Commit 0428b374 authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Test Pathcomp: 

- Renamed device "manager" to device "controller"
- Extended TAPI Service Handler to support optional device controllers
- Fixed IETF L2VPN Service Handler delete to support optional device controllers
parent c0a1c3c6

test_pathcomp/ComputeSubServices.py

+2 −2
Original line number Diff line number Diff line
@@ -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])

test_pathcomp/ResourceGroups.py

+12 −12
Original line number Diff line number Diff line
@@ -53,14 +53,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:
@@ -76,18 +76,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

test_pathcomp/data.py

+19 −19
Original line number Diff line number Diff line
@@ -31,37 +31,37 @@ path_hops = [ 
]



device_data = {

    'TFS'     : {'manager_uuid': None,  'device_type': DeviceTypeEnum.TERAFLOWSDN_CONTROLLER   },

    'IPM'     : {'manager_uuid': None,  'device_type': DeviceTypeEnum.XR_CONSTELLATION         },

    'OLS'     : {'manager_uuid': None,  'device_type': DeviceTypeEnum.OPEN_LINE_SYSTEM         },

    'MW1-2'   : {'manager_uuid': None,  'device_type': DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM   },

    'MW3-4'   : {'manager_uuid': None,  'device_type': DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM   },

    'TFS'     : {'controller_uuid': None,  'device_type': DeviceTypeEnum.TERAFLOWSDN_CONTROLLER   },

    'IPM'     : {'controller_uuid': None,  'device_type': DeviceTypeEnum.XR_CONSTELLATION         },

    'OLS'     : {'controller_uuid': None,  'device_type': DeviceTypeEnum.OPEN_LINE_SYSTEM         },

    'MW1-2'   : {'controller_uuid': None,  'device_type': DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM   },

    'MW3-4'   : {'controller_uuid': None,  'device_type': DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM   },



    'DC1'     : {'manager_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_DATACENTER      },

    'DC2'     : {'manager_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_DATACENTER      },

    'DC1'     : {'controller_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_DATACENTER      },

    'DC2'     : {'controller_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_DATACENTER      },



    'PE1'     : {'manager_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE2'     : {'manager_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE3'     : {'manager_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE4'     : {'manager_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE1'     : {'controller_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE2'     : {'controller_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE3'     : {'controller_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'PE4'     : {'controller_uuid': 'TFS', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },



    'HUB1'    : {'manager_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'LEAF1'   : {'manager_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'LEAF2'   : {'manager_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'HUB1'    : {'controller_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'LEAF1'   : {'controller_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },

    'LEAF2'   : {'controller_uuid': 'IPM', 'device_type': DeviceTypeEnum.PACKET_ROUTER            },



    'splitter': {'manager_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_OPTICAL_SPLITTER},

    'splitter': {'controller_uuid': None,  'device_type': DeviceTypeEnum.EMULATED_OPTICAL_SPLITTER},

}



def process_device(device_uuid, json_device) -> Tuple[Dict, Device]:

    grpc_device = Device()

    grpc_device.device_id.device_uuid.uuid = device_uuid            # pylint: disable=no-member

    grpc_device.device_type = json_device['device_type'].value

    manager_uuid = json_device.get('manager_uuid')

    if manager_uuid is not None:

    controller_uuid = json_device.get('controller_uuid')

    if controller_uuid is not None:

        config_rule = grpc_device.device_config.config_rules.add()  # pylint: disable=no-member

        config_rule.action = ConfigActionEnum.CONFIGACTION_SET

        config_rule.custom.resource_key = '_manager'

        config_rule.custom.resource_value = json.dumps({'uuid': manager_uuid})

        config_rule.custom.resource_key = '_controller'

        config_rule.custom.resource_value = json.dumps({'uuid': controller_uuid})

    return json_device, grpc_device



device_dict = {