def get_CDN(self):
return [(s, self.servicetopo.node[s]["mapping"],
self.servicetopo.node[s]["bandwidth"])
for s in get_nodes_by_type("CDN", self.servicetopo)]
def compute_service_topo(self, substrate, mapped_start_nodes, mapped_cdn_nodes, vhg_count, vcdn_count, delay,
hint_node_mappings=None):
vhg_count = min(len(mapped_start_nodes), vhg_count)
vcdn_count = min(vcdn_count, vhg_count)
vmg_calc = get_vmg_calculator()
vcdn_calc = get_vcdn_calculator()
service = nx.DiGraph()
for i in range(1, vhg_count + 1):
service.add_node("VHG%d" % i, type="VHG", ratio=1, bandwidth=0)
for i in range(1, vcdn_count + 1):
service.add_node("VCDN%d" % i, type="VCDN", cpu=0, delay=delay, ratio=0.35, bandwidth=0)
for index, cdn in enumerate(mapped_cdn_nodes, start=1):
service.add_node("CDN%d" % index, type="CDN", cpu=0, ratio=0.65, name="CDN%d" % index, bandwidth=0,
mapping=cdn.topoNode.name)
for key, slaNodeSpec in enumerate(mapped_start_nodes, start=1):
service.add_node("S%d" % key, cpu=0, type="S", mapping=slaNodeSpec.topoNode.name, bandwidth=0)
# create s<-> vhg edges
score, cluster = get_node_clusters(map(lambda x: x.topoNode.name, mapped_start_nodes), vhg_count,
substrate=substrate)
for toponode_name, vmg_id in cluster.items():
s = [n[0] for n in service.nodes(data=True) if n[1].get("mapping", None) == toponode_name][0]
service.add_edge(s, "VHG%d" % vmg_id, delay=sys.maxint, bandwidth=0)
# create vhg <-> vcdn edges
# here, each S "votes" for a vCDN and tell its VHG
for i in range(1,5):
score, _ = get_node_clusters(map(lambda x: x.topoNode.name, mapped_start_nodes), i, substrate=substrate)
#print score
score, cluster = get_node_clusters(map(lambda x: x.topoNode.name, mapped_start_nodes), vcdn_count,substrate=substrate)
for toponode_name, vCDN_id in cluster.items():
# get the S from the toponode_id
s = [n[0] for n in service.nodes(data=True) if n[1].get("mapping", None) == toponode_name][0]
vcdn = "VCDN%d" % vCDN_id
# get the vhg from the S
vhg = service[s].items()[0][0]
# apply the votes
if "votes" not in service.node[vhg]:
service.node[vhg]["votes"] = collections.defaultdict(lambda: {})
service.node[vhg]["votes"][vcdn] = 1
else:
service.node[vhg]["votes"][vcdn] = service.node[vhg]["votes"].get(vcdn, 0) + 1
# create the edge according to the votes
for vhg in [n[0] for n in service.nodes(data=True) if n[1].get("type") == "VHG"]:
votes = service.node[vhg]["votes"]
winners = max(votes.iteritems(), key=operator.itemgetter(1))
if len(winners) == 1:
service.add_edge(vhg, winners[0], bandwidth=0)
else:
service.add_edge(vhg, winners[0], bandwidth=0)
# delay path
delay_path = {}
delay_route = collections.defaultdict(lambda: [])
for vcdn in get_nodes_by_type("VCDN", service):
for s in get_nodes_by_type("S", service):
try:
sp = shortest_path(service, s, vcdn)
key = "_".join(sp)
delay_path[key] = delay
for i in range(len(sp) - 1):
delay_route[key].append((sp[i], sp[i + 1]))
except:
continue
# add CDN edges if available
try:
if hint_node_mappings is not None:
vhg_mapping = [(nmapping.node.name, nmapping.service_node.name) for nmapping in hint_node_mappings if
"VHG" in nmapping.service_node.name]
cdn_mapping = [(nm.topoNode.name, "CDN%d" % index) for index, nm in
enumerate(mapped_cdn_nodes, start=1)]
for vhg, cdn in get_vhg_cdn_mapping(vhg_mapping, cdn_mapping,substrate).items():
if vhg in service.node:
service.add_edge(vhg, cdn, bandwidth=0,)
except:
traceback.print_exc()
exit(-1)
self.propagate_bandwidth(service, mapped_start_nodes)
# assign CPU according to Bandwidth
for vhg in get_nodes_by_type("VHG", service):
service.node[vhg]["cpu"] = vmg_calc(service.node[vhg]["bandwidth"])
for vhg in get_nodes_by_type("VCDN", service):
service.node[vhg]["cpu"] = vcdn_calc(service.node[vhg]["bandwidth"])
yield TopoInstance(service, delay_path, delay_route, delay)
def get_vhg(self):
return get_nodes_by_type("VHG", self.servicetopo)
def get_cdn(self):
return get_nodes_by_type("CDN", self.servicetopo)
def compute_service_topo(self,
substrate,
mapped_start_nodes,
mapped_cdn_nodes,
vhg_count,
vcdn_count,
delay,
hint_node_mappings=None):
vhg_count = min(len(mapped_start_nodes), vhg_count)
vcdn_count = min(vcdn_count, vhg_count)
vmg_calc = get_vmg_calculator()
vcdn_calc = get_vcdn_calculator()
service = nx.DiGraph()
for i in range(1, vhg_count + 1):
service.add_node("VHG%d" % i, type="VHG", ratio=1, bandwidth=0)
for i in range(1, vcdn_count + 1):
service.add_node("VCDN%d" % i,
type="VCDN",
cpu=0,
delay=delay,
ratio=0.35,
bandwidth=0)
for index, cdn in enumerate(mapped_cdn_nodes, start=1):
service.add_node("CDN%d" % index,
type="CDN",
cpu=0,
ratio=0.65,
name="CDN%d" % index,
bandwidth=0,
mapping=cdn.topoNode.name)
for key, slaNodeSpec in enumerate(mapped_start_nodes, start=1):
service.add_node("S%d" % key,
cpu=0,
type="S",
mapping=slaNodeSpec.topoNode.name,
bandwidth=0)
# create s<-> vhg edges
score, cluster = get_node_clusters(
[x.topoNode.name for x in mapped_start_nodes],
vhg_count,
substrate=substrate)
for toponode_name, vmg_id in list(cluster.items()):
s = [
n[0] for n in service.nodes(data=True)
if n[1].get("mapping", None) == toponode_name
][0]
service.add_edge(s,
"VHG%d" % vmg_id,
delay=sys.maxsize,
bandwidth=0)
# create vhg <-> vcdn edges
# here, each S "votes" for a TE and tell its VHG
score, cluster = get_node_clusters(
[x.topoNode.name for x in mapped_start_nodes],
vcdn_count,
substrate=substrate)
for toponode_name, vCDN_id in list(cluster.items()):
# get the S from the toponode_id
s = [
n[0] for n in service.nodes(data=True)
if n[1].get("mapping", None) == toponode_name
][0]
vcdn = "VCDN%d" % vCDN_id
# get the vhg from the S
vhg = list(service[s].items())[0][0]
# apply the votes
if "votes" not in service.node[vhg]:
service.node[vhg]["votes"] = collections.defaultdict(
lambda: {})
service.node[vhg]["votes"][vcdn] = 1
else:
service.node[vhg]["votes"][
vcdn] = service.node[vhg]["votes"].get(vcdn, 0) + 1
# create the edge according to the votes
for vhg in [
n[0] for n in service.nodes(data=True)
if n[1].get("type") == "VHG"
]:
votes = service.node[vhg]["votes"]
winners = max(iter(list(votes.items())),
key=operator.itemgetter(1))
if len(winners) == 1:
service.add_edge(vhg, winners[0], bandwidth=0)
else:
service.add_edge(vhg, winners[0], bandwidth=0)
# delay path
delay_path = {}
delay_route = collections.defaultdict(lambda: [])
for vcdn in get_nodes_by_type("VCDN", service):
for s in get_nodes_by_type("S", service):
try:
sp = shortest_path(service, s, vcdn)
key = "_".join(sp)
delay_path[key] = delay
for i in range(len(sp) - 1):
delay_route[key].append((sp[i], sp[i + 1]))
except:
continue
# add CDN edges if available
try:
if hint_node_mappings is not None:
vhg_mapping = [(nmapping.node.name, nmapping.service_node.name)
for nmapping in hint_node_mappings
if "VHG" in nmapping.service_node.name]
cdn_mapping = [
(nm.topoNode.name, "CDN%d" % index)
for index, nm in enumerate(mapped_cdn_nodes, start=1)
]
for vhg, cdn in list(
get_vhg_cdn_mapping(vhg_mapping, cdn_mapping,
substrate).items()):
if vhg in service.node:
service.add_edge(
vhg,
cdn,
bandwidth=0,
)
except:
traceback.print_exc()
exit(-1)
self.propagate_bandwidth(service, mapped_start_nodes)
# assign CPU according to Bandwidth
for vhg in get_nodes_by_type("VHG", service):
service.node[vhg]["cpu"] = vmg_calc(service.node[vhg]["bandwidth"])
for vhg in get_nodes_by_type("VCDN", service):
service.node[vhg]["cpu"] = vcdn_calc(
service.node[vhg]["bandwidth"])
yield TopoInstance(service, delay_path, delay_route, delay)
def get_CDN(self):
return [(s, self.servicetopo.node[s]["mapping"], self.servicetopo.node[s]["bandwidth"]) for s in
get_nodes_by_type("CDN", self.servicetopo)]
def get_cdn(self):
return get_nodes_by_type("CDN", self.servicetopo)
def get_vhg(self):
return get_nodes_by_type("VHG", self.servicetopo)
def compute_service_topo(self, substrate, mapped_start_nodes, mapped_cdn_nodes, vhg_count, vcdn_count, delay,
hint_node_mappings=None):
res=[]
vhg_count = min(len(mapped_start_nodes), vhg_count)
vcdn_count = min(vcdn_count, vhg_count)
service_graph = nx.DiGraph()
# add nodes
for key, slaNodeSpec in enumerate(mapped_start_nodes, start=1):
service_graph.add_node("S%d" % key, cpu=0, type="S", mapping=slaNodeSpec.topoNode.name,
bandwidth=slaNodeSpec.attributes["bandwidth"], name="S%d" % key, ratio=1)
for i in range(1, vhg_count + 1):
service_graph.add_node("VHG%d" % i, type="VHG", ratio=1, name="VHG%d" % i, bandwidth=0)
for i in range(1, vcdn_count + 1):
service_graph.add_node("VCDN%d" % i, type="VCDN", cpu=105, delay=delay, ratio=0.35, name="VCDN%d" % i,
bandwidth=0)
for index, cdn in enumerate(mapped_cdn_nodes, start=1):
service_graph.add_node("CDN%d" % index, type="CDN", cpu=0, ratio=0.65, name="CDN%d" % index, bandwidth=0,
mapping=cdn.topoNode.name)
first = get_all_possible_edges([get_nodes_by_type("S", service_graph), get_nodes_by_type("VHG", service_graph),
get_nodes_by_type("VCDN", service_graph)])
last = get_all_possible_edges([get_nodes_by_type("VHG", service_graph),
get_nodes_by_type("CDN", service_graph)], all_rights_are_mandatory=False)
vmg_calc = get_vmg_calculator()
vcdn_calc = get_vcdn_calculator()
# add edges
edges_sets = []
for elt in first:
for new_elt in last:
elt_copy = copy.copy(elt)
elt_copy += (new_elt)
edges_sets.append(elt_copy)
services = []
for t in edges_sets:
try:
serviceT = copy.deepcopy(service_graph)
for edge in t:
serviceT.add_edge(edge[0], edge[1])
for node, degree in list(serviceT.degree().items()):
if degree == 0:
serviceT.remove_node(node)
str_rep = "-".join(
sorted(["%s_%s" % (t[0], t[1].get("mapping", "NA")) for t in serviceT.nodes(data=True)]))
# print str_rep
#sys.stdout.write("o")
#sys.stdout.flush()
if not self.disable_isomorph_check:
for s in services:
if "-".join(sorted(
["%s_%s" % (t[0], t[1].get("mapping", "NA")) for t in s.nodes(data=True)])) == str_rep:
if nx.is_isomorphic(s, serviceT, equal_nodes):
#sys.stdout.write("\b")
#sys.stdout.flush()
raise IsomorphicServiceException()
#sys.stdout.write("\bO")
#sys.stdout.flush()
services.insert(0, serviceT)
self.propagate_bandwidth(serviceT, mapped_start_nodes=mapped_start_nodes)
# assign CPU according to Bandwidth
for vhg in get_nodes_by_type("VHG", serviceT):
serviceT.node[vhg]["cpu"] = vmg_calc(serviceT.node[vhg]["bandwidth"])
for vhg in get_nodes_by_type("VCDN", serviceT):
serviceT.node[vhg]["cpu"] = vcdn_calc(serviceT.node[vhg]["bandwidth"])
delay_path = {}
delay_route = collections.defaultdict(lambda: [])
for vcdn in get_nodes_by_type("VCDN", serviceT):
for s in get_nodes_by_type("S", serviceT):
try:
sp = shortest_path(serviceT, s, vcdn)
key = "_".join(sp)
delay_path[key] = delay
for i in range(len(sp) - 1):
delay_route[key].append((sp[i], sp[i + 1]))
except:
continue
# logging.debug("so far, %d services" % len(services))
res.append(TopoInstance(serviceT, delay_path, delay_route, delay))
except IsomorphicServiceException as e:
pass
#sys.stdout.write("\n%d/%d possible services for vhg=%d, vcdn=%d, s=%d, cdn=%d\n" % ( len(res),len(edges_sets),vhg_count, vcdn_count, len(mapped_start_nodes), len(mapped_cdn_nodes)))
#for line in sorted([",".join(sorted([n for n in serviceT.servicetopo.nodes()])) + "\t" + ",".join(sorted(["%s-%s" % (e[0], e[1]) for e in serviceT.servicetopo.edges()])) for serviceT in res]):
# print line
return res
