Commit 760ca2a9 authored by Antonio Gines Buendia Lopez's avatar Antonio Gines Buendia Lopez
Browse files

Remove old tests from component cloning

parent 91880668

src/pathcompextended/tests_old/.gitignore

deleted100644 → 0
+0 −15
Original line number Original line Diff line number Diff line 
# Copyright 2022-2025 ETSI SDG TeraFlowSDN (TFS) (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.



# Add here your files containing confidential testbed details such as IP addresses, ports, usernames, passwords, etc.

src/pathcompextended/tests_old/MockService_Dependencies.py

deleted100644 → 0
+0 −49
Original line number Original line Diff line number Diff line 
# Copyright 2022-2025 ETSI SDG TeraFlowSDN (TFS) (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 os

from typing import Union

from common.Constants import ServiceNameEnum

from common.Settings import ENVVAR_SUFIX_SERVICE_HOST, ENVVAR_SUFIX_SERVICE_PORT_GRPC, get_env_var_name

from common.proto.context_pb2_grpc import add_ContextServiceServicer_to_server

from common.proto.monitoring_pb2_grpc import add_MonitoringServiceServicer_to_server

from common.tests.MockServicerImpl_Context import MockServicerImpl_Context

from common.tests.MockServicerImpl_Monitoring import MockServicerImpl_Monitoring

from common.tools.service.GenericGrpcService import GenericGrpcService



LOCAL_HOST = '127.0.0.1'



SERVICE_CONTEXT    = ServiceNameEnum.CONTEXT

SERVICE_MONITORING = ServiceNameEnum.MONITORING



class MockService_Dependencies(GenericGrpcService):

    # Mock Service implementing Context, Device, and Service to simplify unitary tests of PathCompExtended



    def __init__(self, bind_port: Union[str, int]) -> None:

        super().__init__(bind_port, LOCAL_HOST, enable_health_servicer=False, cls_name='MockService')



    # pylint: disable=attribute-defined-outside-init

    def install_servicers(self):

        self.context_servicer = MockServicerImpl_Context()

        add_ContextServiceServicer_to_server(self.context_servicer, self.server)



        self.monitoring_servicer = MockServicerImpl_Monitoring()

        add_MonitoringServiceServicer_to_server(self.monitoring_servicer, self.server)



    def configure_env_vars(self):

        os.environ[get_env_var_name(SERVICE_CONTEXT, ENVVAR_SUFIX_SERVICE_HOST     )] = str(self.bind_address)

        os.environ[get_env_var_name(SERVICE_CONTEXT, ENVVAR_SUFIX_SERVICE_PORT_GRPC)] = str(self.bind_port)



        os.environ[get_env_var_name(SERVICE_MONITORING, ENVVAR_SUFIX_SERVICE_HOST     )] = str(self.bind_address)

        os.environ[get_env_var_name(SERVICE_MONITORING, ENVVAR_SUFIX_SERVICE_PORT_GRPC)] = str(self.bind_port)

src/pathcompextended/tests_old/Objects_A_B_C.py

deleted100644 → 0
+0 −160
Original line number Original line Diff line number Diff line 
# Copyright 2022-2025 ETSI SDG TeraFlowSDN (TFS) (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.



from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME

from common.tools.object_factory.Constraint import json_constraint_sla_capacity, json_constraint_sla_latency

from common.tools.object_factory.Context import json_context, json_context_id

from common.tools.object_factory.Device import json_device_emulated_packet_router_disabled, json_device_id

from common.tools.object_factory.EndPoint import json_endpoint_descriptor, json_endpoints

from common.tools.object_factory.Link import get_link_uuid, json_link, json_link_id

from common.tools.object_factory.Service import get_service_uuid, json_service_l3nm_planned

from common.tools.object_factory.Topology import json_topology, json_topology_id



def compose_device(device_uuid, endpoint_uuids, topology_id=None):

    device_id = json_device_id(device_uuid)

    endpoints = [json_endpoint_descriptor(endpoint_uuid, 'copper', []) for endpoint_uuid in endpoint_uuids]

    endpoints = json_endpoints(device_id, endpoints, topology_id=topology_id)

    device = json_device_emulated_packet_router_disabled(device_uuid, endpoints=endpoints)

    return device_id, endpoints, device



def compose_link(endpoint_a, endpoint_z):

    link_uuid = get_link_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])

    link_id   = json_link_id(link_uuid)

    link      = json_link(link_uuid, [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']])

    return link_id, link



def compose_service(endpoint_a, endpoint_z, constraints=[]):

    service_uuid = get_service_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])

    endpoint_ids = [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']]

    service = json_service_l3nm_planned(service_uuid, endpoint_ids=endpoint_ids, constraints=constraints)

    return service



# ----- Context --------------------------------------------------------------------------------------------------------

CONTEXT_ID = json_context_id(DEFAULT_CONTEXT_NAME)

CONTEXT    = json_context(DEFAULT_CONTEXT_NAME)



# ----- Domains --------------------------------------------------------------------------------------------------------

TOPOLOGY_ADMIN_UUID = DEFAULT_TOPOLOGY_NAME

TOPOLOGY_ADMIN_ID   = json_topology_id(TOPOLOGY_ADMIN_UUID, context_id=CONTEXT_ID)

TOPOLOGY_ADMIN      = json_topology(TOPOLOGY_ADMIN_UUID, context_id=CONTEXT_ID)



TOPOLOGY_A_UUID = 'A'

TOPOLOGY_A_ID   = json_topology_id(TOPOLOGY_A_UUID, context_id=CONTEXT_ID)

TOPOLOGY_A      = json_topology(TOPOLOGY_A_UUID, context_id=CONTEXT_ID)



TOPOLOGY_B_UUID = 'B'

TOPOLOGY_B_ID   = json_topology_id(TOPOLOGY_B_UUID, context_id=CONTEXT_ID)

TOPOLOGY_B      = json_topology(TOPOLOGY_B_UUID, context_id=CONTEXT_ID)



TOPOLOGY_C_UUID = 'C'

TOPOLOGY_C_ID   = json_topology_id(TOPOLOGY_C_UUID, context_id=CONTEXT_ID)

TOPOLOGY_C      = json_topology(TOPOLOGY_C_UUID, context_id=CONTEXT_ID)



# ----- Devices Domain A -----------------------------------------------------------------------------------------------

DEVICE_A1_ID, DEVICE_A1_ENDPOINTS, DEVICE_A1 = compose_device('A1', ['1', '2', '2000'], topology_id=TOPOLOGY_A_ID)

DEVICE_A2_ID, DEVICE_A2_ENDPOINTS, DEVICE_A2 = compose_device('A2', ['1', '2', '1001'], topology_id=TOPOLOGY_A_ID)

DEVICE_A3_ID, DEVICE_A3_ENDPOINTS, DEVICE_A3 = compose_device('A3', ['1', '2'        ], topology_id=TOPOLOGY_A_ID)



# ----- Devices Domain B -----------------------------------------------------------------------------------------------

DEVICE_B1_ID, DEVICE_B1_ENDPOINTS, DEVICE_B1 = compose_device('B1', ['1', '2', '2000'], topology_id=TOPOLOGY_B_ID)

DEVICE_B2_ID, DEVICE_B2_ENDPOINTS, DEVICE_B2 = compose_device('B2', ['1', '2', '1002'], topology_id=TOPOLOGY_B_ID)

DEVICE_B3_ID, DEVICE_B3_ENDPOINTS, DEVICE_B3 = compose_device('B3', ['1', '2'        ], topology_id=TOPOLOGY_B_ID)



# ----- Devices Domain C -----------------------------------------------------------------------------------------------

DEVICE_C1_ID, DEVICE_C1_ENDPOINTS, DEVICE_C1 = compose_device('C1', ['1', '2', '1001'], topology_id=TOPOLOGY_C_ID)

DEVICE_C2_ID, DEVICE_C2_ENDPOINTS, DEVICE_C2 = compose_device('C2', ['1', '2'        ], topology_id=TOPOLOGY_C_ID)

DEVICE_C3_ID, DEVICE_C3_ENDPOINTS, DEVICE_C3 = compose_device('C3', ['1', '2', '1002'], topology_id=TOPOLOGY_C_ID)



# ----- InterDomain Links ----------------------------------------------------------------------------------------------

LINK_A2_C3_ID, LINK_A2_C3 = compose_link(DEVICE_A2_ENDPOINTS[2], DEVICE_C3_ENDPOINTS[2])

LINK_C1_B2_ID, LINK_C1_B2 = compose_link(DEVICE_C1_ENDPOINTS[2], DEVICE_B2_ENDPOINTS[2])



LINK_C3_A2_ID, LINK_C3_A2 = compose_link(DEVICE_C3_ENDPOINTS[2], DEVICE_A2_ENDPOINTS[2])

LINK_B2_C1_ID, LINK_B2_C1 = compose_link(DEVICE_B2_ENDPOINTS[2], DEVICE_C1_ENDPOINTS[2])



# ----- IntraDomain A Links --------------------------------------------------------------------------------------------

LINK_A1_A2_ID, LINK_A1_A2 = compose_link(DEVICE_A1_ENDPOINTS[0], DEVICE_A2_ENDPOINTS[0])

LINK_A1_A3_ID, LINK_A1_A3 = compose_link(DEVICE_A1_ENDPOINTS[1], DEVICE_A3_ENDPOINTS[0])

LINK_A2_A3_ID, LINK_A2_A3 = compose_link(DEVICE_A2_ENDPOINTS[1], DEVICE_A3_ENDPOINTS[1])



LINK_A2_A1_ID, LINK_A2_A1 = compose_link(DEVICE_A2_ENDPOINTS[0], DEVICE_A1_ENDPOINTS[0])

LINK_A3_A1_ID, LINK_A3_A1 = compose_link(DEVICE_A3_ENDPOINTS[0], DEVICE_A1_ENDPOINTS[1])

LINK_A3_A2_ID, LINK_A3_A2 = compose_link(DEVICE_A3_ENDPOINTS[1], DEVICE_A2_ENDPOINTS[1])



# ----- IntraDomain B Links --------------------------------------------------------------------------------------------

LINK_B1_B2_ID, LINK_B1_B2 = compose_link(DEVICE_B1_ENDPOINTS[0], DEVICE_B2_ENDPOINTS[0])

LINK_B1_B3_ID, LINK_B1_B3 = compose_link(DEVICE_B1_ENDPOINTS[1], DEVICE_B3_ENDPOINTS[0])

LINK_B2_B3_ID, LINK_B2_B3 = compose_link(DEVICE_B2_ENDPOINTS[1], DEVICE_B3_ENDPOINTS[1])



LINK_B2_B1_ID, LINK_B2_B1 = compose_link(DEVICE_B2_ENDPOINTS[0], DEVICE_B1_ENDPOINTS[0])

LINK_B3_B1_ID, LINK_B3_B1 = compose_link(DEVICE_B3_ENDPOINTS[0], DEVICE_B1_ENDPOINTS[1])

LINK_B3_B2_ID, LINK_B3_B2 = compose_link(DEVICE_B3_ENDPOINTS[1], DEVICE_B2_ENDPOINTS[1])



# ----- IntraDomain C Links --------------------------------------------------------------------------------------------

LINK_C1_C2_ID, LINK_C1_C2 = compose_link(DEVICE_C1_ENDPOINTS[0], DEVICE_C2_ENDPOINTS[0])

LINK_C1_C3_ID, LINK_C1_C3 = compose_link(DEVICE_C1_ENDPOINTS[1], DEVICE_C3_ENDPOINTS[0])

LINK_C2_C3_ID, LINK_C2_C3 = compose_link(DEVICE_C2_ENDPOINTS[1], DEVICE_C3_ENDPOINTS[1])



LINK_C2_C1_ID, LINK_C2_C1 = compose_link(DEVICE_C2_ENDPOINTS[0], DEVICE_C1_ENDPOINTS[0])

LINK_C3_C1_ID, LINK_C3_C1 = compose_link(DEVICE_C3_ENDPOINTS[0], DEVICE_C1_ENDPOINTS[1])

LINK_C3_C2_ID, LINK_C3_C2 = compose_link(DEVICE_C3_ENDPOINTS[1], DEVICE_C2_ENDPOINTS[1])



# ----- Service --------------------------------------------------------------------------------------------------------

SERVICE_A1_B1 = compose_service(DEVICE_A1_ENDPOINTS[2], DEVICE_B1_ENDPOINTS[2], constraints=[

    json_constraint_sla_capacity(10.0),

    json_constraint_sla_latency(12.0),

])



# ----- Containers -----------------------------------------------------------------------------------------------------

CONTEXTS   = [  CONTEXT]

TOPOLOGIES = [  TOPOLOGY_ADMIN, TOPOLOGY_A, TOPOLOGY_B, TOPOLOGY_C]

DEVICES    = [  DEVICE_A1, DEVICE_A2, DEVICE_A3,

                DEVICE_B1, DEVICE_B2, DEVICE_B3,

                DEVICE_C1, DEVICE_C2, DEVICE_C3,    ]

LINKS      = [  LINK_A2_C3, LINK_C1_B2,

                LINK_C3_A2, LINK_B2_C1,



                LINK_A1_A2, LINK_A1_A3, LINK_A2_A3,

                LINK_A2_A1, LINK_A3_A1, LINK_A3_A2,



                LINK_B1_B2, LINK_B1_B3, LINK_B2_B3,

                LINK_B2_B1, LINK_B3_B1, LINK_B3_B2,



                LINK_C1_C2, LINK_C1_C3, LINK_C2_C3,

                LINK_C2_C1, LINK_C3_C1, LINK_C3_C2, ]

SERVICES   = [  SERVICE_A1_B1]



#OBJECTS_PER_TOPOLOGY = [

#    (TOPOLOGY_ADMIN_ID,

#        [   DEVICE_A1_ID, DEVICE_A2_ID, DEVICE_A3_ID,

#            DEVICE_B1_ID, DEVICE_B2_ID, DEVICE_B3_ID,

#            DEVICE_C1_ID, DEVICE_C2_ID, DEVICE_C3_ID,       ],

#        [   LINK_A2_C3_ID, LINK_C1_B2_ID,

#            LINK_A1_A2_ID, LINK_A1_A3_ID, LINK_A2_A3_ID,

#            LINK_B1_B2_ID, LINK_B1_B3_ID, LINK_B2_B3_ID,

#            LINK_C1_C2_ID, LINK_C1_C3_ID, LINK_C2_C3_ID,    ],

#    ),

#    (TOPOLOGY_A_ID,

#        [   DEVICE_A1_ID, DEVICE_A2_ID, DEVICE_A3_ID,       ],

#        [   LINK_A1_A2_ID, LINK_A1_A3_ID, LINK_A2_A3_ID,    ],

#    ),

#    (TOPOLOGY_B_ID,

#        [   DEVICE_B1_ID, DEVICE_B2_ID, DEVICE_B3_ID,       ],

#        [   LINK_B1_B2_ID, LINK_B1_B3_ID, LINK_B2_B3_ID,    ],

#    ),

#    (TOPOLOGY_C_ID,

#        [   DEVICE_C1_ID, DEVICE_C2_ID, DEVICE_C3_ID,       ],

#        [   LINK_C1_C2_ID, LINK_C1_C3_ID, LINK_C2_C3_ID,    ],

#    ),

#]

src/pathcompextended/tests_old/Objects_DC_CSGW_TN.py

deleted100644 → 0
+0 −215
Original line number Original line Diff line number Diff line 
# Copyright 2022-2025 ETSI SDG TeraFlowSDN (TFS) (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.



from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME

from common.tools.object_factory.Constraint import json_constraint_sla_capacity, json_constraint_sla_latency

from common.tools.object_factory.Context import json_context, json_context_id

from common.tools.object_factory.Device import (

    json_device_emulated_connect_rules, json_device_emulated_datacenter_disabled,

    json_device_emulated_packet_router_disabled, json_device_id)

from common.tools.object_factory.EndPoint import json_endpoint_descriptor, json_endpoints

from common.tools.object_factory.Link import get_link_uuid, json_link, json_link_id

from common.tools.object_factory.Service import get_service_uuid, json_service_l3nm_planned

from common.tools.object_factory.Topology import json_topology, json_topology_id



# if true, Device component is present and will infeer the endpoints from connect-rules

# if false, Device component is not present and device objects must contain preconfigured endpoints

ADD_CONNECT_RULES_TO_DEVICES = False



def compose_router(device_uuid, endpoint_uuids, topology_id=None):

    device_id = json_device_id(device_uuid)

    r_endpoints = [json_endpoint_descriptor(endpoint_uuid, 'copper') for endpoint_uuid in endpoint_uuids]

    config_rules = json_device_emulated_connect_rules(r_endpoints) if ADD_CONNECT_RULES_TO_DEVICES else []

    endpoints = json_endpoints(device_id, r_endpoints, topology_id=topology_id)

    j_endpoints = [] if ADD_CONNECT_RULES_TO_DEVICES else endpoints

    device = json_device_emulated_packet_router_disabled(device_uuid, config_rules=config_rules, endpoints=j_endpoints)

    return device_id, endpoints, device



def compose_datacenter(device_uuid, endpoint_uuids, topology_id=None):

    device_id = json_device_id(device_uuid)

    r_endpoints = [json_endpoint_descriptor(endpoint_uuid, 'copper') for endpoint_uuid in endpoint_uuids]

    config_rules = json_device_emulated_connect_rules(r_endpoints) if ADD_CONNECT_RULES_TO_DEVICES else []

    endpoints = json_endpoints(device_id, r_endpoints, topology_id=topology_id)

    j_endpoints = [] if ADD_CONNECT_RULES_TO_DEVICES else endpoints

    device = json_device_emulated_datacenter_disabled(device_uuid, config_rules=config_rules, endpoints=j_endpoints)

    return device_id, endpoints, device



def compose_link(endpoint_a, endpoint_z):

    link_uuid = get_link_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])

    link_id   = json_link_id(link_uuid)

    link      = json_link(link_uuid, [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']])

    return link_id, link



def compose_service(endpoint_a, endpoint_z, constraints=[]):

    service_uuid = get_service_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])

    endpoint_ids = [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']]

    service = json_service_l3nm_planned(service_uuid, endpoint_ids=endpoint_ids, constraints=constraints)

    return service



# ----- Context --------------------------------------------------------------------------------------------------------

CONTEXT_ID = json_context_id(DEFAULT_CONTEXT_NAME)

CONTEXT    = json_context(DEFAULT_CONTEXT_NAME)



# ----- Domains --------------------------------------------------------------------------------------------------------

# Overall network topology

TOPO_ADMIN_UUID = DEFAULT_TOPOLOGY_NAME

TOPO_ADMIN_ID   = json_topology_id(TOPO_ADMIN_UUID, context_id=CONTEXT_ID)

TOPO_ADMIN      = json_topology(TOPO_ADMIN_UUID, context_id=CONTEXT_ID)



# DataCenter #1 Network

TOPO_DC1_UUID = 'DC1'

TOPO_DC1_ID   = json_topology_id(TOPO_DC1_UUID, context_id=CONTEXT_ID)

TOPO_DC1      = json_topology(TOPO_DC1_UUID, context_id=CONTEXT_ID)



# DataCenter #2 Network

TOPO_DC2_UUID = 'DC2'

TOPO_DC2_ID   = json_topology_id(TOPO_DC2_UUID, context_id=CONTEXT_ID)

TOPO_DC2      = json_topology(TOPO_DC2_UUID, context_id=CONTEXT_ID)



# CellSite #1 Network

TOPO_CS1_UUID = 'CS1'

TOPO_CS1_ID   = json_topology_id(TOPO_CS1_UUID, context_id=CONTEXT_ID)

TOPO_CS1      = json_topology(TOPO_CS1_UUID, context_id=CONTEXT_ID)



# CellSite #2 Network

TOPO_CS2_UUID = 'CS2'

TOPO_CS2_ID   = json_topology_id(TOPO_CS2_UUID, context_id=CONTEXT_ID)

TOPO_CS2      = json_topology(TOPO_CS2_UUID, context_id=CONTEXT_ID)



# Transport Network Network

TOPO_TN_UUID = 'TN'

TOPO_TN_ID   = json_topology_id(TOPO_TN_UUID, context_id=CONTEXT_ID)

TOPO_TN      = json_topology(TOPO_TN_UUID, context_id=CONTEXT_ID)





# ----- Devices --------------------------------------------------------------------------------------------------------

# DataCenters

DEV_DC1GW_ID, DEV_DC1GW_EPS, DEV_DC1GW = compose_datacenter('DC1-GW', ['eth1', 'eth2', 'int'])

DEV_DC2GW_ID, DEV_DC2GW_EPS, DEV_DC2GW = compose_datacenter('DC2-GW', ['eth1', 'eth2', 'int'])



# CellSites

DEV_CS1GW1_ID, DEV_CS1GW1_EPS, DEV_CS1GW1 = compose_router('CS1-GW1', ['10/1', '1/1', '1/2'])

DEV_CS1GW2_ID, DEV_CS1GW2_EPS, DEV_CS1GW2 = compose_router('CS1-GW2', ['10/1', '1/1', '1/2'])

DEV_CS2GW1_ID, DEV_CS2GW1_EPS, DEV_CS2GW1 = compose_router('CS2-GW1', ['10/1', '1/1', '1/2'])

DEV_CS2GW2_ID, DEV_CS2GW2_EPS, DEV_CS2GW2 = compose_router('CS2-GW2', ['10/1', '1/1', '1/2'])



# Transport Network

DEV_TNR1_ID, DEV_TNR1_EPS, DEV_TNR1 = compose_router('TN-R1', ['1/1', '1/2', '2/1', '2/2', '2/3'])

DEV_TNR2_ID, DEV_TNR2_EPS, DEV_TNR2 = compose_router('TN-R2', ['1/1', '1/2', '2/1', '2/2', '2/3'])

DEV_TNR3_ID, DEV_TNR3_EPS, DEV_TNR3 = compose_router('TN-R3', ['1/1', '1/2', '2/1', '2/2', '2/3'])

DEV_TNR4_ID, DEV_TNR4_EPS, DEV_TNR4 = compose_router('TN-R4', ['1/1', '1/2', '2/1', '2/2', '2/3'])





# ----- Links ----------------------------------------------------------------------------------------------------------

# InterDomain DC-CSGW

LINK_DC1GW_CS1GW1_ID, LINK_DC1GW_CS1GW1 = compose_link(DEV_DC1GW_EPS[0], DEV_CS1GW1_EPS[0])

LINK_DC1GW_CS1GW2_ID, LINK_DC1GW_CS1GW2 = compose_link(DEV_DC1GW_EPS[1], DEV_CS1GW2_EPS[0])

LINK_DC2GW_CS2GW1_ID, LINK_DC2GW_CS2GW1 = compose_link(DEV_DC2GW_EPS[0], DEV_CS2GW1_EPS[0])

LINK_DC2GW_CS2GW2_ID, LINK_DC2GW_CS2GW2 = compose_link(DEV_DC2GW_EPS[1], DEV_CS2GW2_EPS[0])



LINK_CS1GW1_DC1GW_ID, LINK_CS1GW1_DC1GW = compose_link(DEV_CS1GW1_EPS[0], DEV_DC1GW_EPS[0])

LINK_CS1GW2_DC1GW_ID, LINK_CS1GW2_DC1GW = compose_link(DEV_CS1GW2_EPS[0], DEV_DC1GW_EPS[1])

LINK_CS2GW1_DC2GW_ID, LINK_CS2GW1_DC2GW = compose_link(DEV_CS2GW1_EPS[0], DEV_DC2GW_EPS[0])

LINK_CS2GW2_DC2GW_ID, LINK_CS2GW2_DC2GW = compose_link(DEV_CS2GW2_EPS[0], DEV_DC2GW_EPS[1])



# InterDomain CSGW-TN

LINK_CS1GW1_TNR1_ID, LINK_CS1GW1_TNR1 = compose_link(DEV_CS1GW1_EPS[1], DEV_TNR1_EPS[0])

LINK_CS1GW2_TNR2_ID, LINK_CS1GW2_TNR2 = compose_link(DEV_CS1GW2_EPS[1], DEV_TNR2_EPS[0])

LINK_CS1GW1_TNR2_ID, LINK_CS1GW1_TNR2 = compose_link(DEV_CS1GW1_EPS[2], DEV_TNR2_EPS[1])

LINK_CS1GW2_TNR1_ID, LINK_CS1GW2_TNR1 = compose_link(DEV_CS1GW2_EPS[2], DEV_TNR1_EPS[1])

LINK_CS2GW1_TNR3_ID, LINK_CS2GW1_TNR3 = compose_link(DEV_CS2GW1_EPS[1], DEV_TNR3_EPS[0])

LINK_CS2GW2_TNR4_ID, LINK_CS2GW2_TNR4 = compose_link(DEV_CS2GW2_EPS[1], DEV_TNR4_EPS[0])

LINK_CS2GW1_TNR4_ID, LINK_CS2GW1_TNR4 = compose_link(DEV_CS2GW1_EPS[2], DEV_TNR4_EPS[1])

LINK_CS2GW2_TNR3_ID, LINK_CS2GW2_TNR3 = compose_link(DEV_CS2GW2_EPS[2], DEV_TNR3_EPS[1])



LINK_TNR1_CS1GW1_ID, LINK_TNR1_CS1GW1 = compose_link(DEV_TNR1_EPS[0], DEV_CS1GW1_EPS[1])

LINK_TNR2_CS1GW2_ID, LINK_TNR2_CS1GW2 = compose_link(DEV_TNR2_EPS[0], DEV_CS1GW2_EPS[1])

LINK_TNR2_CS1GW1_ID, LINK_TNR2_CS1GW1 = compose_link(DEV_TNR2_EPS[1], DEV_CS1GW1_EPS[2])

LINK_TNR1_CS1GW2_ID, LINK_TNR1_CS1GW2 = compose_link(DEV_TNR1_EPS[1], DEV_CS1GW2_EPS[2])

LINK_TNR3_CS2GW1_ID, LINK_TNR3_CS2GW1 = compose_link(DEV_TNR3_EPS[0], DEV_CS2GW1_EPS[1])

LINK_TNR4_CS2GW2_ID, LINK_TNR4_CS2GW2 = compose_link(DEV_TNR4_EPS[0], DEV_CS2GW2_EPS[1])

LINK_TNR4_CS2GW1_ID, LINK_TNR4_CS2GW1 = compose_link(DEV_TNR4_EPS[1], DEV_CS2GW1_EPS[2])

LINK_TNR3_CS2GW2_ID, LINK_TNR3_CS2GW2 = compose_link(DEV_TNR3_EPS[1], DEV_CS2GW2_EPS[2])



# IntraDomain TN

LINK_TNR1_TNR2_ID, LINK_TNR1_TNR2 = compose_link(DEV_TNR1_EPS[2], DEV_TNR2_EPS[3])

LINK_TNR2_TNR3_ID, LINK_TNR2_TNR3 = compose_link(DEV_TNR2_EPS[2], DEV_TNR3_EPS[3])

LINK_TNR3_TNR4_ID, LINK_TNR3_TNR4 = compose_link(DEV_TNR3_EPS[2], DEV_TNR4_EPS[3])

LINK_TNR4_TNR1_ID, LINK_TNR4_TNR1 = compose_link(DEV_TNR4_EPS[2], DEV_TNR1_EPS[3])

LINK_TNR1_TNR3_ID, LINK_TNR1_TNR3 = compose_link(DEV_TNR1_EPS[4], DEV_TNR3_EPS[4])

LINK_TNR2_TNR4_ID, LINK_TNR2_TNR4 = compose_link(DEV_TNR2_EPS[4], DEV_TNR4_EPS[4])



LINK_TNR2_TNR1_ID, LINK_TNR2_TNR1 = compose_link(DEV_TNR2_EPS[3], DEV_TNR1_EPS[2])

LINK_TNR3_TNR2_ID, LINK_TNR3_TNR2 = compose_link(DEV_TNR3_EPS[3], DEV_TNR2_EPS[2])

LINK_TNR4_TNR3_ID, LINK_TNR4_TNR3 = compose_link(DEV_TNR4_EPS[3], DEV_TNR3_EPS[2])

LINK_TNR1_TNR4_ID, LINK_TNR1_TNR4 = compose_link(DEV_TNR1_EPS[3], DEV_TNR4_EPS[2])

LINK_TNR3_TNR1_ID, LINK_TNR3_TNR1 = compose_link(DEV_TNR3_EPS[4], DEV_TNR1_EPS[4])

LINK_TNR4_TNR2_ID, LINK_TNR4_TNR2 = compose_link(DEV_TNR4_EPS[4], DEV_TNR2_EPS[4])





# ----- Service --------------------------------------------------------------------------------------------------------

SERVICE_DC1GW_DC2GW = compose_service(DEV_DC1GW_EPS[2], DEV_DC2GW_EPS[2], constraints=[

    json_constraint_sla_capacity(10.0),

    json_constraint_sla_latency(20.0),

])



# ----- Containers -----------------------------------------------------------------------------------------------------

CONTEXTS   = [  CONTEXT ]

TOPOLOGIES = [  TOPO_ADMIN, TOPO_DC1, TOPO_DC2, TOPO_CS1, TOPO_CS2, TOPO_TN ]

DEVICES    = [  DEV_DC1GW, DEV_DC2GW,

                DEV_CS1GW1, DEV_CS1GW2, DEV_CS2GW1, DEV_CS2GW2,

                DEV_TNR1, DEV_TNR2, DEV_TNR3, DEV_TNR4,

            ]

LINKS      = [  LINK_DC1GW_CS1GW1, LINK_DC1GW_CS1GW2, LINK_DC2GW_CS2GW1, LINK_DC2GW_CS2GW2,

                LINK_CS1GW1_DC1GW, LINK_CS1GW2_DC1GW, LINK_CS2GW1_DC2GW, LINK_CS2GW2_DC2GW,



                LINK_CS1GW1_TNR1, LINK_CS1GW2_TNR2, LINK_CS1GW1_TNR2, LINK_CS1GW2_TNR1,

                LINK_CS2GW1_TNR3, LINK_CS2GW2_TNR4, LINK_CS2GW1_TNR4, LINK_CS2GW2_TNR3,

                LINK_TNR1_TNR2, LINK_TNR2_TNR3, LINK_TNR3_TNR4, LINK_TNR4_TNR1, LINK_TNR1_TNR3, LINK_TNR2_TNR4,

                LINK_TNR2_TNR1, LINK_TNR3_TNR2, LINK_TNR4_TNR3, LINK_TNR1_TNR4, LINK_TNR3_TNR1, LINK_TNR4_TNR2,

            ]

SERVICES   = [  SERVICE_DC1GW_DC2GW   ]



#OBJECTS_PER_TOPOLOGY = [

#    (TOPO_ADMIN_ID,

#        [   DEV_DC1GW_ID, DEV_DC2GW_ID,

#            DEV_CS1GW1_ID, DEV_CS1GW2_ID, DEV_CS2GW1_ID, DEV_CS2GW2_ID,

#            DEV_TNR1_ID, DEV_TNR2_ID, DEV_TNR3_ID, DEV_TNR4_ID,

#        ],

#        [   LINK_DC1GW_CS1GW1_ID, LINK_DC1GW_CS1GW2_ID, LINK_DC2GW_CS2GW1_ID, LINK_DC2GW_CS2GW2_ID,

#            LINK_CS1GW1_TNR1_ID, LINK_CS1GW2_TNR2_ID, LINK_CS1GW1_TNR2_ID, LINK_CS1GW2_TNR1_ID,

#            LINK_CS2GW1_TNR3_ID, LINK_CS2GW2_TNR4_ID, LINK_CS2GW1_TNR4_ID, LINK_CS2GW2_TNR3_ID,

#            LINK_TNR1_TNR2_ID, LINK_TNR2_TNR3_ID, LINK_TNR3_TNR4_ID, LINK_TNR4_TNR1_ID, LINK_TNR1_TNR3_ID,

#            LINK_TNR2_TNR4_ID,

#        ],

#    ),

#    (TOPO_DC1_ID,

#        [DEV_DC1GW_ID],

#        []),

#    (TOPO_DC2_ID,

#        [DEV_DC2GW_ID],

#        []),

#    (TOPO_CS1_ID,

#        [DEV_CS1GW1_ID, DEV_CS1GW2_ID],

#        []),

#    (TOPO_CS2_ID,

#        [DEV_CS2GW1_ID, DEV_CS2GW2_ID],

#        []),

#    (TOPO_TN_ID,

#        [   DEV_TNR1_ID, DEV_TNR2_ID, DEV_TNR3_ID, DEV_TNR4_ID,

#        ],

#        [   LINK_TNR1_TNR2_ID, LINK_TNR2_TNR3_ID, LINK_TNR3_TNR4_ID, LINK_TNR4_TNR1_ID, LINK_TNR1_TNR3_ID,

#            LINK_TNR2_TNR4_ID,

#        ]),

#]

src/pathcompextended/tests_old/Objects_DC_CSGW_TN_OLS.py

deleted100644 → 0
+0 −228

File deleted.

Preview size limit exceeded, changes collapsed.