def testMachineType(self, data=TEST_DB_DATA["machine"]):
machineType = MachineType(data["typeID"],
data["numcpu"],
data["numcore"],
data["frequency"],
data["numfpga"],
data["memfpga"],
data["numgpu"],
data["memory"],
data["disk"],
data["typegpu"],
data["typefpga"])
session.add(machineType)
session.commit()
dbType = session.query(MachineType).get("MACHINE")
self.assertEqual(dbType.numcpu,data["numcpu"])
self.assertEqual(dbType.numcore,data["numcore"])
self.assertEqual(dbType.frequency,data["frequency"])
self.assertEqual(dbType.numfpga,data["numfpga"])
self.assertEqual(dbType.memfpga,data["memfpga"])
self.assertEqual(dbType.numgpu,data["numgpu"])
self.assertEqual(dbType.memory,data["memory"])
self.assertEqual(dbType.disk,data["disk"])
self.assertEqual(dbType.typegpu,data["typegpu"])
self.assertEqual(dbType.typefpga,data["typefpga"])
def testStorageType(self, data=TEST_DB_DATA["storage"]):
storageType = StorageType(data["typeID"], data["capacity"],
data["ranbw"], data["seqbw"])
session.add(storageType)
session.commit()
dbType = session.query(StorageType).get("STORAGE")
self.assertEqual(dbType.capacity, data["capacity"])
self.assertEqual(dbType.ranbw, data["ranbw"])
self.assertEqual(dbType.seqbw, data["seqbw"])
def testStorageType(self, data=TEST_DB_DATA["storage"]):
storageType = StorageType(data["typeID"],
data["capacity"],
data["ranbw"],
data["seqbw"])
session.add(storageType)
session.commit()
dbType = session.query(StorageType).get("STORAGE")
self.assertEqual(dbType.capacity, data["capacity"])
self.assertEqual(dbType.ranbw, data["ranbw"])
self.assertEqual(dbType.seqbw, data["seqbw"])
def testRouterType(self, data=TEST_DB_DATA["router"]):
routerType = RouterType(data["typeID"], data["inbw"], data["outbw"],
data["buffer"], data["capacity"],
data["connector"], data["version"])
session.add(routerType)
session.commit()
dbType = session.query(RouterType).get("ROUTER")
self.assertEqual(dbType.inbw, data["inbw"])
self.assertEqual(dbType.outbw, data["outbw"])
self.assertEqual(dbType.buffer, data["buffer"])
self.assertEqual(dbType.capacity, data["capacity"])
self.assertEqual(dbType.connector, data["connector"])
self.assertEqual(dbType.version, data["version"])
def testRouterType(self,data=TEST_DB_DATA["router"]):
routerType = RouterType(data["typeID"],
data["inbw"],
data["outbw"],
data["buffer"],
data["capacity"],
data["connector"],
data["version"])
session.add(routerType)
session.commit()
dbType = session.query(RouterType).get("ROUTER")
self.assertEqual(dbType.inbw,data["inbw"])
self.assertEqual(dbType.outbw,data["outbw"])
self.assertEqual(dbType.buffer,data["buffer"])
self.assertEqual(dbType.capacity,data["capacity"])
self.assertEqual(dbType.connector,data["connector"])
self.assertEqual(dbType.version,data["version"])
def testMachineType(self, data=TEST_DB_DATA["machine"]):
machineType = MachineType(data["typeID"], data["numcpu"],
data["numcore"], data["frequency"],
data["numfpga"], data["memfpga"],
data["numgpu"], data["memory"], data["disk"],
data["typegpu"], data["typefpga"])
session.add(machineType)
session.commit()
dbType = session.query(MachineType).get("MACHINE")
self.assertEqual(dbType.numcpu, data["numcpu"])
self.assertEqual(dbType.numcore, data["numcore"])
self.assertEqual(dbType.frequency, data["frequency"])
self.assertEqual(dbType.numfpga, data["numfpga"])
self.assertEqual(dbType.memfpga, data["memfpga"])
self.assertEqual(dbType.numgpu, data["numgpu"])
self.assertEqual(dbType.memory, data["memory"])
self.assertEqual(dbType.disk, data["disk"])
self.assertEqual(dbType.typegpu, data["typegpu"])
self.assertEqual(dbType.typefpga, data["typefpga"])
def doScheduling(self, appConfig):
"""
Parse the application configuration to get requested resources
"""
machines, storages, routers = self.parseAppConfig(appConfig)
"""
Invoke the IaaS service to get available resources that
satisfy the application configuration
"""
"""
Process machine node
"""
machineIDList = []
machineDesList = []
machinePrice = 0
for i in range(len(machines)):
machineDescriptor = {"machine": machines[i]}
try:
print "........The fifo scheduler gets available" \
" machines for machine description %d from" \
" IaaS and does scheduling" %(i+1)
machineIDs = self.getAvailableNodeList(machineDescriptor,
i + 1)
machineID = machineIDs.pop(0)
while machineID in machineIDList:
machineID = machineIDs.pop(0)
except IndexError:
result = json.dumps({"result": None})
logger.error("Cannot find available machines"
" satisfying requirements")
return result
machinePrice = machinePrice + self.getNodePrice(
machineDescriptor, machineID, 1)
machineDesList.append({machineID: machines[i]})
machineIDList.append(machineID)
# for storing to database
machineInfo = {"machine": machineDesList}
"""
Process storage node
"""
storageIDList = []
storageDesList = []
storagePrice = 0
for i in range(len(storages)):
storageDescriptor = {"storage": storages[i]}
try:
print "........The fifo scheduler gets available" \
" storages for storage description %d from" \
" IaaS and does scheduling" %(i+1)
storageIDs = self.getAvailableNodeList(storageDescriptor,
i + 1)
storageID = storageIDs.pop(0)
while storageID in storageIDList:
storageID = storageIDs.pop(0)
except IndexError:
result = json.dumps({"result": None})
logger.error("Cannot find available storages"
" satisfying requirements")
return result
storagePrice = storagePrice + self.getNodePrice(
storageDescriptor, storageID, 1)
storageDesList.append({storageID: storages[i]})
storageIDList.append(storageID)
# for storing to database
storageInfo = {"storage": storageDesList}
"""
Process router node
"""
routerIDList = []
routerDesList = []
routerPrice = 0
for i in range(len(routers)):
routerDescriptor = {"router": routers[i]}
try:
print "........The fifo scheduler gets available" \
" routers for router description %d from" \
" IaaS and does scheduling" %(i+1)
routerIDs = self.getAvailableNodeList(routerDescriptor, i + 1)
routerID = routerIDs.pop(0)
while routerID in routerIDList:
routerID = routerIDs.pop(0)
except IndexError:
result = json.dumps({"result": None})
logger.error("Cannot find available routers"
" satisfying requirements")
return result
routerPrice = routerPrice + self.getNodePrice(
routerDescriptor, routerID, 1)
routerDesList.append({routerID: routers[i]})
routerIDList.append(routerID)
# for storing to database
routerInfo = {"router": routerDesList}
"""
Store the scheduling result to database
"""
configID = str(uuid.uuid4())
# currently we do not process network scheduling
networkInfo = ""
acs = AppConfigSchedule(configID, json.dumps(storageInfo),
json.dumps(machineInfo),
json.dumps(networkInfo),
json.dumps(routerInfo))
session.add(acs)
session.commit()
"""
Return scheduling result to users to inform them the price
"""
totalPrice = machinePrice + storagePrice + routerPrice
result = json.dumps({
"result": {
"schedule": [machineInfo, storageInfo, routerInfo],
"price": totalPrice,
"configID": configID
}
})
return result
def doScheduling(self, appConfig):
"""
Parse the application configuration to get requested resources
"""
machines, storages, routers = self.parseAppConfig(appConfig)
"""
Invoke the IaaS service to get available resources that
satisfy the application configuration
"""
"""
Process machine node
"""
machineIDList = []
machineDesList = []
machinePrice = 0
for i in range(len(machines)):
machineDescriptor = {"machine":machines[i]}
try:
print "........The fifo scheduler gets available" \
" machines for machine description %d from" \
" IaaS and does scheduling" %(i+1)
machineIDs = self.getAvailableNodeList(machineDescriptor, i+1)
machineID = machineIDs.pop(0)
while machineID in machineIDList:
machineID = machineIDs.pop(0)
except IndexError:
result = json.dumps({"result":None})
logger.error("Cannot find available machines"
" satisfying requirements")
return result
machinePrice = machinePrice + self.getNodePrice(machineDescriptor,
machineID, 1)
machineDesList.append({machineID:machines[i]})
machineIDList.append(machineID)
# for storing to database
machineInfo = {"machine":machineDesList}
"""
Process storage node
"""
storageIDList = []
storageDesList = []
storagePrice = 0
for i in range(len(storages)):
storageDescriptor = {"storage":storages[i]}
try:
print "........The fifo scheduler gets available" \
" storages for storage description %d from" \
" IaaS and does scheduling" %(i+1)
storageIDs = self.getAvailableNodeList(storageDescriptor, i+1)
storageID = storageIDs.pop(0)
while storageID in storageIDList:
storageID = storageIDs.pop(0)
except IndexError:
result = json.dumps({"result":None})
logger.error("Cannot find available storages"
" satisfying requirements")
return result
storagePrice = storagePrice + self.getNodePrice(storageDescriptor,
storageID, 1)
storageDesList.append({storageID:storages[i]})
storageIDList.append(storageID)
# for storing to database
storageInfo = {"storage":storageDesList}
"""
Process router node
"""
routerIDList = []
routerDesList = []
routerPrice = 0
for i in range(len(routers)):
routerDescriptor = {"router":routers[i]}
try:
print "........The fifo scheduler gets available" \
" routers for router description %d from" \
" IaaS and does scheduling" %(i+1)
routerIDs = self.getAvailableNodeList(routerDescriptor, i+1)
routerID = routerIDs.pop(0)
while routerID in routerIDList:
routerID = routerIDs.pop(0)
except IndexError:
result = json.dumps({"result":None})
logger.error("Cannot find available routers"
" satisfying requirements")
return result
routerPrice = routerPrice + self.getNodePrice(routerDescriptor,
routerID, 1)
routerDesList.append({routerID:routers[i]})
routerIDList.append(routerID)
# for storing to database
routerInfo = {"router":routerDesList}
"""
Store the scheduling result to database
"""
configID = str(uuid.uuid4())
# currently we do not process network scheduling
networkInfo = ""
acs = AppConfigSchedule(configID,
json.dumps(storageInfo),
json.dumps(machineInfo),
json.dumps(networkInfo),
json.dumps(routerInfo))
session.add(acs)
session.commit()
"""
Return scheduling result to users to inform them the price
"""
totalPrice = machinePrice + storagePrice + routerPrice
result = json.dumps({"result":
{"schedule":[machineInfo,
storageInfo,
routerInfo],
"price":totalPrice,
"configID":configID
}
})
return result
def beforeFirstRequest():
session.add(MachineType("MACHINE_TYPE_1",
cloud_infra.MACHINE_TYPE_1["numcpu"],
cloud_infra.MACHINE_TYPE_1["numcore"],
cloud_infra.MACHINE_TYPE_1["frequency"],
cloud_infra.MACHINE_TYPE_1["numfpga"],
cloud_infra.MACHINE_TYPE_1["memfpga"],
cloud_infra.MACHINE_TYPE_1["numgpu"],
cloud_infra.MACHINE_TYPE_1["memory"],
cloud_infra.MACHINE_TYPE_1["disk"],
cloud_infra.MACHINE_TYPE_1["typegpu"],
cloud_infra.MACHINE_TYPE_1["typefpga"]))
for i in range(cloud_infra.MACHINE_TYPE_1["quantity"]):
session.add(MachineResource("/dc1/rack1/machine%s/machine:" %i,
"MACHINE_TYPE_1"))
session.add(MachineType("MACHINE_TYPE_2",
cloud_infra.MACHINE_TYPE_2["numcpu"],
cloud_infra.MACHINE_TYPE_2["numcore"],
cloud_infra.MACHINE_TYPE_2["frequency"],
cloud_infra.MACHINE_TYPE_2["numfpga"],
cloud_infra.MACHINE_TYPE_2["memfpga"],
cloud_infra.MACHINE_TYPE_2["numgpu"],
cloud_infra.MACHINE_TYPE_2["memory"],
cloud_infra.MACHINE_TYPE_2["disk"],
cloud_infra.MACHINE_TYPE_2["typegpu"],
cloud_infra.MACHINE_TYPE_2["typefpga"]))
for i in range(cloud_infra.MACHINE_TYPE_2["quantity"]):
session.add(MachineResource("/dc2/rack1/machine%s/machine:" %i,
"MACHINE_TYPE_2"))
session.add(MachineType("MACHINE_TYPE_3",
cloud_infra.MACHINE_TYPE_3["numcpu"],
cloud_infra.MACHINE_TYPE_3["numcore"],
cloud_infra.MACHINE_TYPE_3["frequency"],
cloud_infra.MACHINE_TYPE_3["numfpga"],
cloud_infra.MACHINE_TYPE_3["memfpga"],
cloud_infra.MACHINE_TYPE_3["numgpu"],
cloud_infra.MACHINE_TYPE_3["memory"],
cloud_infra.MACHINE_TYPE_3["disk"],
cloud_infra.MACHINE_TYPE_3["typegpu"],
cloud_infra.MACHINE_TYPE_3["typefpga"]))
for i in range(cloud_infra.MACHINE_TYPE_3["quantity"]):
session.add(MachineResource("/dc2/rack2/machine%s/machine:" %i,
"MACHINE_TYPE_3"))
session.add(RouterType("ROUTER_TYPE_1",
cloud_infra.ROUTER_TYPE_1["inbw"],
cloud_infra.ROUTER_TYPE_1["outbw"],
cloud_infra.ROUTER_TYPE_1["buffer"],
cloud_infra.ROUTER_TYPE_1["capacity"],
cloud_infra.ROUTER_TYPE_1["connector"],
cloud_infra.ROUTER_TYPE_1["version"]))
for i in range(cloud_infra.ROUTER_TYPE_1["quantity"]):
session.add(RouterResource("/dc1/rack1/router%s/router:" %i,
"ROUTER_TYPE_1"))
session.add(RouterType("ROUTER_TYPE_2",
cloud_infra.ROUTER_TYPE_2["inbw"],
cloud_infra.ROUTER_TYPE_2["outbw"],
cloud_infra.ROUTER_TYPE_2["buffer"],
cloud_infra.ROUTER_TYPE_2["capacity"],
cloud_infra.ROUTER_TYPE_2["connector"],
cloud_infra.ROUTER_TYPE_2["version"]))
for i in range(cloud_infra.ROUTER_TYPE_2["quantity"]):
session.add(RouterResource("/dc2/rack1/router%s/router:" %i,
"ROUTER_TYPE_2"))
session.add(StorageType("STORAGE_TYPE_1",
cloud_infra.STORAGE_TYPE_1["capacity"],
cloud_infra.STORAGE_TYPE_1["ranbw"],
cloud_infra.STORAGE_TYPE_1["seqbw"]))
for i in range(cloud_infra.STORAGE_TYPE_1["quantity"]):
session.add(StorageResource("/dc1/rack1/storage%s/storage:" %i,
"STORAGE_TYPE_1"))
session.add(StorageType("STORAGE_TYPE_2",
cloud_infra.STORAGE_TYPE_2["capacity"],
cloud_infra.STORAGE_TYPE_2["ranbw"],
cloud_infra.STORAGE_TYPE_2["seqbw"]))
for i in range(cloud_infra.STORAGE_TYPE_2["quantity"]):
session.add(StorageResource("/dc2/rack1/storage%s/storage:" %i,
"STORAGE_TYPE_2"))
session.commit()