Commit 8b438fb5 authored by Pablo Armingol's avatar Pablo Armingol
Browse files

Merge branch 'develop' of https://labs.etsi.org/rep/tfs/controller into... 

Merge branch 'develop' of https://labs.etsi.org/rep/tfs/controller into feat/382-tid-implement-cache-in-docker
parents 137086fc 7b9f5eb4

src/common/tools/object_factory/PolicyRule.py

+11 −7
Original line number Diff line number Diff line
@@ -22,19 +22,23 @@ def json_policyrule_id(policyrule_uuid : str) -> Dict: 
    return {'uuid': {'uuid': policyrule_uuid}}



def json_policyrule(

    policyrule_uuid : str, policy_priority : int = 1, policy_kpi_id : str = '',

    policy_state : PolicyRuleStateEnum = PolicyRuleStateEnum.POLICY_UNDEFINED, policy_state_message : str = '',

    action_list : List[Dict] = [], service_id : Optional[Dict] = None, device_id_list : List[Dict] = []

    policyrule_uuid : str,

    state : PolicyRuleStateEnum = PolicyRuleStateEnum.POLICY_UNDEFINED, state_message : str = '',

    priority : int = 1, action_list : List[Dict] = [], list_kpi_id : List[str] = list(),

    service_id : Optional[Dict] = None, device_id_list : List[Dict] = []

) -> Dict:

    basic = {

        'policyRuleId': json_policyrule_id(policyrule_uuid),

        'policyRuleState': {

            'policyRuleState': policy_state,

            'policyRuleStateMessage': policy_state_message,

            'policyRuleState': state,

            'policyRuleStateMessage': state_message,

        },

        'policyRulePriority': policy_priority,

        'policyRuleKpiList': [{'policyRuleKpiUuid': {'uuid': policy_kpi_id}}] if policy_kpi_id else [],

        'policyRulePriority': priority,

        'actionList': action_list,

        'policyRuleKpiList': [

            {'policyRuleKpiUuid': {'uuid': kpi_id}}

            for kpi_id in list_kpi_id

        ],

    }



    result = {}

src/context/service/database/PolicyRule.py

+19 −16
Original line number Diff line number Diff line
@@ -82,6 +82,10 @@ def policyrule_set(db_engine : Engine, messagebroker : MessageBroker, request : 
        'actionList': json_policyrule_basic.get('actionList', []),

    }, sort_keys=True)



    policyrule_list_kpi_id = [

        kpi_id.policyRuleKpiUuid.uuid for kpi_id in policyrule_basic.policyRuleKpiList

    ]



    now = datetime.datetime.now(datetime.timezone.utc)



    policyrule_data = [{
@@ -90,8 +94,7 @@ def policyrule_set(db_engine : Engine, messagebroker : MessageBroker, request : 
        'policyrule_state'       : policyrule_state,

        'policyrule_state_msg'   : policyrule_state_msg,

        'policyrule_priority'    : policyrule_basic.policyRulePriority,

        'policyrule_kpi_id'   : policyrule_basic.policyRuleKpiList[0].policyRuleKpiUuid.uuid

                                if len(policyrule_basic.policyRuleKpiList) > 0 else '',

        'policyrule_list_kpi_id' : policyrule_list_kpi_id,

        'policyrule_eca_data'    : policyrule_eca_data,

        'created_at'             : now,

        'updated_at'             : now,
@@ -121,7 +124,7 @@ def policyrule_set(db_engine : Engine, messagebroker : MessageBroker, request : 
                policyrule_state       = stmt.excluded.policyrule_state,

                policyrule_state_msg   = stmt.excluded.policyrule_state_msg,

                policyrule_priority    = stmt.excluded.policyrule_priority,

                policyrule_kpi_id    = stmt.excluded.policyrule_kpi_id,

                policyrule_list_kpi_id = stmt.excluded.policyrule_list_kpi_id,

                policyrule_eca_data    = stmt.excluded.policyrule_eca_data,

                updated_at             = stmt.excluded.updated_at,

            )

src/context/service/database/models/PolicyRuleModel.py

+15 −6
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 


import enum, json

from sqlalchemy import CheckConstraint, Column, DateTime, Enum, ForeignKey, Integer, String

from sqlalchemy.dialects.postgresql import UUID

from sqlalchemy.dialects.postgresql import ARRAY, UUID

from sqlalchemy.orm import relationship

from typing import Dict

from .enums.PolicyRuleState import ORM_PolicyRuleStateEnum
@@ -33,7 +33,7 @@ class PolicyRuleModel(_Base): 
    policyrule_state        = Column(Enum(ORM_PolicyRuleStateEnum), nullable=False)

    policyrule_state_msg    = Column(String, nullable=False)

    policyrule_priority     = Column(Integer, nullable=False)

    policyrule_kpi_id       = Column(String, nullable=False)

    policyrule_list_kpi_id  = Column(ARRAY(String, dimensions=1), nullable=False)

    policyrule_service_uuid = Column(ForeignKey('service.service_uuid', ondelete='RESTRICT'), nullable=True, index=True)

    policyrule_eca_data     = Column(String, nullable=False)

    created_at              = Column(DateTime, nullable=False)
@@ -50,8 +50,10 @@ class PolicyRuleModel(_Base): 
        return {'uuid': {'uuid': self.policyrule_uuid}}



    def dump(self) -> Dict:

        # Load JSON-encoded Event-Condition-Action (ECA) model data and populate with policy basic details

        # Load JSON-encoded Event-Condition-Action (ECA) model data

        policyrule_basic = json.loads(self.policyrule_eca_data)



        # Populate policy rule basic details

        policyrule_basic.update({

            'policyRuleId': self.dump_id(),

            'policyRuleState': {
@@ -59,12 +61,19 @@ class PolicyRuleModel(_Base): 
                'policyRuleStateMessage': self.policyrule_state_msg,

            },

            'policyRulePriority': self.policyrule_priority,

            'policyRuleKpiList': [{'policyRuleKpiUuid': {'uuid': self.policyrule_kpi_id}}]

                                 if self.policyrule_kpi_id else [],

            'policyRuleKpiList': [

                {'policyRuleKpiUuid': {'uuid': kpi_id}}

                for kpi_id in self.policyrule_list_kpi_id

            ]

        })



        # Compose final Policy Rule

        result = {

            'policyRuleBasic': policyrule_basic,

            'deviceList': [{'device_uuid': {'uuid': pr_d.device_uuid}} for pr_d in self.policyrule_devices],

            'deviceList': [

                {'device_uuid': {'uuid': pr_d.device_uuid}}

                for pr_d in self.policyrule_devices

            ],

        }

        if self.policyrule_kind == PolicyRuleKindEnum.SERVICE:

            result['serviceId'] = self.policyrule_service.dump_id()

src/context/tests/Objects.py

+1 −1
Original line number Diff line number Diff line
@@ -186,4 +186,4 @@ CONNECTION_R1_R3_NAME, CONNECTION_R1_R3_ID, CONNECTION_R1_R3 = compose_connectio 
# ----- PolicyRule -------------------------------------------------------------------------------------------------------

POLICYRULE_NAME = 'my-device-policy'

POLICYRULE_ID   = json_policyrule_id(POLICYRULE_NAME)

POLICYRULE      = json_policyrule(POLICYRULE_NAME, policy_priority=1, policy_kpi_id='my-kpi-id')
 
POLICYRULE      = json_policyrule(POLICYRULE_NAME, priority=1, list_kpi_id=['my-kpi-id-1'])

src/context/tests/test_policy.py

+21 −11
Original line number Diff line number Diff line
@@ -45,9 +45,11 @@ def test_policy(context_client : ContextClient): 


    # ----- Get when the object exists ---------------------------------------------------------------------------------

    response = context_client.GetPolicyRule(PolicyRuleId(**POLICYRULE_ID))

    assert response.device.policyRuleBasic.policyRuleId.uuid.uuid == policyrule_uuid

    assert response.device.policyRuleBasic.policyRulePriority == 1

    assert response.device.policyRuleBasic.policyRuleKpiList[0].policyRuleKpiUuid.uuid == 'my-kpi-id'

    policy_basic = response.device.policyRuleBasic

    assert policy_basic.policyRuleId.uuid.uuid == policyrule_uuid

    assert policy_basic.policyRulePriority == 1

    assert len(policy_basic.policyRuleKpiList) == 1

    assert policy_basic.policyRuleKpiList[0].policyRuleKpiUuid.uuid == 'my-kpi-id-1'



    # ----- List when the object exists --------------------------------------------------------------------------------

    response = context_client.ListPolicyRuleIds(Empty())
@@ -56,16 +58,21 @@ def test_policy(context_client : ContextClient): 


    response = context_client.ListPolicyRules(Empty())

    assert len(response.policyRules) == 1

    assert response.policyRules[0].device.policyRuleBasic.policyRuleId.uuid.uuid == policyrule_uuid

    assert response.policyRules[0].device.policyRuleBasic.policyRulePriority == 1

    assert response.policyRules[0].device.policyRuleBasic.policyRuleKpiList[0].policyRuleKpiUuid.uuid == 'my-kpi-id'

    policy_basic = response.policyRules[0].device.policyRuleBasic

    assert policy_basic.policyRuleId.uuid.uuid == policyrule_uuid

    assert policy_basic.policyRulePriority == 1

    assert len(policy_basic.policyRuleKpiList) == 1

    assert policy_basic.policyRuleKpiList[0].policyRuleKpiUuid.uuid == 'my-kpi-id-1'



    # ----- Update the object ------------------------------------------------------------------------------------------

    new_policy_priority = 100

    new_policy_kpi_id = 'new-kpi-id'

    new_policy_list_kpi_id = ['my-kpi-id-1', 'my-kpi-id-2']

    POLICYRULE_UPDATED = copy.deepcopy(POLICYRULE)

    POLICYRULE_UPDATED['device']['policyRuleBasic']['policyRulePriority'] = new_policy_priority

    POLICYRULE_UPDATED['device']['policyRuleBasic']['policyRuleKpiList'] = [{'policyRuleKpiUuid': {'uuid': new_policy_kpi_id}}]

    POLICYRULE_UPDATED['device']['policyRuleBasic']['policyRuleKpiList'] = [

        {'policyRuleKpiUuid': {'uuid': kpi_id}}

        for kpi_id in new_policy_list_kpi_id

    ]

    response = context_client.SetPolicyRule(PolicyRule(**POLICYRULE_UPDATED))

    assert response.uuid.uuid == policyrule_uuid
@@ -80,9 +87,12 @@ def test_policy(context_client : ContextClient): 


    response = context_client.ListPolicyRules(Empty())

    assert len(response.policyRules) == 1

    assert response.policyRules[0].device.policyRuleBasic.policyRuleId.uuid.uuid == policyrule_uuid

    assert response.policyRules[0].device.policyRuleBasic.policyRulePriority == new_policy_priority

    assert response.policyRules[0].device.policyRuleBasic.policyRuleKpiList[0].policyRuleKpiUuid.uuid == new_policy_kpi_id

    policy_basic = response.policyRules[0].device.policyRuleBasic

    assert policy_basic.policyRuleId.uuid.uuid == policyrule_uuid

    assert policy_basic.policyRulePriority == new_policy_priority

    assert len(policy_basic.policyRuleKpiList) == 2

    for i,kpi_id in enumerate(new_policy_list_kpi_id):

        assert policy_basic.policyRuleKpiList[i].policyRuleKpiUuid.uuid == kpi_id



    # ----- Remove the object ------------------------------------------------------------------------------------------

    context_client.RemovePolicyRule(PolicyRuleId(**POLICYRULE_ID))