Commit 0dff3f59 authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Several changes in Device: 

- Multiple minor bug resolutions
- DeviceClient: solved logging bug
- EmulatedDriver: solved GetConfig bug and added event to prevent double connection requests
- DriverInstanceCache, DriverFactory: Added formatting of filter fields
- DataCache: solved minor bug
- DriverAPI test unit: corrected getconfig assertion check
- Device test unit: reimplemented, first complete test after component reworking
- DataCache/DeviceTools: solved several minor bugs
- DeviceServiceServicerImpl: added removal of drivers and endpoints when device is removed.
parent 3e5ef106

run_tests_locally.sh

+1 −1
Original line number Diff line number Diff line
@@ -26,8 +26,8 @@ rm -f $COVERAGEFILE 
#    context/tests/test_unitary.py



coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \

    device/tests/test_unitary_driverapi.py \

    device/tests/test_unitary.py

    #device/tests/test_unitary_driverapi.py \



#coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \

#    service/tests/test_unitary.py

src/device/client/DeviceClient.py

+8 −8
Original line number Diff line number Diff line
@@ -27,28 +27,28 @@ class DeviceClient: 


    @retry(exceptions=set(), max_retries=MAX_RETRIES, delay_function=DELAY_FUNCTION, prepare_method_name='connect')

    def AddDevice(self, request : Device) -> DeviceId:

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

        LOGGER.debug('AddDevice request: {:s}'.format(str(request)))

        response = self.stub.AddDevice(request)

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

        LOGGER.debug('AddDevice result: {:s}'.format(str(response)))

        return response



    @retry(exceptions=set(), max_retries=MAX_RETRIES, delay_function=DELAY_FUNCTION, prepare_method_name='connect')

    def ConfigureDevice(self, request : Device) -> DeviceId:

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

        LOGGER.debug('ConfigureDevice request: {:s}'.format(str(request)))

        response = self.stub.ConfigureDevice(request)

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

        LOGGER.debug('ConfigureDevice result: {:s}'.format(str(response)))

        return response



    @retry(exceptions=set(), max_retries=MAX_RETRIES, delay_function=DELAY_FUNCTION, prepare_method_name='connect')

    def DeleteDevice(self, request : DeviceId) -> Empty:

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

        LOGGER.debug('DeleteDevice request: {:s}'.format(str(request)))

        response = self.stub.DeleteDevice(request)

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

        LOGGER.debug('DeleteDevice result: {:s}'.format(str(response)))

        return response



    @retry(exceptions=set(), max_retries=MAX_RETRIES, delay_function=DELAY_FUNCTION, prepare_method_name='connect')

    def GetInitialConfig(self, request : DeviceId) -> DeviceConfig:

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

        LOGGER.debug('GetInitialConfig request: {:s}'.format(str(request)))

        response = self.stub.GetInitialConfig(request)

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

        LOGGER.debug('GetInitialConfig result: {:s}'.format(str(response)))

        return response

src/device/service/DeviceServiceServicerImpl.py

+21 −7
Original line number Diff line number Diff line 
from typing import Any, List, Tuple

import grpc, logging

from common.rpc_method_wrapper.Decorator import create_metrics, safe_and_metered_rpc_method

from device.proto.context_pb2 import Device, DeviceConfig, DeviceId, Empty

from device.proto.device_pb2_grpc import DeviceServiceServicer

from .data_cache.DataCache import DataCache

from .data_cache.database.DeviceModel import DriverModel

from .data_cache.database.EndPointModel import EndPointModel

from .driver_api._Driver import _Driver

from .driver_api.DriverInstanceCache import DriverInstanceCache

from .driver_api.FilterFields import FilterFieldEnum

#from .Tools import check_device_id_request, check_device_request



LOGGER = logging.getLogger(__name__)
@@ -31,7 +30,7 @@ class DeviceServiceServicerImpl(DeviceServiceServicer): 
        db_device,_ = self.data_cache.set_device(request)



        driver_filter_fields = self.data_cache.get_device_driver_filter_fields(device_uuid)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, **driver_filter_fields)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, driver_filter_fields)

        driver.Connect()



        running_config_rules = driver.GetConfig()
@@ -62,7 +61,7 @@ class DeviceServiceServicerImpl(DeviceServiceServicer): 
        # Compute list of changes between device_config in context, and device_config in request



        driver_filter_fields = self.data_cache.get_device_driver_filter_fields(device_uuid)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, **driver_filter_fields)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, driver_filter_fields)

        driver.Connect()



        #results_setconfig = driver.SetConfig(resources_to_set)
@@ -82,11 +81,26 @@ class DeviceServiceServicerImpl(DeviceServiceServicer): 
        device_uuid = request.device_uuid.uuid

        self.data_cache.sync_device_from_context(device_uuid)

        db_device = self.data_cache.get_device(device_uuid)



        driver_filter_fields = self.data_cache.get_device_driver_filter_fields(device_uuid)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, **driver_filter_fields)

        driver : _Driver = self.driver_instance_cache.get(device_uuid, driver_filter_fields)

        driver.Disconnect()



        self.data_cache.delete_device_from_context(device_uuid)



        for db_endpoint_pk,_ in db_device.references(EndPointModel):

            EndPointModel(db_device.database, db_endpoint_pk).delete()



        for db_driver_pk,_ in db_device.references(DriverModel):

            DriverModel(db_device.database, db_driver_pk).delete()



        #db_config = ConfigModel(db_device.database, db_device.device_config_fk)

        #for db_config_rule_pk,_ in db_config.references(ConfigRuleModel):

        #    ConfigRuleModel(db_device.database, db_config_rule_pk).delete()



        db_device.delete()

        #db_config.delete()



        return Empty()



    @safe_and_metered_rpc_method(METRICS, LOGGER)
@@ -94,4 +108,4 @@ class DeviceServiceServicerImpl(DeviceServiceServicer): 
        device_uuid = request.device_uuid.uuid

        self.data_cache.sync_device_from_context(device_uuid)

        db_device = self.data_cache.get_device(device_uuid)

        return DeviceConfig(device_config={'config_rules': db_device.dump_initial_config()})
 
        return DeviceConfig(config_rules=db_device.dump_initial_config())

src/device/service/data_cache/DataCache.py

+2 −2
Original line number Diff line number Diff line
@@ -6,8 +6,8 @@ from common.orm.HighLevel import get_object 
from common.orm.backend.BackendEnum import BackendEnum

from context.client.ContextClient import ContextClient

from device.proto.context_pb2 import Device, DeviceId

from database.ConfigModel import set_config

from device.service.driver_api.FilterFields import FilterFieldEnum

#from .database.ConfigModel import set_config

from .database.DeviceModel import DeviceModel, DriverModel

from .DeviceTools import update_device_config_in_local_database, update_device_in_local_database
@@ -40,7 +40,7 @@ class DataCache: 
        try:

            device : Device = self._context_client.GetDevice(DeviceId(device_uuid={'uuid': device_uuid}))

        except grpc.RpcError as e:

            if e.value.code() != grpc.StatusCode.NOT_FOUND: raise

            if e.code() != grpc.StatusCode.NOT_FOUND: raise

            return None

        return update_device_in_local_database(self._database, device)

src/device/service/data_cache/DeviceTools.py

+18 −8
Original line number Diff line number Diff line
@@ -26,12 +26,14 @@ def update_device_in_local_database(database : Database, device : Device) -> Tup 
                'request.device_endpoints[{:d}].device_id.device_uuid.uuid'.format(i), endpoint_device_uuid,

                ['should be == {:s}({:s})'.format('request.device_id.device_uuid.uuid', device_uuid)])



    initial_config_result = set_config(database, device_uuid, 'initial', [])

    running_config_result = set_config(database, device_uuid, 'running', device.device_config.config_rules)

    result : Tuple[DeviceModel, bool] = update_or_create_object(database, DeviceModel, device_uuid, {

        'device_uuid'              : device_uuid,

        'device_type'              : device.device_type,

        'device_operational_status': grpc_to_enum__device_operational_status(device.device_operational_status),

        'device_config_fk'         : running_config_result[0][0],

        'device_initial_config_fk' : initial_config_result[0][0],

        'device_running_config_fk' : running_config_result[0][0],

    })

    db_device, updated = result

    set_drivers(database, db_device, device.device_drivers)
@@ -51,24 +53,32 @@ def update_device_in_local_database(database : Database, device : Device) -> Tup 
        endpoint_topology_context_uuid = endpoint.endpoint_id.topology_id.context_id.context_uuid.uuid

        endpoint_topology_uuid = endpoint.endpoint_id.topology_id.topology_uuid.uuid

        if len(endpoint_topology_context_uuid) > 0 and len(endpoint_topology_uuid) > 0:

            db_context : ContextModel = get_or_create_object(database, ContextModel, endpoint_topology_context_uuid)

            result : Tuple[ContextModel, bool] = get_or_create_object(

                database, ContextModel, endpoint_topology_context_uuid, defaults={

                    'context_uuid': endpoint_topology_context_uuid,

                })

            db_context, _ = result



            str_topology_key = key_to_str([endpoint_topology_context_uuid, endpoint_topology_uuid])

            db_topology : TopologyModel = get_or_create_object(database, TopologyModel, str_topology_key, defaults={

            result : Tuple[TopologyModel, bool] = get_or_create_object(

                database, TopologyModel, str_topology_key, defaults={

                    'context_fk': db_context,

                    'topology_uuid': endpoint_topology_uuid,

                })

            db_topology, _ = result



            str_endpoint_key = key_to_str([str_endpoint_key, str_topology_key], separator=':')

            endpoint_attributes['topology_fk'] = db_topology



        result : Tuple[EndPointModel, bool] = update_or_create_object(

            database, EndPointModel, str_endpoint_key, endpoint_attributes)

        #db_endpoint, updated = result

        db_endpoint, db_endpoint_updated = result

        updated = updated or db_endpoint_updated



    return db_device

    return db_device, updated



def update_device_config_in_local_database(

    database : Database, device_uuid : str, config_name : str, config_rules : List[Tuple[str, Any]]):

    database : Database, device_uuid : str, config_name : str, config_rules : List[Tuple[str, Any]]) -> None:



    str_config_key = key_to_str([device_uuid, config_name], separator=':')

    db_config = get_object(database, ConfigModel, str_config_key)