def forwarding_graphs(self, source):
forwarding_graphs = source
try:
for key in forwarding_graphs.keys():
if key == 'forwarding_graphs':
forwarding_graphs_data = forwarding_graphs[key]
for data in forwarding_graphs_data:
for k in data.keys():
# to check if the key matches with "network_forwarding_paths "
if k == "network_forwarding_paths":
# extract and save all data present in "network_forwarding_paths"
network_forwarding_paths = data[k]
for network_forwarding_paths_data in network_forwarding_paths:
for j in network_forwarding_paths_data.keys(
):
# check if key matches with "connection_points"
if j == "connection_points":
# extract and save all data present in "connection points"
network_forwarding_paths_data1 = network_forwarding_paths_data[
j]
for connection_points_data in network_forwarding_paths_data1:
connection_point_ref = connection_points_data[
'connection_point_ref']
position = connection_points_data[
'position']
connection_points_instance = SonataSchema.ConnectionPointsGraph(
connection_point_ref,
position)
self.list_connection_points_graph.append(
connection_points_instance)
fp_id = network_forwarding_paths_data[
'fp_id']
policy = network_forwarding_paths_data[
'policy']
network_forwarding_paths_instance = SonataSchema.NetworkForwardingPaths(
fp_id, policy,
self.list_connection_points_graph)
self.list_network_forwarding_paths.append(
network_forwarding_paths_instance)
fg_id = data['fg_id']
number_of_endpoints = data['number_of_endpoints']
number_of_virtual_links = data[
'number_of_virtual_links']
constituent_virtual_links = []
if data.get(
'constituent_virtual_links') is not None:
constituent_virtual_links = data[
'constituent_virtual_links']
constituent_vnfs = data['constituent_vnfs']
forwarding_graphs_instance = SonataSchema.ForwardingGraphs(
fg_id, number_of_endpoints,
number_of_virtual_links, constituent_vnfs,
constituent_virtual_links,
self.list_network_forwarding_paths)
self.list_forwarding_graphs.append(
forwarding_graphs_instance)
except KeyError:
print("One or many keys not found!")
def split_network_function(self):
for network_function_set in self.network_function_sets:
sub_nsd = SonataSchema.NSD("", "", "", "", "", "", [], [], [], [])
network_function_list = []
for network_function in network_function_set:
network_function_list.append(
self.get_network_function_object(network_function))
sub_nsd.networkFunctions = network_function_list
self.NSDs.append(sub_nsd)
def normal_case(self, path, nsd_fg):
path_inner = SonataSchema.NetworkForwardingPaths(
path.fp_id, path.policy, [])
x = 1
for cp in path.connection_points:
if cp.connection_point_ref in self.get_connection_point_refs(
nsd_fg.networkFunctions):
point = SonataSchema.ConnectionPointsGraph(
cp.connection_point_ref, x)
path_inner.connection_points.append(point)
x = x + 1
else:
for connection_point in nsd_fg.connectionPoints:
if cp.connection_point_ref == connection_point._id:
point = SonataSchema.ConnectionPointsGraph(
cp.connection_point_ref, x)
path_inner.connection_points.append(point)
x = x + 1
return path_inner
def handle_elan_links(self, virtual_link_elan, nsd_vl):
virtual_link_inner = SonataSchema.VirtualLink(
virtual_link_elan._id, virtual_link_elan.connectivity_type, [])
for nf in nsd_vl.networkFunctions:
for connection_point_ref in virtual_link_elan.connection_points_reference:
if connection_point_ref in nf.connection_point_refs:
virtual_link_inner.connection_points_reference.append(
str(connection_point_ref))
else:
if connection_point_ref not in virtual_link_inner.connection_points_reference:
for connection_point in nsd_vl.connectionPoints:
if connection_point_ref == connection_point._id:
virtual_link_inner.connection_points_reference.append(
str(connection_point_ref))
return virtual_link_inner
def sonata_connection_points(self, source):
connection_points = source
try:
for key in connection_points.keys():
if key == 'connection_points':
connection_points_data = connection_points[key]
for data in connection_points_data:
_id = data['id']
interface = data['interface']
_type = data['type']
connection_points_instance = SonataSchema.ConnectionPoint(
_id, interface, _type)
self.list_connection_points.append(
connection_points_instance)
except KeyError:
print("One or many keys not found!")
def sonata_network_function(self, source):
network_functions = source
try:
for key in network_functions.keys():
if key == 'network_functions':
network_functions_data = network_functions[key]
for data in network_functions_data:
vnf_id = data['vnf_id']
vnf_vendor = data['vnf_vendor']
vnf_name = data['vnf_name']
vnf_version = data['vnf_version']
nsd = SonataSchema.NetworkFunction(
vnf_id, vnf_vendor, vnf_name, vnf_version, [])
self.list_nf.append(nsd)
except KeyError:
print("One or many keys not found!")
def virtual_links(self, source):
virtual_links = source
try:
for key in virtual_links.keys():
if key == 'virtual_links':
virtual_links_data = virtual_links[key]
for data in virtual_links_data:
_id = data['id']
connectivity_type = data['connectivity_type']
connection_points_reference = data[
'connection_points_reference']
virtual_links_instance = SonataSchema.VirtualLink(
_id, connectivity_type,
connection_points_reference)
self.list_virtual_links.append(virtual_links_instance)
except KeyError:
print("One or many keys not found!")
def split_forwarding_path(self):
for i in range(len(self.NSDs)):
nsd_fg = self.NSDs[i]
del self.processed_connection_point_path[:]
for fg in self.utilityFunctions.list_forwarding_graphs:
fg_inner = SonataSchema.ForwardingGraphs(
fg.fg_id, fg.number_of_endpoints,
len(self.set_constituent_virtual_links(nsd_fg, fg)),
self.network_function_sets[i],
self.set_constituent_virtual_links(nsd_fg, fg), [])
for path in fg.network_forwarding_path:
if self.number_of_connection_paths(
self.set_constituent_virtual_links(nsd_fg,
fg)) > 1:
for j in range(
self.number_of_connection_paths(
self.set_constituent_virtual_links(
nsd_fg, fg))):
path_inner = SonataSchema.NetworkForwardingPaths(
path.fp_id + "_" + str(j), path.policy, [])
x = 0
for cp in path.connection_points:
if self.connection_point_already_processed(
cp.connection_point_ref) is False:
found = 0
if cp.connection_point_ref in self.get_connection_point_refs(
nsd_fg.networkFunctions):
x = x + 1
point = SonataSchema.ConnectionPointsGraph(
cp.connection_point_ref, x)
path_inner.connection_points.append(
point)
found = 1
self.processed_connection_point_path.append(
[cp.connection_point_ref, 1])
else:
for connection_point in nsd_fg.connectionPoints:
if cp.connection_point_ref == connection_point._id:
x = x + 1
point = SonataSchema.ConnectionPointsGraph(
cp.connection_point_ref, x)
path_inner.connection_points.append(
point)
found = 1
self.processed_connection_point_path.append(
[
cp.
connection_point_ref, 1
])
if found == 0:
string = cp.connection_point_ref.split(
":")
if string[1] == "input":
x = x + 1
point = SonataSchema.ConnectionPointsGraph(
"output", x)
path_inner.connection_points.append(
point)
self.processed_connection_point_path.append(
[cp.connection_point_ref, 1])
break
if string[1] == "output":
x = 1
point = SonataSchema.ConnectionPointsGraph(
"input", x)
path_inner.connection_points.append(
point)
self.processed_connection_point_path.append(
[cp.connection_point_ref, 1])
fg_inner.network_forwarding_path.append(path_inner)
else:
fg_inner.network_forwarding_path.append(
self.normal_case(path, nsd_fg))
nsd_fg.forwardingGraphs.append(fg_inner)
self.NSDs[i] = nsd_fg
def split_virtual_links(self):
for i in range(len(self.NSDs)):
nsd_vl = self.NSDs[i]
for virtual_link in self.utilityFunctions.list_virtual_links:
if virtual_link.connectivity_type == "E-LAN":
virtual_link_inner = self.handle_elan_links(
virtual_link, nsd_vl)
nsd_vl.virtualLinks.append(virtual_link_inner)
if virtual_link.connectivity_type == "E-Line":
virtual_link_inner = SonataSchema.VirtualLink(
virtual_link._id, virtual_link.connectivity_type, [])
cp_0 = virtual_link.connection_points_reference[0]
cp_1 = virtual_link.connection_points_reference[1]
found_0 = 0
found_1 = 0
if cp_0 in self.get_connection_point_refs(
nsd_vl.networkFunctions):
virtual_link_inner.connection_points_reference.append(
str(cp_0))
found_0 = 1
else:
for connection_point in nsd_vl.connectionPoints:
if cp_0 == connection_point._id:
virtual_link_inner.connection_points_reference.append(
str(cp_0))
found_0 = 1
if found_0 == 0:
if self.get_connection_point_type(cp_1) != "external":
virtual_link_inner.connection_points_reference.append(
str("input"))
found_0 = 1
if cp_1 in self.get_connection_point_refs(
nsd_vl.networkFunctions):
virtual_link_inner.connection_points_reference.append(
str(cp_1))
found_1 = 1
else:
for connection_point in self.NSDs[i].connectionPoints:
if cp_1 == connection_point._id:
virtual_link_inner.connection_points_reference.append(
str(cp_1))
found_1 = 1
if found_1 == 0:
if self.get_connection_point_type(cp_0) != "external":
virtual_link_inner.connection_points_reference.append(
str("output"))
found_1 = 1
if len(virtual_link_inner.connection_points_reference
) == 2:
str1 = virtual_link_inner.connection_points_reference[
0].split(":")
str2 = virtual_link_inner.connection_points_reference[
1].split(":")
if len(str1) == 2:
str1[0] = str1[0].replace("vnf_", "")
if len(str2) == 2:
str2[0] = str2[0].replace("vnf_", "")
virtual_link_inner._id = str1[0] + "-2-" + str2[0]
self.old_new_link_mapping.append(
[virtual_link._id, virtual_link_inner._id])
if found_0 == 1 and found_1 == 1:
_connection_point_type_0 = self.get_connection_point_type(
virtual_link_inner.connection_points_reference[0])
_connection_point_type_1 = self.get_connection_point_type(
virtual_link_inner.connection_points_reference[1])
if (_connection_point_type_0 == "external"
and _connection_point_type_1
== "external") == False:
nsd_vl.virtualLinks.append(virtual_link_inner)
self.NSDs[i] = nsd_vl