PathComp component - Frontend:

- Renamed device "manager" to device "controller"

src/pathcomp/frontend/service/algorithms/tools/ComputeSubServices.py

@@ -88,10 +88,10 @@ def convert_explicit_path_hops_to_connections(
         elif prv_res_class[0] == res_class[0]:
             # same resource group kind
             if prv_res_class[1] == res_class[1] and prv_res_class[2] == res_class[2]:
-                # same device type and device manager: connection continues
+                # same device type and device controller: connection continues
                 connection_stack.queue[-1][2].append(path_hop)
             else:
-                # different device type or device manager: chain connections
+                # different device type or device controller: chain connections
                 connection = connection_stack.get()
                 connections.append(connection)
                 connection_stack.queue[-1][3].append(connection[0])

src/pathcomp/frontend/service/algorithms/tools/ResourceGroups.py

@@ -54,14 +54,14 @@ DEVICE_TYPE_TO_DEEPNESS = {
 
 IGNORED_DEVICE_TYPES = {DeviceTypeEnum.EMULATED_OPTICAL_SPLITTER}
 
-def get_device_manager_uuid(
+def get_device_controller_uuid(
     device : Device
 ) -> Optional[str]:
     for config_rule in device.device_config.config_rules:
         if config_rule.WhichOneof('config_rule') != 'custom': continue
-        if config_rule.custom.resource_key != '_manager': continue
-        device_manager_id = json.loads(config_rule.custom.resource_value)
-        return device_manager_id['uuid']
+        if config_rule.custom.resource_key != '_controller': continue
+        device_controller_id = json.loads(config_rule.custom.resource_value)
+        return device_controller_id['uuid']
     return None
 
 def _map_device_type(device : Device) -> DeviceTypeEnum:
@@ -77,18 +77,18 @@ def _map_resource_to_deepness(device_type : DeviceTypeEnum) -> int:
     return deepness
 
 def get_device_type(
-    device : Device, device_dict : Dict[str, Tuple[Dict, Device]], device_manager_uuid : Optional[str]
+    device : Device, device_dict : Dict[str, Tuple[Dict, Device]], device_controller_uuid : Optional[str]
 ) -> DeviceTypeEnum:
-    if device_manager_uuid is None: return _map_device_type(device)
-    device_manager_tuple = device_dict.get(device_manager_uuid)
-    if device_manager_tuple is None: raise Exception('Device({:s}) not found'.format(str(device_manager_uuid)))
-    _,device = device_manager_tuple
+    if device_controller_uuid is None: return _map_device_type(device)
+    device_controller_tuple = device_dict.get(device_controller_uuid)
+    if device_controller_tuple is None: raise Exception('Device({:s}) not found'.format(str(device_controller_uuid)))
+    _,device = device_controller_tuple
     return _map_device_type(device)
 
 def get_resource_classification(
     device : Device, device_dict : Dict[str, Tuple[Dict, Device]]
 ) -> Tuple[int, DeviceTypeEnum, Optional[str]]:
-    device_manager_uuid = get_device_manager_uuid(device)
-    device_type = get_device_type(device, device_dict, device_manager_uuid)
+    device_controller_uuid = get_device_controller_uuid(device)
+    device_type = get_device_type(device, device_dict, device_controller_uuid)
     resource_deepness = _map_resource_to_deepness(device_type)
-    return resource_deepness, device_type, device_manager_uuid
+    return resource_deepness, device_type, device_controller_uuid