Commit a2d4ba5b authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Integration fix resolution: 

Common:
- added slice to EventTools

OFC'22 tests:
- corrected OFC'22 delete service test to identify appropriate service to be deleted
- removed usage of events for testing

Compute:
- remove diversity constraint when not populated

Device:
- removed unused field in database and code polishing

Service:
- migrated L3NMEmulatedServiceHandler to the new API
- polishing of code
parent cd94fed3

src/common/tests/EventTools.py

+3 −1
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
import json, logging

from typing import Dict, List, Tuple

from common.proto.context_pb2 import (

    ConnectionEvent, ContextEvent, DeviceEvent, EventTypeEnum, LinkEvent, ServiceEvent, TopologyEvent)

    ConnectionEvent, ContextEvent, DeviceEvent, EventTypeEnum, LinkEvent, ServiceEvent, SliceEvent, TopologyEvent)

from common.tools.grpc.Tools import grpc_message_to_json_string

from context.client.EventsCollector import EventsCollector
@@ -32,6 +32,7 @@ CLASSNAME_CONTEXT_EVENT = class_to_classname(ContextEvent) 
CLASSNAME_TOPOLOGY_EVENT   = class_to_classname(TopologyEvent)

CLASSNAME_DEVICE_EVENT     = class_to_classname(DeviceEvent)

CLASSNAME_LINK_EVENT       = class_to_classname(LinkEvent)

CLASSNAME_SLICE_EVENT      = class_to_classname(SliceEvent)

CLASSNAME_SERVICE_EVENT    = class_to_classname(ServiceEvent)

CLASSNAME_CONNECTION_EVENT = class_to_classname(ConnectionEvent)
@@ -40,6 +41,7 @@ EVENT_CLASS_NAME__TO__ENTITY_ID_SELECTOR = { 
    CLASSNAME_TOPOLOGY_EVENT  : lambda event: event.topology_id,

    CLASSNAME_DEVICE_EVENT    : lambda event: event.device_id,

    CLASSNAME_LINK_EVENT      : lambda event: event.link_id,

    CLASSNAME_SLICE_EVENT     : lambda event: event.slice_id,

    CLASSNAME_SERVICE_EVENT   : lambda event: event.service_id,

    CLASSNAME_CONNECTION_EVENT: lambda event: event.connection_id,

}

src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_SiteNetworkAccesses.py

+1 −3
Original line number Diff line number Diff line
@@ -98,10 +98,8 @@ def process_site_network_access(context_client : ContextClient, site_id : str, s 
    if circuit_id     is not None: field_updates['circuit_id'         ] = (circuit_id,     True)

    update_config_rule_custom(config_rules, endpoint_settings_key, field_updates)



    field_updates = {}

    if len(diversity_constraints) > 0:

        field_updates.update(diversity_constraints)

    update_constraint_custom(constraints, 'diversity', field_updates)

        update_constraint_custom(constraints, 'diversity', diversity_constraints)



    update_constraint_endpoint_location(constraints, endpoint_id, region=site_id)

    if access_priority is not None: update_constraint_endpoint_priority(constraints, endpoint_id, access_priority)

src/device/service/database/EndPointModel.py

+1 −7
Original line number Diff line number Diff line
@@ -34,7 +34,6 @@ class EndPointModel(Model): 
    device_fk = ForeignKeyField(DeviceModel)

    endpoint_uuid = StringField(required=True, allow_empty=False)

    endpoint_type = StringField()

    resource_key = StringField(required=True, allow_empty=False)



    def dump_id(self) -> Dict:

        device_id = DeviceModel(self.database, self.device_fk).dump_id()
@@ -74,13 +73,8 @@ def set_endpoint_monitors(database : Database, db_endpoint : EndPointModel, grpc 
    for kpi_sample_type in grpc_endpoint_kpi_sample_types:

        orm_kpi_sample_type = grpc_to_enum__kpi_sample_type(kpi_sample_type)

        str_endpoint_kpi_sample_type_key = key_to_str([db_endpoint_pk, str(orm_kpi_sample_type.value)])

        #db_endpoint_kpi_sample_type = EndPointMonitorModel(database, str_endpoint_kpi_sample_type_key)

        #db_endpoint_kpi_sample_type.endpoint_fk = db_endpoint

        #db_endpoint_kpi_sample_type.resource_key = '' # during initialization, allow empty value

        #db_endpoint_kpi_sample_type.kpi_sample_type = orm_kpi_sample_type

        #db_endpoint_kpi_sample_type.save()

        update_or_create_object(database, EndPointMonitorModel, str_endpoint_kpi_sample_type_key, {

            'endpoint_fk'    : db_endpoint,

            #'resource_key'   : '', # during initialization, allow empty value

            'resource_key'   : '', # during initialization, allow empty value

            'kpi_sample_type': orm_kpi_sample_type,

        })

src/service/service/service_handlers/l3nm_emulated/ConfigRules.py

+113 −1
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ def setup_config_rules( 
    network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)



    mtu                 = json_settings.get('mtu',                 1450 )    # 1512

    #address_families    = json_settings.get('address_families',    []   )    # ['IPV4']

    bgp_as              = json_settings.get('bgp_as',              0    )    # 65000

    bgp_route_target    = json_settings.get('bgp_route_target',    '0:0')    # 65000:333
@@ -135,3 +136,114 @@ def setup_config_rules( 
    ]



    return json_config_rules



def teardown_config_rules(

    service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str,

    service_settings : TreeNode, endpoint_settings : TreeNode

) -> List[Dict]:



    json_settings          : Dict = {} if service_settings  is None else service_settings.value

    json_endpoint_settings : Dict = {} if endpoint_settings is None else endpoint_settings.value



    #mtu                 = json_settings.get('mtu',                 1450 )    # 1512

    #address_families    = json_settings.get('address_families',    []   )    # ['IPV4']

    #bgp_as              = json_settings.get('bgp_as',              0    )    # 65000

    bgp_route_target    = json_settings.get('bgp_route_target',    '0:0')    # 65000:333



    #router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'

    #route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0'    )  # '60001:801'

    sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1

    vlan_id             = json_endpoint_settings.get('vlan_id',             1        )  # 400

    #address_ip          = json_endpoint_settings.get('address_ip',          '0.0.0.0')  # '2.2.2.1'

    #address_prefix      = json_endpoint_settings.get('address_prefix',      24       )  # 30



    if_subif_name             = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)

    service_short_uuid        = service_uuid.split('-')[-1]

    network_instance_name     = '{:s}-NetInst'.format(service_short_uuid)

    #network_interface_desc    = '{:s}-NetIf'.format(service_uuid)

    #network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)



    json_config_rules = [

        json_config_rule_delete(

            '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {

                'name': network_instance_name, 'id': if_subif_name,

        }),

        json_config_rule_delete(

            '/interface[{:s}]/subinterface[{:d}]'.format(endpoint_uuid, sub_interface_index), {

                'name': endpoint_uuid, 'index': sub_interface_index,

        }),

        json_config_rule_delete(

            '/interface[{:s}]'.format(endpoint_uuid), {

                'name': endpoint_uuid,

        }),

        json_config_rule_delete(

            '/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(

                network_instance_name), {

                'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',

                'address_family': 'IPV4',

        }),

        json_config_rule_delete(

            '/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {

                'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',

                'address_family': 'IPV4',

        }),

        json_config_rule_delete(

            '/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {

                'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP',

        }),

        json_config_rule_delete(

            # pylint: disable=duplicate-string-formatting-argument

            '/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(

                network_instance_name, network_instance_name), {

            'name': network_instance_name,

        }),

        json_config_rule_delete(

            '/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(

                network_instance_name, '3'), {

                'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',

        }),

        json_config_rule_delete(

            '/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {

                'policy_name': '{:s}_import'.format(network_instance_name),

        }),

        json_config_rule_delete(

            '/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(

                network_instance_name, bgp_route_target), {

                'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),

                'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),

        }),

        json_config_rule_delete(

            '/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {

                'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),

        }),

        json_config_rule_delete(

            # pylint: disable=duplicate-string-formatting-argument

            '/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(

                network_instance_name, network_instance_name), {

                'name': network_instance_name,

        }),

        json_config_rule_delete(

            '/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(

                network_instance_name, '3'), {

                'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',

        }),

        json_config_rule_delete(

            '/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {

                'policy_name': '{:s}_export'.format(network_instance_name),

        }),

        json_config_rule_delete(

            '/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(

                network_instance_name, bgp_route_target), {

                'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),

                'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),

        }),

        json_config_rule_delete(

            '/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {

                'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),

        }),

        json_config_rule_delete(

            '/network_instance[{:s}]'.format(network_instance_name), {

                'name': network_instance_name

        }),

    ]

    return json_config_rules

src/service/service/service_handlers/l3nm_emulated/ConfigRulesOld.py

0 → 100644
+109 −0
Original line number Diff line number Diff line 


                # json_endpoint_settings : Dict = endpoint_settings.value

                # #router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'

                # route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0'    )  # '60001:801'

                # sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1

                # vlan_id             = json_endpoint_settings.get('vlan_id',             1        )  # 400

                # address_ip          = json_endpoint_settings.get('address_ip',          '0.0.0.0')  # '2.2.2.1'

                # address_prefix      = json_endpoint_settings.get('address_prefix',      24       )  # 30

                # if_subif_name       = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)



                # db_device : DeviceModel = get_object(self.__database, DeviceModel, device_uuid, raise_if_not_found=True)

                # device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))

                # json_device = db_device.dump(include_config_rules=False, include_drivers=True, include_endpoints=True)

                # json_device_config : Dict = json_device.setdefault('device_config', {})

                # json_device_config_rules : List = json_device_config.setdefault('config_rules', [])

                # json_device_config_rules.extend([

                #     json_config_rule_set(

                #         '/network_instance[{:s}]'.format(network_instance_name), {

                #             'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',

                #             'route_distinguisher': route_distinguisher,

                #             #'router_id': router_id, 'address_families': address_families,

                #     }),

                #     json_config_rule_set(

                #         '/interface[{:s}]'.format(endpoint_uuid), {

                #             'name': endpoint_uuid, 'description': network_interface_desc, 'mtu': mtu,

                #     }),

                #     json_config_rule_set(

                #         '/interface[{:s}]/subinterface[{:d}]'.format(endpoint_uuid, sub_interface_index), {

                #             'name': endpoint_uuid, 'index': sub_interface_index,

                #             'description': network_subinterface_desc, 'vlan_id': vlan_id,

                #             'address_ip': address_ip, 'address_prefix': address_prefix,

                #     }),

                #     json_config_rule_set(

                #         '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {

                #             'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_uuid,

                #             'subinterface': sub_interface_index,

                #     }),

                #     json_config_rule_set(

                #         '/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {

                #             'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,

                #     }),

                #     json_config_rule_set(

                #         '/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {

                #             'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',

                #             'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',

                #     }),

                #     json_config_rule_set(

                #         '/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(

                #             network_instance_name), {

                #             'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',

                #             'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {

                #             'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(

                #             network_instance_name, bgp_route_target), {

                #             'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),

                #             'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {

                #             'policy_name': '{:s}_import'.format(network_instance_name),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(

                #             network_instance_name, '3'), {

                #             'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',

                #             'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),

                #             'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',

                #     }),

                #     json_config_rule_set(

                #         # pylint: disable=duplicate-string-formatting-argument

                #         '/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(

                #             network_instance_name, network_instance_name), {

                #             'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {

                #             'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(

                #             network_instance_name, bgp_route_target), {

                #             'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),

                #             'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {

                #             'policy_name': '{:s}_export'.format(network_instance_name),

                #     }),

                #     json_config_rule_set(

                #         '/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(

                #             network_instance_name, '3'), {

                #             'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',

                #             'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),

                #             'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',

                #     }),

                #     json_config_rule_set(

                #         # pylint: disable=duplicate-string-formatting-argument

                #         '/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(

                #             network_instance_name, network_instance_name), {

                #             'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),

                #     }),

                # ])

                # self.__device_client.ConfigureDevice(Device(**json_device))

                # results.append(True)