def parse_store(self):
log.info("NODE ID: " + self.name)
db = store.get_bucket()
successful_sequence_keys = []
if (self.value is None):
return
try:
#parse the dictionary. Strip values of every sequence number and add nodeid, absolute server timestamp
for key in self.value.keys():
seq_value = self.value[key]
seq_value.update({'nodeid': self.ip})
seq_value.update({'seq': key})
########################### Testing for generated Sliver and Slice ID. Remove later####################
#rename.rename_sliver(seq_value, self.name)
############################################################################################################
#convert the relative timestamp to absolute server timestamp. Relative timestamps and server receiving the requests are always causally ordered.
server_absolute_timestamp = util.get_timestamp()- float (seq_value['relative_timestamp'])
seq_value.update({'server_timestamp': server_absolute_timestamp})
if not self.type:
seq_value.update({'type': 'node'})
else:
seq_value.update({'type': self.type})
self.most_recent_absolute_timestamp = util.find_recent_timestamp(self.most_recent_absolute_timestamp, server_absolute_timestamp)
# should only fetch the document timestamp and not generate a new one
# print str(server_absolute_timestamp) + "--" + str(key) + "-- time" + str(config.get_timestamp())
doc_id = self.generate_docid(self.name, server_absolute_timestamp)
store.store_document(doc_id,seq_value)
#get and update the last seen sequence number
if(self.value!={}):
sequence = util.get_most_recent_sequence_number(self.value)
self.sequence = sequence #Wouldn't work if the server crashes. Need to persist??
self.most_recent_doc = self.value[str(self.sequence)]
# After all the documents are stored, find the most recent timestamp and update the reference document to speedup lookups
reference_doc_id = self.generate_reference_docid(self.name)
self.most_recent_doc.update({"most_recent_timestamp": self.most_recent_absolute_timestamp})
if not self.type:
self.most_recent_doc.update({"type": "node_most_recent"})
else:
self.most_recent_doc.update({"type": self.type+'_most_recent'})
store.update_document(reference_doc_id, self.most_recent_doc)
except Exception as e:
log.info("Caught Exception: "+str(e))
pass
def generate_view_document ( doc_name, map_function, view_name, reduce_function=None, reduce=False ):
# check if there are entries for same document_id
log.debug("Generating view function: %s with Map function as: %s " %(doc_name, map_function))
if(not reduce):
design = { 'views': {
view_name: {
'map':map_function,
}
}
}
else:
design = { 'views': {
view_name: {
'map':map_function,
'reduce': reduce_function
}
}
}
document_id = '_design/'+ doc_name
store.store_document(document_id, design)
def probe_and_store(hostname):
nodeip6 = hostname
hostname= hostname.lstrip('[')
hostname= hostname.rstrip(']')
values = probe(hostname)
timestamp = util.get_timestamp()
values.update({"server_timestamp":timestamp})
values.update({'nodeid': nodeip6})
values.update({'type': 'node_synthesized'})
doc_id = nodeip6+'-synthesized'+str(timestamp)
try:
store.store_document(doc_id, values)
reference_doc_id = nodeip6+ '-synthesized-most_recent'
values.update({'type' : 'node_most_recent_synthesized'})
store.update_document(reference_doc_id, values)
except Exception as e:
print "Caught Exception: "+ str(e)
pass