public class Table {
int numslots;
- HashMap<IoTString, IoTString> table=new HashMap<IoTString, IoTString>();
+ HashMap<IoTString, KeyValue> table=new HashMap<IoTString, KeyValue>();
+ HashMap<Long, Pair<Long, Liveness>> lastmessagetable=new HashMap<Long, Pair<Long, Liveness>>();
SlotBuffer buffer;
CloudComm cloud;
private Mac hmac;
long sequencenumber;
+ long localmachineid;
- public Table(String baseurl, String password) {
- initCloud(baseurl, password);
+ public Table(String baseurl, String password, long _localmachineid) {
+ localmachineid=_localmachineid;
buffer = new SlotBuffer();
sequencenumber = 1;
+ initCloud(baseurl, password);
}
private void initCloud(String baseurl, String password) {
validateandupdate(newslots);
}
+ public IoTString get(IoTString key) {
+ KeyValue kv=table.get(key);
+ if (kv != null)
+ return kv.getValue();
+ else
+ return null;
+ }
+
+ public IoTString put(IoTString key, IoTString value) {
+ return null;
+ }
+
void validateandupdate(Slot[] newslots) {
//The cloud communication layer has checked slot HMACs already
//before decoding
-
if (newslots.length==0)
return;
long firstseqnum=newslots[0].getSequenceNumber();
if (firstseqnum < sequencenumber)
- throw new Error("Server sent older slots!");
+ throw new Error("Server Error: Sent older slots!");
- checkHMACChain(newslots);
+ SlotIndexer indexer = new SlotIndexer(newslots, buffer);
+ checkHMACChain(indexer, newslots);
+ for(Slot slot: newslots) {
+ processSlot(indexer, slot);
+ }
- if (firstseqnum == (buffer.getNewestSeqNum()+1)) {
- //contiguous update
- } else {
- //non-contiguous update
+ }
+
+ void processEntry(KeyValue entry, SlotIndexer indexer) {
+ IoTString key=entry.getKey();
+ KeyValue oldvalue=table.get(key);
+ if (oldvalue != null) {
+ oldvalue.decrementLiveCount();
}
+ table.put(key, entry);
+ }
+ void processEntry(LastMessage entry, SlotIndexer indexer) {
+ updateLastMessage(entry.getMachineID(), entry.getSequenceNumber(), entry);
+ }
+
+ void processEntry(RejectedMessage entry, SlotIndexer indexer) {
+ long oldseqnum=entry.getOldSeqNum();
+ long newseqnum=entry.getNewSeqNum();
+ boolean isequal=entry.getEqual();
+ long machineid=entry.getMachineID();
+ for(long seqnum=oldseqnum;seqnum<=newseqnum;seqnum++) {
+ Slot slot=indexer.getSlot(seqnum);
+ if (slot != null) {
+ long slotmachineid=slot.getMachineID();
+ if (isequal!=(slotmachineid==machineid)) {
+ throw new Error("Server Error: Trying to insert rejected message for slot "+seqnum);
+ }
+ }
+ }
+ }
+
+ void processEntry(TableStatus entry, SlotIndexer indexer, Slot slot) {
}
- void checkHMACChain(Slot[] newslots) {
- if (newslots[0].getSequenceNumber() == (buffer.getNewestSeqNum()+1)) {
- Slot prevslot=buffer.getSlot(buffer.getNewestSeqNum());
- Slot currslot=newslots[0];
- if (!Arrays.equals(prevslot.getHMAC(), currslot.getPrevHMAC()))
- throw new Error("Error in HMAC Chain");
+ void updateLastMessage(long machineid, long seqnum, Liveness liveness) {
+ Pair<Long, Liveness> lastmsgentry = lastmessagetable.put(machineid, new Pair<Long, Liveness>(seqnum, liveness));
+ if (lastmsgentry == null)
+ return;
+
+ long lastmsgseqnum = lastmsgentry.getFirst();
+ Liveness lastentry = lastmsgentry.getSecond();
+ if (lastentry instanceof LastMessage) {
+ ((LastMessage)lastentry).decrementLiveCount();
+ } else if (lastentry instanceof Slot) {
+ ((Slot)lastentry).decrementLiveCount();
+ } else {
+ throw new Error("Unrecognized type");
+ }
+
+ //Check that nothing funny happened
+ if (machineid == localmachineid) {
+ if (lastmsgseqnum != seqnum)
+ throw new Error("Server Error: Mismatch on local machine sequence number");
+ } else {
+ if (lastmsgseqnum > seqnum)
+ throw new Error("Server Error: Rolback on remote machine sequence number");
}
+ }
+
+ void processSlot(SlotIndexer indexer, Slot slot) {
+ updateLastMessage(slot.getMachineID(), slot.getSequenceNumber(), slot);
- for(int i=1; i < newslots.length; i++) {
- Slot prevslot=newslots[i-1];
- Slot currslot=newslots[i];
- if (!Arrays.equals(prevslot.getHMAC(), currslot.getPrevHMAC()))
- throw new Error("Error in HMAC Chain");
+ for(Entry entry : slot.getEntries()) {
+ switch(entry.getType()) {
+ case Entry.TypeKeyValue:
+ processEntry((KeyValue)entry, indexer);
+ break;
+ case Entry.TypeLastMessage:
+ processEntry((LastMessage)entry, indexer);
+ break;
+ case Entry.TypeRejectedMessage:
+ processEntry((RejectedMessage)entry, indexer);
+ break;
+ case Entry.TypeTableStatus:
+ processEntry((TableStatus)entry, indexer, slot);
+ break;
+ default:
+ throw new Error("Unrecognized type: "+entry.getType());
+ }
}
}
+ void checkHMACChain(SlotIndexer indexer, Slot[] newslots) {
+ for(int i=0; i < newslots.length; i++) {
+ Slot currslot=newslots[i];
+ Slot prevslot=indexer.getSlot(currslot.getSequenceNumber()-1);
+ if (prevslot != null &&
+ !Arrays.equals(prevslot.getHMAC(), currslot.getPrevHMAC()))
+ throw new Error("Server Error: Invalid HMAC Chain");
+ }
+ }
}