Commit 9a8a1a34 authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Added simple test to check pathcomp subservice composition

parent a23c62f5

test_pathcomp/ComputeSubServices.py

0 → 100644
+255 −0
Original line number Diff line number Diff line 
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.



# Convert the path defined as explicit hops with ingress and egress endpoints per device into a set of connections and

# compute the dependencies among them.

#

# Example:

# o-- int DC1 eth1 -- 10/1 CS1 1/2 -- 1/2 R2 2/1 -- a7.. OLS 60.. -- 2/1 R3 1/1 -- 1/1 CS2 10/1 -- eth1 DC2 int --o

#         APP              PKT            PKT            CTRL            PKT           PKT              APP

#

# path_hops = [

#     {'device': 'DC1-GW', 'ingress_ep': 'int', 'egress_ep': 'eth1'},

#     {'device': 'CS1-GW1', 'ingress_ep': '10/1', 'egress_ep': '1/2'},

#     {'device': 'TN-R2', 'ingress_ep': '1/2', 'egress_ep': '2/1'},

#     {'device': 'TN-OLS', 'ingress_ep': 'a7a80b23a703', 'egress_ep': '60519106029e'},

#     {'device': 'TN-R3', 'ingress_ep': '2/1', 'egress_ep': '1/1'},

#     {'device': 'CS2-GW1', 'ingress_ep': '1/1', 'egress_ep': '10/1'},

#     {'device': 'DC2-GW', 'ingress_ep': 'eth1', 'egress_ep': 'int'}

# ]

#

# connections=[

#     (UUID('7548edf7-ee7c-4adf-ac0f-c7a0c0dfba8e'), <DeviceLayerEnum.OPTICAL_CONTROLLER: 1>, [

#             {'device': 'TN-OLS', 'ingress_ep': '833760219d0f', 'egress_ep': 'cf176771a4b9'}

#         ], []),

#     (UUID('c2e57966-5d82-4705-a5fe-44cf6487219e'), <DeviceLayerEnum.PACKET_DEVICE: 30>, [

#             {'device': 'CS1-GW1', 'ingress_ep': '10/1', 'egress_ep': '1/2'},

#             {'device': 'TN-R2', 'ingress_ep': '1/2', 'egress_ep': '2/1'},

#             {'device': 'TN-R3', 'ingress_ep': '2/1', 'egress_ep': '1/1'},

#             {'device': 'CS2-GW1', 'ingress_ep': '1/1', 'egress_ep': '10/1'}

#         ], [UUID('7548edf7-ee7c-4adf-ac0f-c7a0c0dfba8e')]),

#     (UUID('1e205c82-f6ea-4977-9e97-dc27ef1f4802'), <DeviceLayerEnum.APPLICATION_DEVICE: 40>, [

#             {'device': 'DC1-GW', 'ingress_ep': 'int', 'egress_ep': 'eth1'},

#             {'device': 'DC2-GW', 'ingress_ep': 'eth1', 'egress_ep': 'int'}

#         ], [UUID('c2e57966-5d82-4705-a5fe-44cf6487219e')])

# ]



import enum, json, queue, uuid

from typing import Dict, List, Optional, Tuple

from common.DeviceTypes import DeviceTypeEnum

from common.proto.context_pb2 import Device, ServiceTypeEnum #, DeviceDriverEnum as grpc_DeviceDriverEnum

#from .ConstantsMappings import DEVICE_TYPE_TO_LAYER, DeviceLayerEnum



class StackActionEnum(enum.Enum):

    PATH_INGRESS         = 'ingress'

    CREATE_CONNECTION    = 'create'

    APPEND_PATH_HOP      = 'append'

    CHAIN_CONNECTION     = 'chain'

    TERMINATE_CONNECTION = 'terminate'



#class DeviceDriverEnum(enum.IntEnum):

#    EMULATED              = grpc_DeviceDriverEnum.DEVICEDRIVER_UNDEFINED

#    OPENCONFIG            = grpc_DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG

#    TRANSPORT_API         = grpc_DeviceDriverEnum.DEVICEDRIVER_TRANSPORT_API

#    P4                    = grpc_DeviceDriverEnum.DEVICEDRIVER_P4

#    IETF_NETWORK_TOPOLOGY = grpc_DeviceDriverEnum.DEVICEDRIVER_IETF_NETWORK_TOPOLOGY

#    ONF_TR_352            = grpc_DeviceDriverEnum.DEVICEDRIVER_ONF_TR_352

#    XR                    = grpc_DeviceDriverEnum.DEVICEDRIVER_XR

#    IETF_L2VPN            = grpc_DeviceDriverEnum.DEVICEDRIVER_IETF_L2VPN



def is_datacenter(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.DATACENTER, DeviceTypeEnum.EMULATED_DATACENTER}



def is_packet_router(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.PACKET_ROUTER, DeviceTypeEnum.EMULATED_PACKET_ROUTER}



def is_packet_switch(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.PACKET_SWITCH, DeviceTypeEnum.EMULATED_PACKET_SWITCH}



def is_packet_device(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return is_packet_router(dev_type) or is_packet_switch(dev_type)



def is_tfs_controller(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.TERAFLOWSDN_CONTROLLER}



def is_mw_controller(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.MICROWAVE_RADIO_SYSTEM, DeviceTypeEnum.EMULATED_MICROWAVE_RADIO_SYSTEM}



def is_ipm_controller(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.XR_CONSTELLATION, DeviceTypeEnum.EMULATED_XR_CONSTELLATION}



def is_ols_controller(dev_type : Optional[DeviceTypeEnum]) -> bool:

    return dev_type in {DeviceTypeEnum.OPEN_LINE_SYSTEM, DeviceTypeEnum.EMULATED_OPEN_LINE_SYSTEM}



def is_subdevice(dev_manager : Optional[str]) -> bool:

    return dev_manager is not None



def is_subdevice_equal(dev_manager_a : Optional[str], dev_manager_b : Optional[str]) -> bool:

    if dev_manager_a is None and dev_manager_b is None: return True

    if dev_manager_a is not None and dev_manager_b is not None: return dev_manager_a == dev_manager_b

    return False



#def has_driver(dev_drivers : List[DeviceDriverEnum], dev_driver : DeviceDriverEnum) -> bool:

#    return dev_driver in dev_drivers



def get_action(

    prv_type : Optional[DeviceTypeEnum], prv_manager : Optional[str],

    cur_type : DeviceTypeEnum, cur_manager : Optional[str]

) -> StackActionEnum:

    if prv_type is None:

        return StackActionEnum.PATH_INGRESS



    if is_datacenter(prv_type):

        if is_packet_device(cur_type): return StackActionEnum.CREATE_CONNECTION

        if is_tfs_controller(cur_type): return StackActionEnum.CREATE_CONNECTION



    if is_packet_device(prv_type):

        if is_datacenter(cur_type): return StackActionEnum.TERMINATE_CONNECTION

        if is_packet_device(cur_type):

            if is_subdevice_equal(cur_manager, prv_manager): return StackActionEnum.APPEND_PATH_HOP

            if is_subdevice(prv_manager) and not is_subdevice(cur_manager): return StackActionEnum.TERMINATE_CONNECTION

            if not is_subdevice(prv_manager) and is_subdevice(cur_manager): return StackActionEnum.CREATE_CONNECTION



        if is_mw_controller(cur_type) and not is_subdevice(cur_manager): return StackActionEnum.CREATE_CONNECTION

        if is_ols_controller(cur_type) and not is_subdevice(cur_manager): return StackActionEnum.CREATE_CONNECTION

        if is_tfs_controller(cur_type) and is_subdevice(cur_manager): return StackActionEnum.CREATE_CONNECTION



    if is_mw_controller(prv_type) or is_ols_controller(prv_type):

        if is_packet_device(cur_type): return StackActionEnum.TERMINATE_CONNECTION



    if is_tfs_controller(prv_type):

        if is_tfs_controller(cur_type) and is_subdevice_equal(prv_manager, cur_manager): return StackActionEnum.APPEND_PATH_HOP

        if is_datacenter(cur_type): return StackActionEnum.TERMINATE_CONNECTION

        if is_packet_device(cur_type): return StackActionEnum.TERMINATE_CONNECTION

        if is_mw_controller(cur_type) or is_ols_controller(cur_type): return StackActionEnum.CHAIN_CONNECTION



    str_fields = ', '.join([

        'prv_type={:s}'.format(str(prv_type)), 'prv_manager={:s}'.format(str(prv_manager)),

        'cur_type={:s}'.format(str(cur_type)), 'cur_manager={:s}'.format(str(cur_manager)),

    ])

    raise Exception('Undefined Action for ({:s})'.format(str_fields))



def get_device_manager_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']

    return None



def get_device_type(

    grpc_device : Device, device_dict : Dict[str, Tuple[Dict, Device]], device_manager_uuid : Optional[str]

) -> DeviceTypeEnum:

    if device_manager_uuid is None:

        return DeviceTypeEnum._value2member_map_[grpc_device.device_type] # pylint: disable=no-member

    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)))

    _,grpc_device = device_manager_tuple

    return DeviceTypeEnum._value2member_map_[grpc_device.device_type] # pylint: disable=no-member



    #manager_drivers = set(grpc_device.device_drivers)

    #if DeviceDriverEnum.DEVICEDRIVER_IETF_L2VPN in manager_drivers:

    #    device_layer = DeviceLayerEnum.MAC_LAYER_CONTROLLER

    #else:

    #    device_type = json_device['device_type']

    #    device_layer = DEVICE_TYPE_TO_LAYER.get(device_type)

    #    if device_layer is None: raise Exception('Undefined Layer for DeviceType({:s})'.format(str(device_type)))



SERVICE_TYPE_LXNM = {ServiceTypeEnum.SERVICETYPE_L3NM, ServiceTypeEnum.SERVICETYPE_L2NM}



def get_service_type(device_type : DeviceTypeEnum, prv_service_type : ServiceTypeEnum) -> ServiceTypeEnum:

    if is_tfs_controller(device_type) or is_packet_router(device_type):

        if prv_service_type in SERVICE_TYPE_LXNM: return prv_service_type

    if is_packet_switch(device_type) or is_mw_controller(device_type):

        if prv_service_type == ServiceTypeEnum.SERVICETYPE_L2NM: return prv_service_type

    if is_ols_controller(device_type) or is_ipm_controller(device_type):

        return ServiceTypeEnum.SERVICETYPE_TAPI_CONNECTIVITY_SERVICE



    str_fields = ', '.join([

        'device_type={:s}'.format(str(device_type)),

    ])

    raise Exception('Undefined Service Type for ({:s})'.format(str_fields))



def convert_explicit_path_hops_to_connections(

    path_hops : List[Dict], device_dict : Dict[str, Tuple[Dict, Device]],

    main_service_uuid : str, main_service_type : ServiceTypeEnum

) -> List[Tuple[str, int, List[str], List[str]]]:



    connection_stack = queue.LifoQueue()

    connections : List[Tuple[str, int, List[str], List[str]]] = list()

    prv_device_uuid = None

    prv_device_type = None

    prv_manager_uuid = None



    for path_hop in path_hops:

        device_uuid = path_hop['device']

        if prv_device_uuid == device_uuid: continue

        device_tuple = device_dict.get(device_uuid)

        if device_tuple is None: raise Exception('Device({:s}) not found'.format(str(device_uuid)))

        _,grpc_device = device_tuple



        manager_uuid = get_device_manager_uuid(grpc_device)

        device_type = get_device_type(grpc_device, device_dict, manager_uuid)

        action = get_action(prv_device_type, prv_manager_uuid, device_type, manager_uuid)



        if action == StackActionEnum.PATH_INGRESS:

            connection_stack.put((main_service_uuid, main_service_type, [path_hop], []))

        elif action == StackActionEnum.CREATE_CONNECTION:

            connection_uuid = str(uuid.uuid4())

            prv_service_type = connection_stack.queue[-1][1]

            service_type = get_service_type(device_type, prv_service_type)

            connection_stack.put((connection_uuid, service_type, [path_hop], []))

        elif action == StackActionEnum.APPEND_PATH_HOP:

            connection_stack.queue[-1][2].append(path_hop)

        elif action == StackActionEnum.CHAIN_CONNECTION:

            connection = connection_stack.get()

            connections.append(connection)

            connection_stack.queue[-1][3].append(connection[0])



            connection_uuid = str(uuid.uuid4())

            prv_service_type = connection_stack.queue[-1][1]

            service_type = get_service_type(device_type, prv_service_type)

            connection_stack.put((connection_uuid, service_type, [path_hop], []))

        elif action == StackActionEnum.TERMINATE_CONNECTION:

            connection = connection_stack.get()

            connections.append(connection)

            connection_stack.queue[-1][3].append(connection[0])

            connection_stack.queue[-1][2].append(path_hop)

        else:

            raise Exception('Uncontrolled condition')



        prv_device_uuid = device_uuid

        prv_device_type = device_type

        prv_manager_uuid = manager_uuid



    # path egress

    connections.append(connection_stack.get())

    assert connection_stack.empty()

    return connections



def convert_explicit_path_hops_to_plain_connection(

    path_hops : List[Dict], main_service_uuid : str, main_service_type : ServiceTypeEnum

) -> List[Tuple[str, int, List[str], List[str]]]:



    connection : Tuple[str, int, List[str], List[str]] = \

        (main_service_uuid, main_service_type, [], [])



    prv_device_uuid = None

    for path_hop in path_hops:

        device_uuid = path_hop['device']

        if prv_device_uuid == device_uuid: continue

        connection[2].append(path_hop)

        prv_device_uuid = device_uuid



    return [connection]

test_pathcomp/__init__.py

0 → 100644
+14 −0
Original line number Diff line number Diff line 
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

test_pathcomp/__main__.py

0 → 100644
+33 −0
Original line number Diff line number Diff line 
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.





import logging, sys

from common.proto.context_pb2 import ServiceTypeEnum

from .data import path_hops, device_dict

from .ComputeSubServices import convert_explicit_path_hops_to_connections



logging.basicConfig(level=logging.DEBUG)

LOGGER = logging.getLogger(__name__)



def main():

    service_uuid = 'dc-2-dc-svc'

    service_type = ServiceTypeEnum.SERVICETYPE_L2NM

    connections = convert_explicit_path_hops_to_connections(path_hops, device_dict, service_uuid, service_type)

    str_connections = '\n'.join(['  ' + str(connection) for connection in connections])

    LOGGER.debug('connections = [\n{:s}\n]'.format(str_connections))

    return 0



if __name__ == '__main__':

    sys.exit(main())

test_pathcomp/data.py

0 → 100644
+115 −0
Original line number Diff line number Diff line 
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.





import json

from typing import Dict, Tuple

from common.proto.context_pb2 import ConfigActionEnum, Device



path_hops = [

    {'device': 'DC1', 'ingress_ep': 'int', 'egress_ep': 'eth1'},

    {'device': 'PE1', 'ingress_ep': '1/1', 'egress_ep': '1/2'},

    {'device': 'MW1-2', 'ingress_ep': '172.18.0.1:1', 'egress_ep': '172.18.0.2:1'},

    {'device': 'R1', 'ingress_ep': '1/1', 'egress_ep': '1/3'},

    {'device': 'OLS', 'ingress_ep': 'aade6001-f00b-5e2f-a357-6a0a9d3de870', 'egress_ep': '0ef74f99-1acc-57bd-ab9d-4b958b06c513'},

    {'device': 'R2', 'ingress_ep': '1/1', 'egress_ep': '1/2'},

    {'device': 'PE3', 'ingress_ep': '1/1', 'egress_ep': '1/2'},

    {'device': 'DC2', 'ingress_ep': 'eth1', 'egress_ep': 'int'}

]



device_dict = {

    'R3': {'device_Id': 'R3', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'R3', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'R3', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'}

    ]},

    'PE4': {'device_Id': 'PE4', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'PE4', 'endpoint_uuid': 'mgmt'}, 'endpoint_type': 'mgmt'},

        {'endpoint_id': {'device_id': 'PE4', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'PE4', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'}

    ]},

    'PE2': {'device_Id': 'PE2', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'PE2', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'PE2', 'endpoint_uuid': 'mgmt'}, 'endpoint_type': 'mgmt'},

        {'endpoint_id': {'device_id': 'PE2', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'}

    ]},

    'R1': {'device_Id': 'R1', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'R1', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'R1', 'endpoint_uuid': '1/3'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'R1', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'}

    ]},

    'PE3': {'device_Id': 'PE3', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'PE3', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'PE3', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'PE3', 'endpoint_uuid': 'mgmt'}, 'endpoint_type': 'mgmt'}

    ]},

    'OLS': {'device_Id': 'OLS', 'device_type': 'emu-open-line-system', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'OLS', 'endpoint_uuid': '0ef74f99-1acc-57bd-ab9d-4b958b06c513'}, 'endpoint_type': 'optical'},

        {'endpoint_id': {'device_id': 'OLS', 'endpoint_uuid': '50296d99-58cc-5ce7-82f5-fc8ee4eec2ec'}, 'endpoint_type': 'optical'},

        {'endpoint_id': {'device_id': 'OLS', 'endpoint_uuid': 'aade6001-f00b-5e2f-a357-6a0a9d3de870'}, 'endpoint_type': 'optical'},

        {'endpoint_id': {'device_id': 'OLS', 'endpoint_uuid': 'eb287d83-f05e-53ec-ab5a-adf6bd2b5418'}, 'endpoint_type': 'optical'}

    ]},

    'PE1': {'device_Id': 'PE1', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'PE1', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'PE1', 'endpoint_uuid': 'mgmt'}, 'endpoint_type': 'mgmt'},

        {'endpoint_id': {'device_id': 'PE1', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'}

    ]},

    'DC2': {'device_Id': 'DC2', 'device_type': 'emu-datacenter', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'DC2', 'endpoint_uuid': 'eth1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'DC2', 'endpoint_uuid': 'eth2'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'DC2', 'endpoint_uuid': 'int'}, 'endpoint_type': 'copper/internal'}

    ]},

    'MW1-2': {'device_Id': 'MW1-2', 'device_type': 'emu-microwave-radio-system', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'MW1-2', 'endpoint_uuid': '172.18.0.1:1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'MW1-2', 'endpoint_uuid': '172.18.0.2:1'}, 'endpoint_type': 'copper/internal'}

    ]},

    'MW3-4': {'device_Id': 'MW3-4', 'device_type': 'emu-microwave-radio-system', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'MW3-4', 'endpoint_uuid': '172.18.0.3:1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'MW3-4', 'endpoint_uuid': '172.18.0.4:1'}, 'endpoint_type': 'copper/internal'}

    ]},

    'TFS': {'device_Id': 'TFS', 'device_type': 'teraflowsdn', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'TFS', 'endpoint_uuid': 'mgmt'}, 'endpoint_type': 'mgmt'}

    ]},

    'R2': {'device_Id': 'R2', 'device_type': 'emu-packet-router', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'R2', 'endpoint_uuid': '1/2'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'R2', 'endpoint_uuid': '1/1'}, 'endpoint_type': 'copper/internal'}

    ]},

    'DC1': {'device_Id': 'DC1', 'device_type': 'emu-datacenter', 'device_endpoints': [

        {'endpoint_id': {'device_id': 'DC1', 'endpoint_uuid': 'int'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'DC1', 'endpoint_uuid': 'eth1'}, 'endpoint_type': 'copper/internal'},

        {'endpoint_id': {'device_id': 'DC1', 'endpoint_uuid': 'eth2'}, 'endpoint_type': 'copper/internal'}

    ]},

}



MANAGED_DEVICES = {'PE1', 'PE2', 'PE3', 'PE4'}

MANAGER = 'TFS'



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

    device_uuid = json_device['device_Id']



    grpc_device = Device()

    grpc_device.device_id.device_uuid.uuid = device_uuid

    grpc_device.device_type = json_device['device_type']



    if device_uuid in MANAGED_DEVICES:

        config_rule = grpc_device.device_config.config_rules.add()

        config_rule.action = ConfigActionEnum.CONFIGACTION_SET

        config_rule.custom.resource_key = '_manager'

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



    return json_device, grpc_device



device_dict = {

    device_uuid:process_device(json_device)

    for device_uuid,json_device in device_dict.items()

}

test_pathcomp/format.sh

0 → 100755
+56 −0

File added.

Preview size limit exceeded, changes collapsed.