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
#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:
completePathVir = SC.virTopo.getWeightPath(srcSwitch, dstSwitch)
if not completePathVir:
self.logger.warning("no virual 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.setVirCompletePath(completePathVir)
virEdges = taskInstance.getVirEdges()
# 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)
##################
# 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
virSectorialPath = taskInstance.getVirSectorialPath(nodeToDomian, virEdges)
# backupSectorialPath = taskInstance.getBackupSectorialPath(nodeToDomian)
print virSectorialPath
# 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 virSectorialPath:
send_message = taskInstance.makeDoaminTaskAssign(i)
command = SC._to_commad(send_message)
print "main: ", command
SC.send_no_return_command(command)
taskInstance.addMainUnconfirmDomain(i)
