def taskDelete(self, req): SC = self.SuperController rest = eval(req.body) src = rest['src'] dst = rest['dst'] print 'src,dst: ', src, dst try: taskId_list = SC.task_service[(src, dst)] #taskId = rest[TASK_ID] for taskId in taskId_list: if not assertTaskInDict(taskId): self.logger.info("no task %d" % taskId) return Response(status=200, body='No task %d\n' % taskId) taskInstance = getTask(taskId) # taskInstance1 = getTask(SC.basic_taskId) # allCrossDomains = taskInstance1.getAllDomains() # taskInstance.setDeleteDomains(allCrossDomains) # for i in allCrossDomains: domainId = SC.taskId_domainId[taskId] send_message = taskInstance.makeTaskDeleteMsg(domainId) command =SC._to_commad(send_message) SC.send_no_return_command(command) except: self.logger.warning("There is no flow between %s and %s,maybe it has been deleted", src, dst)
def setNewBackupPath(self, taskId): taskInstance = getTask(taskId) completePathMain = taskInstance.getMainCompletePath() assert len(completePathMain) > 1 # to make sure we set a backupPath for a task having a mainPath mainEdges = taskInstance.getMainEdges() newTopo = self.topo.getNewTopoExceptSE(mainEdges) srcSwitch = taskInstance.getSrcSwtich() dstSwtich = taskInstance.getDstSwitch() if self.trafficBalance: newCompletePathBackup = newTopo.getWeightPath(srcSwitch, dstSwtich) else: newCompletePathBackup = newTopo.getShortestPath(srcSwitch, dstSwtich) if not newCompletePathBackup: self.logger.warning("can not assign a new backupPath for this task ") return taskInstance.setBackupCompletePath(newCompletePathBackup) nodeToDomain = self.topo.nodeToDomainId newBackupSectorialPath = taskInstance.getBackupSectorialPath(nodeToDomain) newAllBackupPathMpls = self.LabelsPool.getLabels(len(newCompletePathBackup)) noUseLabels = taskInstance.assignBackuPathMpls(newAllBackupPathMpls) self.LabelsPool.recycleLabels(noUseLabels) for i in newBackupSectorialPath: send_message = taskInstance.makeDoaminTaskAssign(i, type='backup') command = self._to_commad(send_message) print 'newbackup: ', command self.send_no_return_command(command) taskInstance.addBackupUnconfirmDomain(i)
def setNewBackupPath(self, taskId): taskInstance = getTask(taskId) completePathMain = taskInstance.getMainCompletePath() assert len(completePathMain) > 1 # to make sure we set a backupPath for a task having a mainPath mainEdges = taskInstance.getMainEdges() newTopo = self.topo.getNewTopoExceptSE(mainEdges) srcSwitch = taskInstance.getSrcSwtich() dstSwtich = taskInstance.getDstSwitch() if self.trafficBalance: newCompletePathBackup = newTopo.getWeightPath(srcSwitch, dstSwtich) else: newCompletePathBackup = newTopo.getShortestPath(srcSwitch, dstSwtich) if not newCompletePathBackup: self.logger.warning("can not assign a new backupPath for this task ") return taskInstance.setBackupCompletePath(newCompletePathBackup) nodeToDomain = self.topo.nodeToDomainId newBackupSectorialPath = taskInstance.getBackupSectorialPath(nodeToDomain) newAllBackupPathMpls = self.LabelsPool.getLabels(len(newCompletePathBackup)) noUseLabels = taskInstance.assignBackuPathMpls(newAllBackupPathMpls) self.LabelsPool.recycleLabels(noUseLabels) for i in newBackupSectorialPath: send_message = taskInstance.makeDomainTaskAssign(i, type='backup') command = self._to_commad(send_message) print 'newbackup: ', command self.send_no_return_command(command) taskInstance.addBackupUnconfirmDomain(i)
def taskAssignReply(self, jsonMsg, SC): assert jsonMsg[TYPE] == 'taskAssignReply' taskId = jsonMsg[TASK_ID] src = jsonMsg['src'] dst = jsonMsg['dst'] try: taskInstance = getTask(taskId) except: self.logger.warning( "receive a task assign reply to a task not assign") return domainId = jsonMsg[DOMAINID] pathType = jsonMsg[PATHTYPE] if pathType == 'main': print 'receive main reply from domain' + str(domainId) print 'Link between ' + str(src) + ' and ' + str( dst) + ' has been established!' taskInstance.removeMainUnconfirmDomain(domainId) if pathType == 'backup': print 'receive backup reply' taskInstance.removeBackupUnconfirmDomain(domainId) if taskInstance.checkTaskStatus(): self.logger.info("Task %d Established" % taskId)
def taskDeleteReply(self, jsonMsg, SC): assert jsonMsg[TYPE] == 'taskDeleteReply' taskId = jsonMsg[TASK_ID] if not assertTaskInDict(taskId): self.logger.info("No such task") return taskInstance = getTask(taskId) # taskInstance = Task(1) domainId = jsonMsg[DOMAINID] allDeleteDomians = taskInstance.getDeleteDomains() assert domainId in allDeleteDomians taskInstance.removeDeleteDomain(domainId) if taskInstance.isCheckToDelete(): allLabels = taskInstance.getAllMpls() SC.LabelsPool.recycleLabels(allLabels) delTask(taskId) self.logger.info("Task %d deleted" % taskId)
def taskAssignReply(self, jsonMsg, SC): assert jsonMsg[TYPE] == 'taskAssignReply' taskId = jsonMsg[TASK_ID] src = jsonMsg['src'] dst = jsonMsg['dst'] try: taskInstance = getTask(taskId) except: self.logger.warning("receive a task assign reply to a task not assign") return domainId = jsonMsg[DOMAINID] pathType = jsonMsg[PATHTYPE] if pathType == 'main': print 'receive main reply from domain'+str(domainId) print 'Link between '+str(src)+' and '+str(dst)+' has been established!' taskInstance.removeMainUnconfirmDomain(domainId) if pathType == 'backup': print 'receive backup reply' taskInstance.removeBackupUnconfirmDomain(domainId) if taskInstance.checkTaskStatus(): self.logger.info("Task %d Established" % taskId)
def makeTaskInstance(self): taskId = self.TaskPool.get_taskid() if not taskId: return Response(status=200, body="there is no task Id\n") #if taskid and task object have been registered,return a task object ,or instantiate a task object if assertTaskInDict(taskId): return getTask(taskId) else: return Task(taskId)
def startBackupHandler(self, taskId): taskInstance = getTask(taskId) backupPathDomains = taskInstance.getBackupCrossDomains() if not backupPathDomains: self.logger.info('NO Backup Path for this Task') return mainPathDomains = taskInstance.getMainCrossDomains() handlerDomains = self._add_diff_from_list(backupPathDomains, mainPathDomains) for domainId in handlerDomains: self.sendStartBackupPathMsg(domainId, taskId) taskInstance.changeBackupToMain()
def taskDelete(self, req): SC = self.SuperController rest = eval(req) taskId = rest[TASK_ID] if not assertTaskInDict(taskId): self.logger.info("no task %d" % taskId) return Response(status=200, body='No task %d\n' % taskId) taskInstance = getTask(taskId) allCrossDomains = taskInstance.getAllDomains() taskInstance.setDeleteDomains(allCrossDomains) for i in allCrossDomains: send_message = taskInstance.makeTaskDeleteMsg(i) command = SC._to_commad(send_message) SC.send_no_return_command(command)
def taskDelete(self, req): SC = self.SuperController rest = eval(req) taskId = rest[TASK_ID] if not assertTaskInDict(taskId): self.logger.info("no task %d" % taskId) return Response(status=200, body='No task %d\n' % taskId) taskInstance = getTask(taskId) allCrossDomains = taskInstance.getAllDomains() taskInstance.setDeleteDomains(allCrossDomains) for i in allCrossDomains: send_message = taskInstance.makeTaskDeleteMsg(i) command =SC._to_commad(send_message) SC.send_no_return_command(command)
def taskAssignReply(self, jsonMsg, SC): assert jsonMsg[TYPE] == 'taskAssignReply' taskId = jsonMsg[TASK_ID] try: taskInstance = getTask(taskId) except: self.logger.warning("receive a task assign reply to a task not assign") return domainId = jsonMsg[DOMAINID] pathType = jsonMsg[PATHTYPE] if pathType == 'main': print 'receive main reply' taskInstance.removeMainUnconfirmDomain(domainId) if pathType == 'backup': print 'receive backup reply' taskInstance.removeBackupUnconfirmDomain(domainId) if taskInstance.checkTaskStatus(): self.logger.info("Task %d Established" % taskId)
def taskAssignReply(self, jsonMsg, SC): assert jsonMsg[TYPE] == 'taskAssignReply' taskId = jsonMsg[TASK_ID] try: taskInstance = getTask(taskId) except: self.logger.warning( "receive a task assign reply to a task not assign") return domainId = jsonMsg[DOMAINID] pathType = jsonMsg[PATHTYPE] if pathType == 'main': print 'receive main reply' taskInstance.removeMainUnconfirmDomain(domainId) if pathType == 'backup': print 'receive backup reply' taskInstance.removeBackupUnconfirmDomain(domainId) if taskInstance.checkTaskStatus(): self.logger.info("Task %d Established" % taskId)
def taskAssign(self, req): SC = self.SuperController body = req.body rest = eval(body) taskId = rest[TASK_ID] if not taskId: return Response(status=200, body="Input a task Id\n") if assertTaskInDict(taskId): taskInstance = getTask(taskId) else: taskInstance = Task(taskId) if taskInstance.isEstablished(): return Response(status=200, body="taskId duplicated!\n") srcSwitch = rest[SRC_SWITCH] dstSwitch = rest[DST_SWITCH] bandwith = rest[BANDWIDTH] # duration = rest[] dstIp = rest[DST_IP] srcIp = rest[SRC_IP] local_mac = rest[LOCAL_MAC] next_mac = rest[NEXT_MAC] last_outport_num = rest[LAST_OUTPORT_NUM] taskInstance.taskSetFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcIp=srcIp, dstIp=dstIp, local_mac=local_mac, next_mac=next_mac, last_outport_num=last_outport_num, bandwidth=bandwith) if SC.trafficBalance: completePathMain = SC.topo.getWeightPath(srcSwitch, dstSwitch) if not completePathMain: self.logger.warning("no main path between switch %d and %d" % (srcSwitch, dstSwitch)) return Response( status=200, body="no main path between switch %d and %d\n" % (srcSwitch, dstSwitch)) taskInstance.setMainCompletePath(completePathMain) mainEdges = taskInstance.getMainEdges() newTopo = SC.topo.getNewTopoExceptSE(mainEdges) completePathBackup = newTopo.getWeightPath(srcSwitch, dstSwitch) if not completePathBackup: self.logger.warning("no backup path between switch %d and %d" % (srcSwitch, dstSwitch)) taskInstance.setBackupCompletePath(completePathBackup) else: completePathMath = SC.topo.getShortestPath(srcSwitch, dstSwitch) if not completePathMath: self.logger.warning("no main path between switch %d and %d" % (srcSwitch, dstSwitch)) return Response( status=200, body="no main path between switch %d and %d\n" % (srcSwitch, dstSwitch)) taskInstance.setMainCompletePath(completePathMath) mainEdges = taskInstance.getMainEdges() newTopo = SC.topo.getNewTopoExceptSE(mainEdges) completePathBackup = newTopo.getShorestPath(srcSwitch, dstSwitch) if not completePathBackup: self.logger.warning("no backup path between switch %d and %d" % (srcSwitch, dstSwitch)) taskInstance.setBackupCompletePath(completePathBackup) nodeToDomian = SC.topo.nodeToDomainId mainSectorialPath = taskInstance.getMainSectorialPath(nodeToDomian) backupSectorialPath = taskInstance.getBackupSectorialPath(nodeToDomian) # print mainSectorialPath # print backupSectorialPath allMainPathMpls = SC.LabelsPool.getLabels(len(completePathMain)) noUseLabels = taskInstance.assignMainPathMpls(allMainPathMpls) SC.LabelsPool.recycleLabels(noUseLabels) allBackupPathMpls = SC.LabelsPool.getLabels(len(completePathBackup)) noUseLabels = taskInstance.assignBackuPathMpls(allBackupPathMpls) SC.LabelsPool.recycleLabels(noUseLabels) registerTask(taskInstance) # print "main: ", completePathMain # print "backup: ", completePathBackup # print "nodeToDomain: ", nodeToDomian for i in mainSectorialPath: send_message = taskInstance.makeDoaminTaskAssign(i) command = SC._to_commad(send_message) print "main: ", command SC.send_no_return_command(command) taskInstance.addMainUnconfirmDomain(i) for j in backupSectorialPath: send_message = taskInstance.makeDoaminTaskAssign(j, type='backup') command = SC._to_commad(send_message) print "backup: ", command SC.send_no_return_command(command) taskInstance.addBackupUnconfirmDomain(j)
def taskAssign(self, req): SC = self.SuperController body = req #print repr(req) rest = eval(body) taskId = rest[TASK_ID] if not taskId: return Response(status=200, body="there is no task Id\n") #if taskid and task object have been registered,return a task object ,or instantiate a task object if assertTaskInDict(taskId): taskInstance = getTask(taskId) else: taskInstance = Task(taskId) if taskInstance.isEstablished(): return Response(status=200, body="taskId duplicated!\n") srcSwitch = rest[SRC_SWITCH] dstSwitch = rest[DST_SWITCH] bandwith = rest[BANDWIDTH] # duration = rest[] local_mac = rest[LOCAL_MAC] next_mac = rest[NEXT_MAC] last_outport_num = rest[LAST_OUTPORT_NUM] domain_type = rest[DOMAINTYPE] if domain_type is 'L3': dstIp = rest[DST_IP] srcIp = rest[SRC_IP] taskInstance.taskSetIpFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcIp=srcIp, dstIp=dstIp, local_mac=local_mac, next_mac=next_mac, last_outport_num=last_outport_num, bandwidth=bandwith) #generate a task object else: srcMac = rest['srcMac'] dstMac = rest['dstMac'] #print 'srcMac,dstMac: ',srcMac,dstMac taskInstance.taskSetMacFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcMac=srcMac, dstMac=dstMac, last_outport_num=last_outport_num, bandwidth=bandwith) ########################################################################################################## #print 'SC.virualTopo.topo.edges(): ',SC.virualTopo.topo.edges() #print 'srcSwitch,dstSwitch: ',srcSwitch,dstSwitch completePathVir = SC.virualTopo.getWeightPath(int(srcSwitch), int(dstSwitch)) # print 'New Task src_dpid,dst_dpid: ',srcSwitch,dstSwitch # print 'New Task completePathVir: ', completePathVir # print 'New Task topo: ',SC.virualTopo.edges() #print 'topo: ',SC.virualTopo.edge() if not completePathVir: self.logger.warning( "no virual path between switch %0x16 and %0x16" % (srcSwitch, dstSwitch)) return Response( status=200, body="no main path between switch %0x16 and %0x16\n" % (srcSwitch, dstSwitch)) print "Link calculate success between %0x16 and %0x16:" % ( int(srcSwitch), int(dstSwitch)), completePathVir # allMainPathMpls = SC.LabelsPool.getLabels(len(completePathVir))#n different numbers # noUseLabels = taskInstance.assignMainPathMpls(allMainPathMpls) # SC.LabelsPool.recycleLabels(noUseLabels) taskInstance.setVirCompletePath(completePathVir) virEdges = taskInstance.getVirEdges() # print 'virEdges: ',virEdges nodeToDomain = SC.topo.nodeToDomainId virSectorialPath = taskInstance.getVirSectorialPath( nodeToDomain, virEdges) # print 'virSectorialPath: ', virSectorialPath registerTask(taskInstance) print "Begin send task to Domain." for i in virSectorialPath: send_message = taskInstance.makeDomainTaskAssign(i) # print 'send_message: ', send_message command = SC._to_commad(send_message) # print "main: ", command SC.send_no_return_command(command) taskInstance.addMainUnconfirmDomain(i)
def taskAssign(self, req): SC = self.SuperController body = req rest = eval(body) taskId = rest[TASK_ID] if not taskId: return Response(status=200, body="Input a task Id\n") if assertTaskInDict(taskId): taskInstance = getTask(taskId) else: taskInstance = Task(taskId) if taskInstance.isEstablished(): return Response(status=200, body="taskId duplicated!\n") srcSwitch = rest[SRC_SWITCH] dstSwitch = rest[DST_SWITCH] bandwith = rest[BANDWIDTH] # duration = rest[] dstIp = rest[DST_IP] srcIp = rest[SRC_IP] local_mac = rest[LOCAL_MAC] next_mac = rest[NEXT_MAC] last_outport_num = rest[LAST_OUTPORT_NUM] taskInstance.taskSetFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcIp=srcIp, dstIp=dstIp, local_mac=local_mac, next_mac=next_mac, last_outport_num=last_outport_num, bandwidth=bandwith) if SC.trafficBalance: completePathMain = SC.topo.getWeightPath(srcSwitch, dstSwitch) if not completePathMain: self.logger.warning("no main path between switch %d and %d" % (srcSwitch, dstSwitch)) return Response(status=200, body="no main path between switch %d and %d\n" % (srcSwitch, dstSwitch)) taskInstance.setMainCompletePath(completePathMain) mainEdges = taskInstance.getMainEdges() newTopo = SC.topo.getNewTopoExceptSE(mainEdges) completePathBackup = newTopo.getWeightPath(srcSwitch, dstSwitch) if not completePathBackup: self.logger.warning("no backup path between switch %d and %d" % (srcSwitch, dstSwitch)) taskInstance.setBackupCompletePath(completePathBackup) else: completePathMath = SC.topo.getShortestPath(srcSwitch, dstSwitch) if not completePathMath: self.logger.warning("no main path between switch %d and %d" % (srcSwitch, dstSwitch)) return Response(status=200, body="no main path between switch %d and %d\n" % (srcSwitch, dstSwitch)) taskInstance.setMainCompletePath(completePathMath) mainEdges = taskInstance.getMainEdges() newTopo = SC.topo.getNewTopoExceptSE(mainEdges) completePathBackup = newTopo.getShorestPath(srcSwitch, dstSwitch) if not completePathBackup: self.logger.warning("no backup path between switch %d and %d" % (srcSwitch, dstSwitch)) taskInstance.setBackupCompletePath(completePathBackup) # backupEdges = taskInstance.getBackupEdges() # newTopo = SC.topo.getNewTopoExceptSE(backupEdges) nodeToDomian = SC.topo.nodeToDomainId mainSectorialPath = taskInstance.getMainSectorialPath(nodeToDomian) backupSectorialPath = taskInstance.getBackupSectorialPath(nodeToDomian) # print mainSectorialPath # print backupSectorialPath allMainPathMpls = SC.LabelsPool.getLabels(len(completePathMain)) noUseLabels = taskInstance.assignMainPathMpls(allMainPathMpls) SC.LabelsPool.recycleLabels(noUseLabels) allBackupPathMpls = SC.LabelsPool.getLabels(len(completePathBackup)) noUseLabels = taskInstance.assignBackuPathMpls(allBackupPathMpls) SC.LabelsPool.recycleLabels(noUseLabels) registerTask(taskInstance) # print "main: ", completePathMain # print "backup: ", completePathBackup # print "nodeToDomain: ", nodeToDomian for i in mainSectorialPath: send_message = taskInstance.makeDoaminTaskAssign(i) command = SC._to_commad(send_message) print "main: ", command SC.send_no_return_command(command) taskInstance.addMainUnconfirmDomain(i) for j in backupSectorialPath: send_message = taskInstance.makeDoaminTaskAssign(j, type='backup') command = SC._to_commad(send_message) print "backup: ",command SC.send_no_return_command(command) taskInstance.addBackupUnconfirmDomain(j)
def taskAssign(self, req): SC = self.SuperController body = req #print repr(req) rest = eval(body) taskId = rest[TASK_ID] if not taskId: return Response(status=200, body="there is no task Id\n") #if taskid and task object have been registered,return a task object ,or instantiate a task object if assertTaskInDict(taskId): taskInstance = getTask(taskId) else: taskInstance = Task(taskId) if taskInstance.isEstablished(): return Response(status=200, body="taskId duplicated!\n") srcSwitch = rest[SRC_SWITCH] dstSwitch = rest[DST_SWITCH] bandwith = rest[BANDWIDTH] # duration = rest[] local_mac = rest[LOCAL_MAC] next_mac = rest[NEXT_MAC] last_outport_num = rest[LAST_OUTPORT_NUM] domain_type = rest[DOMAINTYPE] if domain_type is 'L3': dstIp = rest[DST_IP] srcIp = rest[SRC_IP] taskInstance.taskSetIpFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcIp=srcIp, dstIp=dstIp, local_mac=local_mac, next_mac=next_mac, last_outport_num=last_outport_num, bandwidth=bandwith) #generate a task object else: srcMac = rest['srcMac'] dstMac = rest['dstMac'] #print 'srcMac,dstMac: ',srcMac,dstMac taskInstance.taskSetMacFields(srcSwitch=srcSwitch, dstSwitch=dstSwitch, srcMac=srcMac,dstMac=dstMac, last_outport_num=last_outport_num,bandwidth=bandwith) ########################################################################################################## #print 'SC.virualTopo.topo.edges(): ',SC.virualTopo.topo.edges() #print 'srcSwitch,dstSwitch: ',srcSwitch,dstSwitch completePathVir = SC.virualTopo.getWeightPath(int(srcSwitch), int(dstSwitch)) # print 'New Task src_dpid,dst_dpid: ',srcSwitch,dstSwitch # print 'New Task completePathVir: ', completePathVir # print 'New Task topo: ',SC.virualTopo.edges() #print 'topo: ',SC.virualTopo.edge() if not completePathVir: self.logger.warning("no virual path between switch %0x16 and %0x16" % (srcSwitch, dstSwitch)) return Response(status=200, body="no main path between switch %0x16 and %0x16\n" % (srcSwitch, dstSwitch)) print "Link calculate success between %0x16 and %0x16:"%(int(srcSwitch), int(dstSwitch)),completePathVir # allMainPathMpls = SC.LabelsPool.getLabels(len(completePathVir))#n different numbers # noUseLabels = taskInstance.assignMainPathMpls(allMainPathMpls) # SC.LabelsPool.recycleLabels(noUseLabels) taskInstance.setVirCompletePath(completePathVir) virEdges = taskInstance.getVirEdges() # print 'virEdges: ',virEdges nodeToDomain = SC.topo.nodeToDomainId virSectorialPath = taskInstance.getVirSectorialPath(nodeToDomain, virEdges) # print 'virSectorialPath: ', virSectorialPath registerTask(taskInstance) print "Begin send task to Domain." for i in virSectorialPath: send_message = taskInstance.makeDomainTaskAssign(i) # print 'send_message: ', send_message command = SC._to_commad(send_message) # print "main: ", command SC.send_no_return_command(command) taskInstance.addMainUnconfirmDomain(i)