Commit 8503a835 authored by Javier Diaz's avatar Javier Diaz
Browse files

Debugging

parent 6a73ac1f

src/dlt/connector/client/DltConnectorClient.py

+18 −18
Original line number Diff line number Diff line
@@ -48,64 +48,64 @@ class DltConnectorClient: 
        self.stub = None



    @RETRY_DECORATOR

    def RecordAll(self, request : TopologyId) -> Empty:

    async def RecordAll(self, request : TopologyId) -> Empty:

        LOGGER.debug('RecordAll request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordAll(request)

        response = await self.stub.RecordAll(request)

        LOGGER.debug('RecordAll result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordAllDevices(self, request : TopologyId) -> Empty:

    async def RecordAllDevices(self, request : TopologyId) -> Empty:

        LOGGER.debug('RecordAllDevices request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordAllDevices(request)

        response = await self.stub.RecordAllDevices(request)

        LOGGER.debug('RecordAllDevices result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordDevice(self, request : DltDeviceId) -> Empty:

    async def RecordDevice(self, request : DltDeviceId) -> Empty:

        LOGGER.debug('RecordDevice request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordDevice(request)

        response = await self.stub.RecordDevice(request)

        LOGGER.debug('RecordDevice result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordAllLinks(self, request : TopologyId) -> Empty:

    async def RecordAllLinks(self, request : TopologyId) -> Empty:

        LOGGER.debug('RecordAllLinks request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordAllLinks(request)

        response = await self.stub.RecordAllLinks(request)

        LOGGER.debug('RecordAllLinks result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordLink(self, request : DltLinkId) -> Empty:

    async def RecordLink(self, request : DltLinkId) -> Empty:

        LOGGER.debug('RecordLink request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordLink(request)

        response = await self.stub.RecordLink(request)

        LOGGER.debug('RecordLink result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordAllServices(self, request : TopologyId) -> Empty:

    async def RecordAllServices(self, request : TopologyId) -> Empty:

        LOGGER.debug('RecordAllServices request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordAllServices(request)

        response = await self.stub.RecordAllServices(request)

        LOGGER.debug('RecordAllServices result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordService(self, request : DltServiceId) -> Empty:

    async def RecordService(self, request : DltServiceId) -> Empty:

        LOGGER.debug('RecordService request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordService(request)

        response = await self.stub.RecordService(request)

        LOGGER.debug('RecordService result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordAllSlices(self, request : TopologyId) -> Empty:

    async def RecordAllSlices(self, request : TopologyId) -> Empty:

        LOGGER.debug('RecordAllSlices request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordAllSlices(request)

        response = await self.stub.RecordAllSlices(request)

        LOGGER.debug('RecordAllSlices result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def RecordSlice(self, request : DltSliceId) -> Empty:

    async def RecordSlice(self, request : DltSliceId) -> Empty:

        LOGGER.debug('RecordSlice request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordSlice(request)

        response = await self.stub.RecordSlice(request)

        LOGGER.debug('RecordSlice result: {:s}'.format(grpc_message_to_json_string(response)))

        return response

src/dlt/connector/client/DltGatewayClient.py

+10 −10
Original line number Diff line number Diff line
@@ -49,36 +49,36 @@ class DltGatewayClient: 
        self.stub = None



    @RETRY_DECORATOR

    def RecordToDlt(self, request : DltRecord) -> DltRecordStatus:

    async def RecordToDlt(self, request : DltRecord) -> DltRecordStatus:

        LOGGER.debug('RecordToDlt request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.RecordToDlt(request)

        response = await self.stub.RecordToDlt(request)

        LOGGER.debug('RecordToDlt result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def GetFromDlt(self, request : DltRecordId) -> DltRecord:

    async def GetFromDlt(self, request : DltRecordId) -> DltRecord:

        LOGGER.debug('GetFromDlt request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.GetFromDlt(request)

        response = await self.stub.GetFromDlt(request)

        LOGGER.debug('GetFromDlt result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def SubscribeToDlt(self, request : DltRecordSubscription) -> Iterator[DltRecordEvent]:

    async def SubscribeToDlt(self, request : DltRecordSubscription) -> Iterator[DltRecordEvent]:

        LOGGER.debug('SubscribeToDlt request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.SubscribeToDlt(request)

        response = await self.stub.SubscribeToDlt(request)

        LOGGER.debug('SubscribeToDlt result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def GetDltStatus(self, request : TeraFlowController) -> DltPeerStatus:

    async def GetDltStatus(self, request : TeraFlowController) -> DltPeerStatus:

        LOGGER.debug('GetDltStatus request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.GetDltStatus(request)

        response = await self.stub.GetDltStatus(request)

        LOGGER.debug('GetDltStatus result: {:s}'.format(grpc_message_to_json_string(response)))

        return response



    @RETRY_DECORATOR

    def GetDltPeers(self, request : Empty) -> DltPeerStatusList:

    async def GetDltPeers(self, request : Empty) -> DltPeerStatusList:

        LOGGER.debug('GetDltPeers request: {:s}'.format(grpc_message_to_json_string(request)))

        response = self.stub.GetDltPeers(request)

        response = await self.stub.GetDltPeers(request)

        LOGGER.debug('GetDltPeers result: {:s}'.format(grpc_message_to_json_string(response)))

        return response

src/dlt/connector/service/DltConnectorServiceServicerImpl.py

+14 −14
Original line number Diff line number Diff line
@@ -35,22 +35,22 @@ class DltConnectorServiceServicerImpl(DltConnectorServiceServicer): 
        LOGGER.debug('Servicer Created')



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordAll(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

    async def RecordAll(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordAllDevices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

    async def RecordAllDevices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordDevice(self, request : DltDeviceId, context : grpc.ServicerContext) -> Empty:

    async def RecordDevice(self, request : DltDeviceId, context : grpc.ServicerContext) -> Empty:

        data_json = None

        if not request.delete:

            context_client = ContextClient()

            device = context_client.GetDevice(request.device_id)

            data_json = grpc_message_to_json_string(device)



        self._record_entity(

        await self._record_entity(

            request.topology_id.topology_uuid.uuid, DltRecordTypeEnum.DLTRECORDTYPE_DEVICE,

            request.device_id.device_uuid.uuid, request.delete, data_json)

        return Empty()
@@ -60,53 +60,53 @@ class DltConnectorServiceServicerImpl(DltConnectorServiceServicer): 
        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordLink(self, request : DltLinkId, context : grpc.ServicerContext) -> Empty:

    async def RecordLink(self, request : DltLinkId, context : grpc.ServicerContext) -> Empty:

        data_json = None

        if not request.delete:

            context_client = ContextClient()

            link = context_client.GetLink(request.link_id)

            data_json = grpc_message_to_json_string(link)



        self._record_entity(

        await self._record_entity(

            request.topology_id.topology_uuid.uuid, DltRecordTypeEnum.DLTRECORDTYPE_LINK,

            request.link_id.link_uuid.uuid, request.delete, data_json)

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordAllServices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

    async def RecordAllServices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordService(self, request : DltServiceId, context : grpc.ServicerContext) -> Empty:

    async def RecordService(self, request : DltServiceId, context : grpc.ServicerContext) -> Empty:

        data_json = None

        if not request.delete:

            context_client = ContextClient()

            service = context_client.GetService(request.service_id)

            data_json = grpc_message_to_json_string(service)



        self._record_entity(

        await self._record_entity(

            request.topology_id.topology_uuid.uuid, DltRecordTypeEnum.DLTRECORDTYPE_SERVICE,

            request.service_id.service_uuid.uuid, request.delete, data_json)

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordAllSlices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

    async def RecordAllSlices(self, request : TopologyId, context : grpc.ServicerContext) -> Empty:

        return Empty()



    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RecordSlice(self, request : DltSliceId, context : grpc.ServicerContext) -> Empty:

    async def RecordSlice(self, request : DltSliceId, context : grpc.ServicerContext) -> Empty:

        data_json = None

        if not request.delete:

            context_client = ContextClient()

            slice_ = context_client.GetSlice(request.slice_id)

            data_json = grpc_message_to_json_string(slice_)



        self._record_entity(

        await self._record_entity(

            request.topology_id.topology_uuid.uuid, DltRecordTypeEnum.DLTRECORDTYPE_SLICE,

            request.slice_id.slice_uuid.uuid, request.delete, data_json)

        return Empty()



    def _record_entity(

    async def _record_entity(

        self, dlt_domain_uuid : str, dlt_record_type : DltRecordTypeEnum, dlt_record_uuid : str, delete : bool,

        data_json : Optional[str] = None

    ) -> None:
@@ -143,6 +143,6 @@ class DltConnectorServiceServicerImpl(DltConnectorServiceServicer): 


        str_dlt_record = grpc_message_to_json_string(dlt_record)

        LOGGER.debug('[_record_entity] sent dlt_record = {:s}'.format(str_dlt_record))

        dlt_record_status = dltgateway_client.RecordToDlt(dlt_record)

        dlt_record_status = await dltgateway_client.RecordToDlt(dlt_record)

        str_dlt_record_status = grpc_message_to_json_string(dlt_record_status)

        LOGGER.debug('[_record_entity] recv dlt_record_status = {:s}'.format(str_dlt_record_status))

src/interdomain/service/topology_abstractor/DltRecordSender.py

+5 −5
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ class DltRecordSender: 
        record_uuid = '{:s}:slice:{:s}/{:s}'.format(topology_uuid, context_uuid, slice_uuid)

        self._add_record(record_uuid, (topology_id, slice_))



    def commit(self) -> None:

    async def commit(self) -> None:

        for dlt_record_uuid in self.dlt_record_uuids:

            topology_id,dlt_record = self.dlt_record_uuid_to_data[dlt_record_uuid]

            if isinstance(dlt_record, Device):
@@ -73,7 +73,7 @@ class DltRecordSender: 
                dlt_device_id = DltDeviceId()

                dlt_device_id.topology_id.CopyFrom(topology_id)     # pylint: disable=no-member

                dlt_device_id.device_id.CopyFrom(device_id)         # pylint: disable=no-member

                self.dlt_connector_client.RecordDevice(dlt_device_id)

                await self.dlt_connector_client.RecordDevice(dlt_device_id)

            elif isinstance(dlt_record, Link):

                #link_id = self.context_client.SetLink(dlt_record)

                link_id = dlt_record.link_id
@@ -81,7 +81,7 @@ class DltRecordSender: 
                dlt_link_id = DltLinkId()

                dlt_link_id.topology_id.CopyFrom(topology_id)       # pylint: disable=no-member

                dlt_link_id.link_id.CopyFrom(link_id)               # pylint: disable=no-member

                self.dlt_connector_client.RecordLink(dlt_link_id)

                await self.dlt_connector_client.RecordLink(dlt_link_id)

            elif isinstance(dlt_record, Service):

                #service_id = self.context_client.SetService(dlt_record)

                service_id = dlt_record.service_id
@@ -89,7 +89,7 @@ class DltRecordSender: 
                dlt_service_id = DltServiceId()

                dlt_service_id.topology_id.CopyFrom(topology_id)    # pylint: disable=no-member

                dlt_service_id.service_id.CopyFrom(service_id)      # pylint: disable=no-member

                self.dlt_connector_client.RecordService(dlt_service_id)

                await self.dlt_connector_client.RecordService(dlt_service_id)

            elif isinstance(dlt_record, Slice):

                #slice_id = self.context_client.SetSlice(dlt_record)

                slice_id = dlt_record.slice_id
@@ -97,6 +97,6 @@ class DltRecordSender: 
                dlt_slice_id = DltSliceId()

                dlt_slice_id.topology_id.CopyFrom(topology_id)      # pylint: disable=no-member

                dlt_slice_id.slice_id.CopyFrom(slice_id)            # pylint: disable=no-member

                self.dlt_connector_client.RecordSlice(dlt_slice_id)

                await self.dlt_connector_client.RecordSlice(dlt_slice_id)

            else:

                LOGGER.error('Unsupported Record({:s})'.format(str(dlt_record)))