Commit cf2a36a2 authored by Carlos Manso's avatar Carlos Manso
Browse files

Update scalability

parent facab6d6

src/context/service/Database.py

+11 −6
Original line number Diff line number Diff line 
from typing import Tuple, List



from sqlalchemy import MetaData

from sqlalchemy.orm import Session

from sqlalchemy.orm import Session, joinedload

from context.service.database.Base import Base

import logging

from common.orm.backend.Tools import key_to_str
@@ -27,8 +27,11 @@ class Database(Session): 
    def create_or_update(self, model):

        with self.session() as session:

            att = getattr(model, model.main_pk_name())

            obj = self.get_object(type(model), att)



            filt = {model.main_pk_name(): att}

            found = session.query(type(model)).filter_by(**filt).one_or_none()

            t_model = type(model)

            found = session.query(t_model).filter_by(**filt).one_or_none()

            if found:

                found = True

            else:
@@ -36,6 +39,9 @@ class Database(Session): 


            session.merge(model)

            session.commit()



            obj = self.get_object(t_model, att)



        return model, found



    def create(self, model):
@@ -93,10 +99,10 @@ class Database(Session): 
                    raise NotFoundException(model_class.__name__.replace('Model', ''), main_key)



            return get

    def get_or_create(self, model_class: Base, key_parts: List[str]

                      ) -> Tuple[Base, bool]:



    def get_or_create(self, model_class: Base, key_parts: List[str], filt=None) -> Tuple[Base, bool]:

        str_key = key_to_str(key_parts)

        if not filt:

            filt = {model_class.main_pk_name(): key_parts}

        with self.session() as session:

            get = session.query(model_class).filter_by(**filt).one_or_none()
@@ -105,7 +111,6 @@ class Database(Session): 
            else:

                obj = model_class()

                setattr(obj, model_class.main_pk_name(), str_key)

                LOGGER.info(obj.dump())

                session.add(obj)

                session.commit()

                return obj, True

src/context/service/database/ConfigModel.py

+3 −3
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ class ConfigModel(Base): # pylint: disable=abstract-method 
    config_uuid = Column(UUID(as_uuid=False), primary_key=True)



    # Relationships

    config_rule = relationship("ConfigRuleModel", back_populates="config", lazy="dynamic")

    config_rule = relationship("ConfigRuleModel", back_populates="config", lazy='joined')





    def delete(self) -> None:
@@ -48,7 +48,7 @@ class ConfigModel(Base): # pylint: disable=abstract-method 
        for pk,_ in db_config_rule_pks: ConfigRuleModel(self.database, pk).delete()

        super().delete()



    def dump(self): # -> List[Dict]:

    def dump(self) -> List[Dict]:

        config_rules = []

        for a in self.config_rule:

            asdf = a.dump()
@@ -62,7 +62,7 @@ class ConfigModel(Base): # pylint: disable=abstract-method 
class ConfigRuleModel(Base): # pylint: disable=abstract-method

    __tablename__ = 'ConfigRule'

    config_rule_uuid = Column(UUID(as_uuid=False), primary_key=True)

    config_uuid = Column(UUID(as_uuid=False), ForeignKey("Config.config_uuid"), primary_key=True)

    config_uuid = Column(UUID(as_uuid=False), ForeignKey("Config.config_uuid", ondelete='CASCADE'), primary_key=True)



    action = Column(Enum(ORM_ConfigActionEnum, create_constraint=True, native_enum=True), nullable=False)

    position = Column(INTEGER, nullable=False)

src/context/service/database/ContextModel.py

+2 −1
Original line number Diff line number Diff line
@@ -33,7 +33,8 @@ class ContextModel(Base): 
    def dump_id(self) -> Dict:

        return {'context_uuid': {'uuid': self.context_uuid}}



    def main_pk_name(self):

    @staticmethod

    def main_pk_name():

        return 'context_uuid'



    """

src/context/service/database/DeviceModel.py

+29 −13
Original line number Diff line number Diff line
@@ -49,14 +49,16 @@ class DeviceModel(Base): 
    __tablename__ = 'Device'

    device_uuid = Column(UUID(as_uuid=False), primary_key=True)

    device_type = Column(String)

    device_config_uuid = Column(UUID(as_uuid=False), ForeignKey("Config.config_uuid"))

    device_config_uuid = Column(UUID(as_uuid=False), ForeignKey("Config.config_uuid", ondelete='CASCADE'))

    device_operational_status = Column(Enum(ORM_DeviceOperationalStatusEnum, create_constraint=False,

                                            native_enum=False))



    # Relationships

    device_config = relationship("ConfigModel", lazy="joined")

    driver = relationship("DriverModel", lazy="joined")

    endpoints = relationship("EndPointModel", lazy="joined")

    device_config = relationship("ConfigModel", passive_deletes="all, delete", lazy="joined")

    driver = relationship("DriverModel", passive_deletes=True, back_populates="device")

    endpoints = relationship("EndPointModel", passive_deletes=True, back_populates="device")



    # topology = relationship("TopologyModel", lazy="joined")



    # def delete(self) -> None:

    #     # pylint: disable=import-outside-toplevel
@@ -83,13 +85,25 @@ class DeviceModel(Base): 
        return self.device_config.dump()



    def dump_drivers(self) -> List[int]:

        return self.driver.dump()

        response = []



        for a in self.driver:

            LOGGER.info('DUMPPPPPPPPPPPPPPPPPPPPPIIIIIIIIIIIIIIIIIIIIIIINNNNNNNNNNNNNNNGGGGGGGGGGGGGGGGGGg')

            LOGGER.info('aasdfadsf: {}'.format(a.dump()))

            response.append(a.dump())



        return response



    def dump_endpoints(self) -> List[Dict]:

        return self.endpoints.dump()

        response = []



        for a in self.endpoints:

            response.append(a.dump())



        return response



    def dump(   # pylint: disable=arguments-differ

            self, include_config_rules=True, include_drivers=False, include_endpoints=False

            self, include_config_rules=True, include_drivers=True, include_endpoints=True

        ) -> Dict:

        result = {

            'device_id': self.dump_id(),
@@ -101,24 +115,26 @@ class DeviceModel(Base): 
        if include_endpoints: result['device_endpoints'] = self.dump_endpoints()

        return result



    def main_pk_name(self):

    @staticmethod

    def main_pk_name():

        return 'device_uuid'



class DriverModel(Base): # pylint: disable=abstract-method

    __tablename__ = 'Driver'

    driver_uuid = Column(UUID(as_uuid=False), primary_key=True)

    device_uuid = Column(UUID(as_uuid=False), ForeignKey("Device.device_uuid"), primary_key=True)

    # driver_uuid = Column(UUID(as_uuid=False), primary_key=True)

    device_uuid = Column(UUID(as_uuid=False), ForeignKey("Device.device_uuid", ondelete='CASCADE'), primary_key=True)

    driver = Column(Enum(ORM_DeviceDriverEnum, create_constraint=False, native_enum=False))



    # Relationships

    device = relationship("DeviceModel")

    device = relationship("DeviceModel", back_populates="driver")





    def dump(self) -> Dict:

        return self.driver.value



    def main_pk_name(self):

        return 'driver_uuid'

    @staticmethod

    def main_pk_name():

        return 'device_uuid'



def set_drivers(database : Database, db_device : DeviceModel, grpc_device_drivers):

    db_device_pk = db_device.device_uuid

src/context/service/database/EndPointModel.py

+20 −8
Original line number Diff line number Diff line
@@ -27,14 +27,17 @@ LOGGER = logging.getLogger(__name__) 


class EndPointModel(Base):

    __tablename__ = 'EndPoint'

    endpoint_uuid = Column(UUID(as_uuid=False), primary_key=True, unique=True)

    topology_uuid = Column(UUID(as_uuid=False), ForeignKey("Topology.topology_uuid"), primary_key=True)

    device_uuid = Column(UUID(as_uuid=False), ForeignKey("Device.device_uuid"), primary_key=True)

    device_uuid = Column(UUID(as_uuid=False), ForeignKey("Device.device_uuid", ondelete='CASCADE'), primary_key=True)

    endpoint_uuid = Column(UUID(as_uuid=False), primary_key=True, unique=True)

    endpoint_type = Column(String)



    # Relationships

    kpi_sample_types = relationship("KpiSampleTypeModel", passive_deletes=True, back_populates="EndPoint")

    device = relationship("DeviceModel", back_populates="endpoints")



    def main_pk_name(self):

    @staticmethod

    def main_pk_name():

        return 'endpoint_uuid'



    def delete(self) -> None:
@@ -44,32 +47,41 @@ class EndPointModel(Base): 


    def dump_id(self) -> Dict:

        result = {

            'device_uuid': self.device_uuid,

            'device_id': self.device.dump_id(),

            'endpoint_uuid': {'uuid': self.endpoint_uuid},

        }

        return result



    def dump_kpi_sample_types(self) -> List[int]:

        db_kpi_sample_type_pks = self.references(KpiSampleTypeModel)

        return [KpiSampleTypeModel(self.database, pk).dump() for pk,_ in db_kpi_sample_type_pks]

        # db_kpi_sample_type_pks = self.references(KpiSampleTypeModel)

        # return [KpiSampleTypeModel(self.database, pk).dump() for pk,_ in db_kpi_sample_type_pks]

        response = []

        for a in self.kpi_sample_types:

            response.append(a.dump())

        return response



    def dump(   # pylint: disable=arguments-differ

            self, include_kpi_sample_types=True

        ) -> Dict:

        result = {

            'endpoint_uuid': self.dump_id(),

            'endpoint_id': self.dump_id(),

            'endpoint_type': self.endpoint_type,

        }

        if include_kpi_sample_types: result['kpi_sample_types'] = self.dump_kpi_sample_types()

        return result





class KpiSampleTypeModel(Base): # pylint: disable=abstract-method

    __tablename__ = 'KpiSampleType'

    kpi_uuid = Column(UUID(as_uuid=False), primary_key=True)

    endpoint_uuid = Column(UUID(as_uuid=False), ForeignKey("EndPoint.endpoint_uuid"))

    endpoint_uuid = Column(UUID(as_uuid=False), ForeignKey("EndPoint.endpoint_uuid",  ondelete='CASCADE'))

    kpi_sample_type = Column(Enum(ORM_KpiSampleTypeEnum, create_constraint=False,

                                                  native_enum=False))

    # __table_args__ = (ForeignKeyConstraint([endpoint_uuid], [EndPointModel.endpoint_uuid]), {})



    # Relationships

    EndPoint = relationship("EndPointModel", passive_deletes=True, back_populates="kpi_sample_types")



    def dump(self) -> Dict:

        return self.kpi_sample_type.value