Common framework: (96ab782f) · Commits · TFS / controller

src/common/tools/descriptor/Loader.py

+47 −18

Original line number	Diff line number	Diff line
		@@ -45,12 +45,13 @@ from context.client.ContextClient import ContextClient
		from device.client.DeviceClient import DeviceClient
		from service.client.ServiceClient import ServiceClient
		from slice.client.SliceClient import SliceClient
		from vnt_manager.client.VNTManagerClient import VNTManagerClient
		from .Tools import (
		format_device_custom_config_rules, format_service_custom_config_rules,
		format_slice_custom_config_rules, get_descriptors_add_contexts,
		get_descriptors_add_services, get_descriptors_add_slices,
		get_descriptors_add_topologies, split_controllers_and_network_devices,
		split_devices_by_rules
		split_devices_by_rules, split_links_by_type
		)

		LOGGER = logging.getLogger(__name__)
		@@ -112,7 +113,8 @@ class DescriptorLoader:
		self, descriptors : Optional[Union[str, Dict]] = None, descriptors_file : Optional[str] = None,
		num_workers : int = 1,
		context_client : Optional[ContextClient] = None, device_client : Optional[DeviceClient] = None,
		service_client : Optional[ServiceClient] = None, slice_client : Optional[SliceClient] = None
		service_client : Optional[ServiceClient] = None, slice_client : Optional[SliceClient] = None,
		vntm_client : Optional[VNTManagerClient] = None
		) -> None:
		if (descriptors is None) == (descriptors_file is None):
		# pylint: disable=broad-exception-raised
		@@ -194,6 +196,7 @@ class DescriptorLoader:
		self.__dev_cli = DeviceClient() if device_client is None else device_client
		self.__svc_cli = ServiceClient() if service_client is None else service_client
		self.__slc_cli = SliceClient() if slice_client is None else slice_client
		self.__vnt_cli = VNTManagerClient() if vntm_client is None else vntm_client

		self.__results : TypeResults = list()

		@@ -351,20 +354,36 @@ class DescriptorLoader:

		controllers_add, network_devices_add = split_controllers_and_network_devices(self.__devices_add)

		typed_links = split_links_by_type(self.__links)
		typed_normal_links = typed_links.get('normal', list())
		typed_optical_links = typed_links.get('optical', list())
		typed_optical_links.extend(self.__optical_links)
		typed_virtual_links = typed_links.get('virtual', list())

		self.__ctx_cli.connect()
		self.__dev_cli.connect()
		self.__svc_cli.connect()
		self.__slc_cli.connect()
		if len(self.__services ) > 0: self.__svc_cli.connect()
		if len(self.__slices ) > 0: self.__slc_cli.connect()
		if len(typed_virtual_links) > 0: self.__vnt_cli.connect()

		self._process_descr('context', 'add', self.__ctx_cli.SetContext, Context, self.__contexts_add )
		self._process_descr('topology', 'add', self.__ctx_cli.SetTopology, Topology, self.__topologies_add)
		self._process_descr('controller', 'add', self.__dev_cli.AddDevice, Device, controllers_add )
		self._process_descr('device', 'add', self.__dev_cli.AddDevice, Device, network_devices_add )
		self._process_descr('device', 'config', self.__dev_cli.ConfigureDevice, Device, self.__devices_config)
		self._process_descr('link', 'add', self.__ctx_cli.SetLink, Link, self.__links )
		self._process_descr('link', 'add', self.__ctx_cli.SetOpticalLink, OpticalLink, self.__optical_links )
		self._process_descr('link', 'add', self.__ctx_cli.SetLink, Link, typed_normal_links )

		if len(typed_optical_links) > 0:
		self._process_descr('link', 'add', self.__ctx_cli.SetOpticalLink, OpticalLink, typed_optical_links )

		if len(typed_virtual_links) > 0:
		self._process_descr('link', 'add', self.__vnt_cli.SetVirtualLink, Link, typed_virtual_links )

		if len(self.__services) > 0:
		self._process_descr('service','add', self.__svc_cli.CreateService, Service, self.__services_add )
		self._process_descr('service','update', self.__svc_cli.UpdateService, Service, self.__services )

		if len(self.__slices) > 0:
		self._process_descr('slice', 'add', self.__slc_cli.CreateSlice, Slice, self.__slices_add )
		self._process_descr('slice', 'update', self.__slc_cli.UpdateSlice, Slice, self.__slices )

		@@ -467,10 +486,17 @@ class DescriptorLoader:

		def _unload_normal_mode(self) -> None:
		# Normal mode: follows the automated workflows in the different components
		typed_links = split_links_by_type(self.links)
		typed_normal_links = typed_links.get('normal', list())
		typed_optical_links = typed_links.get('optical', list())
		typed_optical_links.extend(self.optical_links)
		typed_virtual_links = typed_links.get('virtual', list())

		self.__ctx_cli.connect()
		self.__dev_cli.connect()
		self.__svc_cli.connect()
		self.__slc_cli.connect()
		if len(self.services ) > 0: self.__svc_cli.connect()
		if len(self.slices ) > 0: self.__slc_cli.connect()
		if len(typed_virtual_links) > 0: self.__vnt_cli.connect()

		for _, slice_list in self.slices.items():
		for slice_ in slice_list:
		@@ -480,10 +506,13 @@ class DescriptorLoader:
		for service in service_list:
		self.__svc_cli.DeleteService(ServiceId(**service['service_id']))

		for optical_link in self.optical_links:
		for virtual_link in typed_virtual_links:
		self.__vnt_cli.RemoveVirtualLink(LinkId(**virtual_link['link_id']))

		for optical_link in typed_optical_links:
		self.__ctx_cli.DeleteOpticalLink(LinkId(**optical_link['link_id']))

		for link in self.links:
		for link in typed_normal_links:
		self.__ctx_cli.RemoveLink(LinkId(**link['link_id']))

		for device in self.devices:

src/common/tools/descriptor/Tools.py

+29 −1

Original line number	Diff line number	Diff line
		@@ -12,10 +12,11 @@
		# See the License for the specific language governing permissions and
		# limitations under the License.

		import collections
		import copy, json
		from typing import Dict, List, Optional, Tuple, Union
		from common.DeviceTypes import DeviceTypeEnum
		from common.proto.context_pb2 import DeviceDriverEnum
		from common.proto.context_pb2 import DeviceDriverEnum, LinkTypeEnum

		def get_descriptors_add_contexts(contexts : List[Dict]) -> List[Dict]:
		contexts_add = copy.deepcopy(contexts)
		@@ -131,3 +132,30 @@ def split_controllers_and_network_devices(devices : List[Dict]) -> Tuple[List[Di
		else:
		network_devices.append(device)
		return controllers, network_devices

		def link_type_to_str(link_type : Union[int, str]) -> Optional[str]:
		if isinstance(link_type, int): return LinkTypeEnum.Name(link_type)
		if isinstance(link_type, str): return LinkTypeEnum.Name(LinkTypeEnum.Value(link_type))
		return None

		def split_links_by_type(links : List[Dict]) -> Dict[str, List[Dict]]:
		typed_links = collections.defaultdict(list)
		for link in links:
		link_type = link.get('link_type', LinkTypeEnum.LINKTYPE_UNKNOWN)
		str_link_type = link_type_to_str(link_type)
		if str_link_type is None:
		MSG = 'Unsupported LinkType in Link({:s})'
		raise Exception(MSG.format(str(link)))

		link_type = LinkTypeEnum.Value(str_link_type)
		if link_type in {LinkTypeEnum.LINKTYPE_UNKNOWN, LinkTypeEnum.LINKTYPE_COPPER, LinkTypeEnum.LINKTYPE_RADIO}:
		typed_links['normal'].append(link)
		elif link_type in {LinkTypeEnum.LINKTYPE_FIBER}:
		typed_links['optical'].append(link)
		elif link_type in {LinkTypeEnum.LINKTYPE_VIRTUAL}:
		typed_links['virtual'].append(link)
		else:
		MSG = 'Unsupported LinkType({:s}) in Link({:s})'
		raise Exception(MSG.format(str_link_type, str(link)))

		return typed_links