def verifyDataMovement(entranceNode, dest, data, sock, msgQ, dataId=None):
if dataId == None:
dataId = MsgFactory.generateMessageId(data)
moveData(entranceNode, dest, data, dataId, sock, MsgType.DATA_MSG)
elif dataId != None:
moveData(entranceNode, dest, data, dataId, sock, MsgType.DATA_MOVE_MSG)
while True:
try:
while msgQ.empty() == False:
msg = msgQ.get(False)
assert len(msg) == 2
msgIn = cPickle.loads(msg[1])
if msgIn[MsgType.TYPE] == MsgType.DATA_ACK and \
msg[0] == dest and msgIn[MsgType.DATA_ID] == dataId:
msgQ.task_done()
print "Message with id", dataId, " arrived to dest", dest
return
if msgIn[MsgType.TYPE] == MsgType.DATA_NACK \
and msgIn[MsgType.DATA_ID] == dataId:
msgQ.task_done()
print "Message with id", dataId, " was not in the dest", msg[0]
return
except Empty:
continue
def testBidirectionalChannel(sock, msgInQ, msgOutQ):
mCheck=0
packet = MsgFactory.create(MsgType.AGENT_TEST_MSG)
for k in Nodes.keys():
msg = [Nodes[k]['name'], packet]
sock.send_multipart(msg)
while True:
try:
while msgInQ.empty() == False:
msg = msgInQ.get(False)
Nodes[msg[0]]['status'] = NodeStatus.DRIVER_FUNCTIONAL
msgInQ.task_done()
msgOutQ.put([msg[0], "ack"])
mCheck+=1
if mCheck==len(Nodes.keys()):
print 'Received all ACK messages'
return
except Empty:
if mCheck == 3:
break
else:
print 'Exception'
continue
def procPeerRxPathReversalMsg(self, stream, rxMsg, sender, pureMsg):
logging.debug("\t[PR-LOG] Sending PR_ACK to:"+str(sender))
ackMsg = MsgFactory.create(MsgType.PR_ACK, dst=sender)
stream.send_multipart([self.name, ackMsg])
if rxMsg[MsgType.DST] != self.name:
if rxMsg[MsgType.TYPE] == MsgType.PR_REQ:
logging.debug("\t[PR-LOG] Forwarding PR_REQ to:"+self.neighbor)
elif rxMsg[MsgType.TYPE] == MsgType.PR_OBJ:
logging.debug("\t[PR-LOG] Forwarding PR_OBJ to:"+self.neighbor)
self.peerCltStream.send_multipart([self.name, pureMsg])
elif rxMsg[MsgType.DST] == self.name:
if rxMsg[MsgType.TYPE] == MsgType.PR_REQ:
txMsg = None
logging.debug("\t[PR-LOG] PR_REQ reached DST")
action, actionArg = self.prMod.recv(self.name, rxMsg)
self.ackAgent()
if action == PRNext.FORWARD:
logging.debug("\t[PR-LOG] New Request FWD to:"+actionArg)
txMsg = MsgFactory.create(MsgType.PR_REQ,
dst=actionArg,
src=rxMsg[MsgType.SOURCE])
elif action == PRNext.TX_OBJ:
logging.debug("\t[PR-LOG] Serving OBJECT to:"+rxMsg[MsgType.SOURCE])
txMsg = MsgFactory.create(MsgType.PR_OBJ,
dst=rxMsg[MsgType.SOURCE],
data=actionArg,
src=self.name)
self.peerCltStream.send_multipart([self.name, txMsg])
elif rxMsg[MsgType.TYPE] == MsgType.PR_OBJ:
logging.debug("\t[PR-LOG] Received OBJECT from:"+rxMsg[MsgType.SOURCE])
self.prMod.becomeEating(rxMsg[MsgType.DATA])
logging.debug("\t[PR-LOG] Inform the server about EATING")
self.ackAgent(satisfy=True)
def becomeHungry(self, issuerNetName):
if self.status == PRStatus.THINKING:
self.status = PRStatus.HUNGRY
prReq = MsgFactory.create(MsgType.PR_REQ, dst=self.last, src=issuerNetName)
self.logger.debug("\t[PR-LOG] Status: HUNGRY")
last = self.last
self.last = None
return prReq, last
return False
def procPeerRxServerMsg(self, stream, msg):
logging.debug("\tReceived message...")
rxMsg = cPickle.loads(msg[1])
logging.debug("GENERIC:\t"+str(rxMsg))
if rxMsg[MsgType.TYPE] == MsgType.PR_REQ or \
rxMsg[MsgType.TYPE] == MsgType.PR_OBJ:
self.procPeerRxPathReversalMsg(stream, rxMsg, msg[0], msg[1])
if rxMsg[MsgType.TYPE] == MsgType.KEEP_ALIVE:
logging.debug('\tReceived KEEP_ALIVE message from:\t'+str(msg[0]))
logging.debug('\tSending a KEEP_ALIVE_ACK message to:\t'+str(msg[0]))
msgOut = MsgFactory.create(MsgType.KEEP_ALIVE_ACK, msg[0])
try:
stream.send_multipart([self.name, msgOut])
except TypeError as e:
logging.debug(e.message())
if rxMsg[MsgType.TYPE] == MsgType.DATA_MSG:
did = rxMsg[MsgType.DATA_ID]
logging.debug('\tReceived DATA_MSG message from:\t'+str(msg[0])+
" with id\t"+did)
msgOut = MsgFactory.create(MsgType.DATA_ACK, None, None, did, None)
logging.debug('\tSending DATA_ACK message to:\t'+str(msg[0]))
stream.send_multipart([self.name, msgOut])
if rxMsg[MsgType.DST] == self.name:
self.dataObject = deepcopy(rxMsg[MsgType.DATA])
self.dataObjectId = rxMsg[MsgType.DATA_ID]
logging.debug('\t[PR-LOG]DATA_MSG destination reached with id:'+
str(self.dataObjectId))
logging.debug('\tSending DATA_ACK to Agent')
msgOutDatAck = MsgFactory.create(MsgType.DATA_ACK, None, None, did, None)
self.streamCmdOut.send_multipart([self.name, msgOutDatAck])
else:
logging.debug("\tIncoming DATA_MSG needs forwarding")
logging.debug("\tForwarding DATA_MSG("+str(did)+") to neighbor:\t"+
str(self.neighbor))
self.peerCltStream.send_multipart([self.name, msg[1]])
def ackOrForward(self, msgIn, caseExisting=False, caseNACK=False):
did = msgIn[MsgType.DATA_ID]
if msgIn[MsgType.DST] == self.name or caseNACK == True:
if caseNACK == False:
msgOut = MsgFactory.create(MsgType.DATA_ACK, dataId=did)
logging.debug("\tObject\t"+str(did)+" is home. Sending ACK to the agent")
else:
msgOut = MsgFactory.create(MsgType.DATA_NACK, dataId=did)
logging.debug("\t Object\t"+str(did)+" is NOT home. Sending NACK to the agent")
self.streamCmdOut.send_multipart([self.name, msgOut])
self.streamCmdOut.flush()
else:
if caseExisting == True:
msgIn[MsgType.TYPE] = MsgType.DATA_MSG
msgOut = [self.name, cPickle.dumps(msgIn)]
logging.debug("\tIncoming DATA_MSG needs forwarding")
logging.debug("\tForwarding DATA_MSG("+str(did)+") to neighbor:\t"+
str(self.neighbor))
self.peerSockClt.send_multipart(msgOut)
def playScenario(scenarioFile, peerSock, inQueue, outQueue, sinkServer):
hungryNodes = []
counter = 1
scenario = buildScenario(scenarioFile)
logging.basicConfig(level=logging.INFO, filename=LOGFILE)
initiateGraph(scenario)
drawGraph(graphNetXLast, "graphProgress/graph_stepL_000.png", "step000")
for cmd in scenario:
try:
updateAck = inQueue.get(True, timeout=1)
inQueue.task_done()
node, statusAck = verifyOperation(updateAck, hungryNodes, counter)
counter+=1
print 'Sending ACK back to the ', node
outQueue.put([node, statusAck])
except Empty:
pass
if cmd['ACTION'] == 'sleep':
print 'Waiting for ', cmd['ARG']
sleep(int(cmd['ARG']))
elif cmd['ACTION'] == 'set':
dataItem = str(choice(xrange(1000)))
dataId = MsgFactory.generateMessageId(dataItem)
txMsg = MsgFactory.create(MsgType.PR_SETUP,
dst=cmd['ARG'],
data=dataItem,
dataId=dataId)
print 'Setting object', dataItem, 'to node:', cmd['ARG']
peerSock.send_multipart(['Set', txMsg])
elif cmd['ACTION'] == 'reset':
print 'Reseting nodes'
peerSock.send_string('Reset')
elif cmd['ACTION'] == 'hungry':
hungryNodes.append(cmd['ARG'])
print 'Set Hungry node ', cmd['ARG']
txMsg = MsgFactory.create(MsgType.PR_GET_HUNGRY, dst=cmd['ARG'])
peerSock.send_multipart([cmd['ARG'], txMsg])
elif cmd['ACTION'] == 'exit':
print 'Exiting'
print 'Creating videos'
#createVideo()
peerSock.send_string('Exit')
inQueue.join()
outQueue.join()
sinkServer.join()
for n in NodeProcesses:
print n, n.is_alive()
n.join()
n.terminate()
system("killall -9 python")
def moveData(entranceNode, dest, data=None, dataId=None, sock=None, msgtype=None):
packet = MsgFactory.create(msgtype, dest, data, dataId)
netMsg = [entranceNode, packet]
sock.send_multipart(netMsg)
def procAgentCmd(self, stream, msg):
if msg[0] == 'Exit':
logging.debug("Received exit")
stream.stop_on_recv()
self.nodeIloop.stop()
if msg[0] == 'ConnectToNeighbor':
logging.debug("\tConnectingToNeighbor CMD arrived")
self.peerSockClt = self.context.socket(zmq.REQ)
self.peerSockClt.connect(self.neighborAddr)
self.peerCltStream = zmqstream.ZMQStream(self.peerSockClt)
self.peerCltStream.on_recv(self.procPeerRxClientMsg)
self.peerCltStream.on_send(self.procPeerTxClientMsg)
if msg[0] == 'TestConnectionToNeighbor':
logging.debug('\tTestConnection With the Peer-Neighbor')
msgOut = MsgFactory.create(MsgType.KEEP_ALIVE,
self.neighbor)
self.peerSockClt.send_multipart([self.name, msgOut])
if msg[0] == 'Reset':
logging.debug('\tServer send RESET message')
self.prMod.reset()
if msg[0] == 'Echo':
logging.debug("\t Server sends echo message: "+(str(msg[1])))
if msg[0] == 'Set':
logging.debug('\tServer send SET message')
rxMsg = cPickle.loads(msg[1])
itemHolder = rxMsg[MsgType.DST]
item = None
if itemHolder == self.name:
logging.debug("\tInitial object holder from Server's SET")
item = rxMsg[MsgType.DATA]
if self.prMod == None:
self.prMod = PathReversal(itemHolder, item, logging)
else:
self.prMod.set(itemHolder,item, logging)
if len(msg) > 1:
rxMsg = cPickle.loads(msg[1])
if rxMsg[MsgType.TYPE] == MsgType.AGENT_TEST_MSG:
logging.debug('\tReceived Test from Agent')
msgOut = MsgFactory.create(MsgType.AGENT_TETS_ACK)
self.streamCmdOut.send_multipart([self.name, msgOut], callback=self.cmdOutRequestToSink)
elif rxMsg[MsgType.TYPE] == MsgType.DATA_MOVE_MSG:
logging.debug("Received DATA_MOVE_MSG request")
if self.dataObjectId == rxMsg[MsgType.DATA_ID]:
self.ackOrForward(rxMsg, caseExisting=True)
else:
self.ackOrForward(rxMsg, caseExisting=True, caseNACK=True)
elif rxMsg[MsgType.TYPE] == MsgType.DATA_MSG:
logging.debug('\t[PR-LOG]Received Data Message from Agent with ID:\t'+
str(rxMsg[MsgType.DATA_ID]))
self.ackOrForward(rxMsg, caseExisting=False)
elif rxMsg[MsgType.TYPE] == MsgType.FIFO_STATS_QUERY:
logging.debug("\tReceived FIFO-query-stats message from agent")
self.streamCmdOut.send_multipart([self.name, cPickle.dumps(self.fifoStats)])
elif rxMsg[MsgType.TYPE] == MsgType.PR_GET_HUNGRY:
logging.debug("\tReceived Message from server to get hungry")
txMsg, toWhom = self.prMod.becomeHungry(self.name)
self.ackAgent()
if txMsg != False:
logging.debug("\t[PR-LOG] Sending PR-Request to: "+toWhom)
self.peerCltStream.send_multipart([self.name, txMsg])
elif rxMsg[MsgType.TYPE] == MsgType.PR_STATUS_ACK:
logging.debug("======Incoming status ACK")
print "======Incoming status ACK"
self.statusQueue.put(rxMsg)
return
