Merge branch 'feat/tid-add-support-for-ietf-slices' into 'develop'

#    # do test ...

#    descriptor_loader.unload()

import concurrent.futures, json, logging, operator

import concurrent.futures, copy, json, logging, operator

from typing import Any, Dict, List, Optional, Tuple, Union

from common.proto.context_pb2 import (

    Connection, Context, ContextId, Device, DeviceId, Empty, Link, LinkId, Service, ServiceId, Slice, SliceId,

    Topology, TopologyId)

    Connection, Context, ContextId, Device, DeviceId, Empty,

    Link, LinkId, Service, ServiceId, Slice, SliceId,

    Topology, TopologyId

)

from common.tools.object_factory.Context import json_context_id

from context.client.ContextClient import ContextClient

from device.client.DeviceClient import DeviceClient

from service.client.ServiceClient import ServiceClient

from slice.client.SliceClient import SliceClient

from .Tools import (

    format_device_custom_config_rules, format_service_custom_config_rules, format_slice_custom_config_rules,

    get_descriptors_add_contexts, get_descriptors_add_services, get_descriptors_add_slices,

    get_descriptors_add_topologies, split_controllers_and_network_devices, split_devices_by_rules)

    format_device_custom_config_rules, format_service_custom_config_rules,

    format_slice_custom_config_rules, get_descriptors_add_contexts,

    get_descriptors_add_services, get_descriptors_add_slices,

    get_descriptors_add_topologies, split_controllers_and_network_devices,

    split_devices_by_rules

)

LOGGER = logging.getLogger(__name__)

LOGGERS = {

TypeNotification = Tuple[str, str] # message, level

TypeNotificationList = List[TypeNotification]

SLICE_TEMPLATE = {

    "slice_id": {

        "context_id": {"context_uuid": {"uuid": "admin"}},

        "slice_uuid": {"uuid": None}

    },

    "name": {},

    "slice_config": {"config_rules": [

        {"action": 1, "custom": {"resource_key": "/settings", "resource_value": {

            "address_families": ["IPV4"], "bgp_as": 65000,

            "bgp_route_target": "65000:333", "mtu": 1512

        }}}

    ]},

    "slice_constraints": [

        {"sla_capacity": {"capacity_gbps": 20.0}},

        {"sla_availability": {"availability": 20.0, "num_disjoint_paths": 1, "all_active": True}},

        {"sla_isolation": {"isolation_level": [0]}}

    ],

    "slice_endpoint_ids": [

    ],

    "slice_status": {"slice_status": 1}

}

class DescriptorLoader:

    def __init__(

        self, descriptors : Optional[Union[str, Dict]] = None, descriptors_file : Optional[str] = None,

        self.__links       = self.__descriptors.get('links'      , [])

        self.__services    = self.__descriptors.get('services'   , [])

        self.__slices      = self.__descriptors.get('slices'     , [])

        self.__ietf_slices = self.__descriptors.get('ietf-network-slice-service:network-slice-services', {})

        self.__connections = self.__descriptors.get('connections', [])

        if len(self.__ietf_slices) > 0:

            for slice_service in self.__ietf_slices["slice-service"]:

                tfs_slice = copy.deepcopy(SLICE_TEMPLATE)

                tfs_slice["slice_id"]["slice_uuid"]["uuid"] = slice_service["id"]

                tfs_slice["name"] = slice_service["description"]

                for sdp in slice_service["sdps"]["sdp"]:

                    sdp_id = sdp["id"]

                    for attcircuit in sdp["attachment-circuits"]["attachment-circuit"]:

                        att_cir_tp_id = attcircuit["ac-tp-id"]

                        RESOURCE_KEY = "/device[{:s}]/endpoint[{:s}]/settings"

                        resource_key = RESOURCE_KEY.format(str(sdp_id), str(att_cir_tp_id))

                        for tag in attcircuit['ac-tags']['ac-tag']:

                            if tag.get('tag-type') == 'ietf-nss:vlan-id':

                                vlan_id = tag.get('value')

                            else:

                                vlan_id = 0

                        tfs_slice["slice_config"]["config_rules"].append({

                            "action": 1, "custom": {

                                "resource_key": resource_key, "resource_value": {

                                    "router_id": sdp.get("node-id",[]),

                                    "sub_interface_index": 0,

                                    "vlan_id": vlan_id

                                }

                            }

                        })

                        tfs_slice["slice_endpoint_ids"].append({

                            "device_id": {"device_uuid": {"uuid": sdp_id}},

                            "endpoint_uuid": {"uuid": att_cir_tp_id},

                            "topology_id": {"context_id": {"context_uuid": {"uuid": "admin"}}, 

                            "topology_uuid": {"uuid": "admin"}}

                        })

                        #tfs_slice["slice_constraints"].append({

                        #    "endpoint_location": {

                        #        "endpoint_id": {

                        #            "device_id": {"device_uuid": {"uuid": sdp["id"]}},

                        #            "endpoint_uuid": {"uuid": attcircuit["ac-tp-id"]}

                        #        },

                        #        "location": {"region": "4"}

                        #    }

                        #})

                self.__slices.append(tfs_slice)

        self.__contexts_add   = None

        self.__topologies_add = None

        self.__devices_add    = None

    def _load_dummy_mode(self) -> None:

        # Dummy Mode: used to pre-load databases (WebUI debugging purposes) with no smart or automated tasks.

        controllers, network_devices = split_controllers_and_network_devices(self.__devices)

        self.__ctx_cli.connect()

        self._process_descr('context',    'add',    self.__ctx_cli.SetContext,    Context,    self.__contexts_add  )

        self._process_descr('topology',   'add',    self.__ctx_cli.SetTopology,   Topology,   self.__topologies_add)