E2E Orchetsrator component:

# See the License for the specific language governing permissions and

# limitations under the License.

import copy

import requests

import copy, grpc, json, logging, networkx, requests, threading

from common.method_wrappers.Decorator import MetricsPool, safe_and_metered_rpc_method

from common.proto.e2eorchestrator_pb2 import E2EOrchestratorRequest, E2EOrchestratorReply

from common.proto.context_pb2 import (

    Empty, Connection, EndPointId, Link, LinkId, TopologyDetails, Topology, Context, Service, ServiceId,

    ServiceTypeEnum, ServiceStatusEnum)

from common.proto.e2eorchestrator_pb2_grpc import E2EOrchestratorServiceServicer

from common.proto.vnt_manager_pb2 import VNTSubscriptionRequest

from common.tools.grpc.Tools import grpc_message_to_json_string

from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME

from common.Settings import get_setting

from context.client.ContextClient import ContextClient

from service.client.ServiceClient import ServiceClient

from context.service.database.uuids.EndPoint import endpoint_get_uuid

from context.service.database.uuids.Device import device_get_uuid

from common.proto.vnt_manager_pb2 import VNTSubscriptionRequest

from common.tools.grpc.Tools import grpc_message_to_json_string

import grpc

import json

import logging

import networkx as nx

from threading import Thread

from service.client.ServiceClient import ServiceClient

from websockets.sync.client import connect

from websockets.sync.server import serve

from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME

LOGGER = logging.getLogger(__name__)

service_client: ServiceClient = ServiceClient()

EXT_HOST = str(get_setting('WS_IP_HOST'))

EXT_PORT = str(get_setting('WS_IP_PORT'))

EXT_PORT = int(get_setting('WS_IP_PORT'))

EXT_URL  = 'ws://{:s}:{:d}'.format(EXT_HOST, EXT_PORT)

OWN_HOST = str(get_setting('WS_E2E_HOST'))

OWN_PORT = str(get_setting('WS_E2E_PORT'))

OWN_PORT = int(get_setting('WS_E2E_PORT'))

ALL_HOSTS = "0.0.0.0"

class SubscriptionServer(Thread):

    def __init__(self):

        Thread.__init__(self)

ALL_HOSTS = '0.0.0.0'

class SubscriptionServer(threading.Thread):

    def run(self):

        url = "ws://" + EXT_HOST + ":" + EXT_PORT

        request = VNTSubscriptionRequest()

        request.host = OWN_HOST

        request.port = OWN_PORT

        try: 

            LOGGER.debug("Trying to connect to {}".format(url))

            websocket = connect(url)

        except Exception as ex:

            LOGGER.error('Error connecting to {}'.format(url))

            LOGGER.debug('Trying to connect to {:s}'.format(EXT_URL))

            websocket = connect(EXT_URL)

        except: # pylint: disable=bare-except

            LOGGER.exception('Error connecting to {:s}'.format(EXT_URL))

        else:

            with websocket:

                LOGGER.debug("Connected to {}".format(url))

                LOGGER.debug('Connected to {:s}'.format(EXT_URL))

                send = grpc_message_to_json_string(request)

                websocket.send(send)

                LOGGER.debug("Sent: {}".format(send))

                LOGGER.debug('Sent: {:s}'.format(send))

                try:

                    message = websocket.recv()

                    LOGGER.debug("Received message from WebSocket: {}".format(message))

                    LOGGER.debug('Received message from WebSocket: {:s}'.format(message))

                except Exception as ex:

                    LOGGER.error('Exception receiving from WebSocket: {}'.format(ex))

                    LOGGER.error('Exception receiving from WebSocket: {:s}'.format(ex))

            self._events_server()

    def _events_server(self):

        all_hosts = "0.0.0.0"

        try:

            server = serve(self._event_received, all_hosts, int(OWN_PORT))

        except Exception as ex:

            LOGGER.error('Error starting server on {}:{}'.format(all_hosts, OWN_PORT))

            LOGGER.error('Exception!: {}'.format(ex))

            server = serve(self._event_received, ALL_HOSTS, int(OWN_PORT))

        except: # pylint: disable=bare-except

            LOGGER.exception('Error starting server on {:s}:{:d}'.format(ALL_HOSTS, OWN_PORT))

        else:

            with server:

                LOGGER.info("Running events server...: {}:{}".format(all_hosts, OWN_PORT))

                LOGGER.info('Running events server...: {:s}:{:d}'.format(ALL_HOSTS, OWN_PORT))

                server.serve_forever()

class E2EOrchestratorServiceServicerImpl(E2EOrchestratorServiceServicer):

    def __init__(self):

        LOGGER.debug("Creating Servicer...")

        LOGGER.debug('Creating Servicer...')

        try:

            LOGGER.debug("Requesting subscription")

            LOGGER.debug('Requesting subscription')

            sub_server = SubscriptionServer()

            sub_server.start()

            LOGGER.debug("Servicer Created")

            LOGGER.debug('Servicer Created')

            self.retrieve_external_topologies()

        except Exception as ex:

            LOGGER.info("Exception!: {}".format(ex))

        except:

            LOGGER.exception('Unhandled Exception')

    def retrieve_external_topologies(self):

        i = 1

        while True:

            try:

                ADD  = str(get_setting(f'EXT_CONTROLLER{i}_ADD'))

                PORT = str(get_setting(f'EXT_CONTROLLER{i}_PORT'))

            except Exception as e:

                PORT = int(get_setting(f'EXT_CONTROLLER{i}_PORT'))

            except: # pylint: disable=bare-except

                break

            try:

                LOGGER.info(f'Retrieving external controller #{i}')

                url = f'http://{ADD}:{PORT}/tfs-api/context/{DEFAULT_CONTEXT_NAME}/topology_details/{DEFAULT_TOPOLOGY_NAME}'

                LOGGER.info(f'url= {url}')

                LOGGER.info('Retrieving external controller #{:d}'.format(i))

                url = 'http://{:s}:{:d}/tfs-api/context/{:s}/topology_details/{:s}'.format(

                    ADD, PORT, DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME

                )

                LOGGER.info('url={:s}'.format(str(url)))

                topo = requests.get(url).json()

                LOGGER.info(f'Retrieved external controller #{i}')

            except Exception as e:

                LOGGER.info(f'Exception retrieven topology from external controler #{i}: {e}')

                LOGGER.info('Retrieved external controller #{:d}'.format(i))

            except: # pylint: disable=bare-except

                LOGGER.exception('Exception retrieven topology from external controler #{:d}'.format(i))

            topology_details = TopologyDetails(**topo)

            context = Context()

            context.context_id.context_uuid.uuid = topology_details.topology_id.context_id.context_uuid.uuid

        for endpoint_id in request.service.service_endpoint_ids:

            endpoints_ids.append(endpoint_get_uuid(endpoint_id)[2])

        graph = nx.Graph()

        graph = networkx.Graph()

        devices = context_client.ListDevices(Empty()).devices

            graph.add_edge(eps[0], eps[1])

        shortest = nx.shortest_path(graph, endpoints_ids[0], endpoints_ids[1])

        shortest = networkx.shortest_path(graph, endpoints_ids[0], endpoints_ids[1])

        path = E2EOrchestratorReply()

        path.services.append(copy.deepcopy(request.service))