Commit 0040dd5f authored by Lluis Gifre Renom's avatar Lluis Gifre Renom
Browse files

Merge branch 'release/2.0.1' of https://labs.etsi.org/rep/tfs/controller into feat/slice-grouping

parents 5aff458e 5c95b835

src/common/tools/grpc/Constraints.py

+56 −3
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 




import json

from typing import Any, Dict, Optional, Tuple

from typing import Any, Dict, List, Optional, Tuple

from common.proto.context_pb2 import Constraint, EndPointId

from common.tools.grpc.Tools import grpc_message_to_json_string
@@ -137,7 +137,31 @@ def update_constraint_endpoint_priority(constraints, endpoint_id : EndPointId, p 
    constraint.endpoint_priority.priority = priority

    return constraint



def update_constraint_sla_availability(constraints, num_disjoint_paths : int, all_active : bool) -> Constraint:

def update_constraint_sla_capacity(constraints, capacity_gbps : float) -> Constraint:

    for constraint in constraints:

        if constraint.WhichOneof('constraint') != 'sla_capacity': continue

        break   # found, end loop

    else:

        # not found, add it

        constraint = constraints.add()      # pylint: disable=no-member



    constraint.sla_capacity.capacity_gbps = capacity_gbps

    return constraint



def update_constraint_sla_latency(constraints, e2e_latency_ms : float) -> Constraint:

    for constraint in constraints:

        if constraint.WhichOneof('constraint') != 'sla_latency': continue

        break   # found, end loop

    else:

        # not found, add it

        constraint = constraints.add()      # pylint: disable=no-member



    constraint.sla_latency.e2e_latency_ms = e2e_latency_ms

    return constraint



def update_constraint_sla_availability(

    constraints, num_disjoint_paths : int, all_active : bool, availability : float

) -> Constraint:

    for constraint in constraints:

        if constraint.WhichOneof('constraint') != 'sla_availability': continue

        break   # found, end loop
@@ -147,8 +171,21 @@ def update_constraint_sla_availability(constraints, num_disjoint_paths : int, al 


    constraint.sla_availability.num_disjoint_paths = num_disjoint_paths

    constraint.sla_availability.all_active = all_active

    constraint.sla_availability.availability = availability

    return constraint



def update_constraint_sla_isolation(constraints, isolation_levels : List[int]) -> Constraint:

    for constraint in constraints:

        if constraint.WhichOneof('constraint') != 'sla_isolation': continue

        break   # found, end loop

    else:

        # not found, add it

        constraint = constraints.add()      # pylint: disable=no-member



    for isolation_level in isolation_levels:

        if isolation_level in constraint.sla_isolation.isolation_level: continue

        constraint.sla_isolation.isolation_level.append(isolation_level)

    return constraint



def copy_constraints(source_constraints, target_constraints):

    for source_constraint in source_constraints:
@@ -189,11 +226,27 @@ def copy_constraints(source_constraints, target_constraints): 
            priority = source_constraint.endpoint_priority.priority

            update_constraint_endpoint_priority(target_constraints, endpoint_id, priority)



        elif constraint_kind == 'sla_capacity':

            sla_capacity = source_constraint.sla_capacity

            capacity_gbps = sla_capacity.capacity_gbps

            update_constraint_sla_capacity(target_constraints, capacity_gbps)



        elif constraint_kind == 'sla_latency':

            sla_latency = source_constraint.sla_latency

            e2e_latency_ms = sla_latency.e2e_latency_ms

            update_constraint_sla_latency(target_constraints, e2e_latency_ms)



        elif constraint_kind == 'sla_availability':

            sla_availability = source_constraint.sla_availability

            num_disjoint_paths = sla_availability.num_disjoint_paths

            all_active = sla_availability.all_active

            update_constraint_sla_availability(target_constraints, num_disjoint_paths, all_active)

            availability = sla_availability.availability

            update_constraint_sla_availability(target_constraints, num_disjoint_paths, all_active, availability)



        elif constraint_kind == 'sla_isolation':

            sla_isolation = source_constraint.sla_isolation

            isolation_levels = sla_isolation.isolation_level

            update_constraint_sla_isolation(target_constraints, isolation_levels)



        else:

            raise NotImplementedError('Constraint({:s})'.format(grpc_message_to_json_string(source_constraint)))

src/common/tools/object_factory/Constraint.py

+14 −3
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 
# limitations under the License.



import json

from typing import Any, Dict, Union

from typing import Any, Dict, List, Union



def json_constraint_custom(constraint_type : str, constraint_value : Union[str, Dict[str, Any]]) -> Dict:

    if not isinstance(constraint_value, str): constraint_value = json.dumps(constraint_value, sort_keys=True)
@@ -29,5 +29,16 @@ def json_constraint_endpoint_location_gps(endpoint_id : Dict, latitude : float, 
def json_constraint_endpoint_priority(endpoint_id : Dict, priority : int) -> Dict:

    return {'endpoint_priority': {'endpoint_id': endpoint_id, 'priority': priority}}



def json_constraint_sla_availability(num_disjoint_paths : int, all_active : bool) -> Dict:

    return {'sla_availability': {'num_disjoint_paths': num_disjoint_paths, 'all_active': all_active}}
 
def json_constraint_sla_availability(num_disjoint_paths : int, all_active : bool, availability : float) -> Dict:

    return {'sla_availability': {

        'num_disjoint_paths': num_disjoint_paths, 'all_active': all_active, 'availability': availability

    }}



def json_constraint_sla_capacity(capacity_gbps : float) -> Dict:

    return {'sla_capacity': {'capacity_gbps': capacity_gbps}}



def json_constraint_sla_isolation(isolation_levels : List[int]) -> Dict:

    return {'sla_isolation': {'isolation_level': isolation_levels}}



def json_constraint_sla_latency(e2e_latency_ms : float) -> Dict:

    return {'sla_latency': {'e2e_latency_ms': e2e_latency_ms}}

src/context/service/database/Service.py

+5 −2
Original line number Diff line number Diff line
@@ -77,8 +77,11 @@ def service_set(db_engine : Engine, request : Service) -> Tuple[Dict, bool]: 
    service_endpoints_data : List[Dict] = list()

    for i,endpoint_id in enumerate(request.service_endpoint_ids):

        endpoint_context_uuid = endpoint_id.topology_id.context_id.context_uuid.uuid

        if len(endpoint_context_uuid) == 0: endpoint_context_uuid = context_uuid

        if endpoint_context_uuid not in {raw_context_uuid, context_uuid}:

        if len(endpoint_context_uuid) == 0:

            endpoint_context_uuid = context_get_uuid(request.service_id.context_id, allow_random=False)

        else:

            endpoint_context_uuid = context_get_uuid(endpoint_id.topology_id.context_id, allow_random=False)

        if endpoint_context_uuid != context_uuid:

            raise InvalidArgumentException(

                'request.service_endpoint_ids[{:d}].topology_id.context_id.context_uuid.uuid'.format(i),

                endpoint_context_uuid,

src/context/service/database/Slice.py

+7 −4
Original line number Diff line number Diff line
@@ -77,8 +77,11 @@ def slice_set(db_engine : Engine, request : Slice) -> Tuple[Dict, bool]: 
    slice_endpoints_data : List[Dict] = list()

    for i,endpoint_id in enumerate(request.slice_endpoint_ids):

        endpoint_context_uuid = endpoint_id.topology_id.context_id.context_uuid.uuid

        if len(endpoint_context_uuid) == 0: endpoint_context_uuid = context_uuid

        if endpoint_context_uuid not in {raw_context_uuid, context_uuid}:

        if len(endpoint_context_uuid) == 0:

            endpoint_context_uuid = context_get_uuid(request.slice_id.context_id, allow_random=False)

        else:

            endpoint_context_uuid = context_get_uuid(endpoint_id.topology_id.context_id, allow_random=False)

        if endpoint_context_uuid != context_uuid:

            raise InvalidArgumentException(

                'request.slice_endpoint_ids[{:d}].topology_id.context_id.context_uuid.uuid'.format(i),

                endpoint_context_uuid,
@@ -210,13 +213,13 @@ def slice_unset(db_engine : Engine, request : Slice) -> Tuple[Dict, bool]: 
                )).delete()

        if len(slice_subslice_uuids) > 0:

            num_deletes += session.query(SliceSubSliceModel)\

                .filter_by(and_(

                .filter(and_(

                    SliceSubSliceModel.slice_uuid == slice_uuid,

                    SliceSubSliceModel.subslice_uuid.in_(slice_subslice_uuids)

                )).delete()

        if len(slice_endpoint_uuids) > 0:

            num_deletes += session.query(SliceEndPointModel)\

                .filter_by(and_(

                .filter(and_(

                    SliceEndPointModel.slice_uuid == slice_uuid,

                    SliceEndPointModel.endpoint_uuid.in_(slice_endpoint_uuids)

                )).delete()

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

+4 −0
Original line number Diff line number Diff line
@@ -100,3 +100,7 @@ class SliceSubSliceModel(_Base): 


    slice_uuid    = Column(ForeignKey('slice.slice_uuid', ondelete='CASCADE' ), primary_key=True)

    subslice_uuid = Column(ForeignKey('slice.slice_uuid', ondelete='RESTRICT'), primary_key=True)



    slice    = relationship(

        'SliceModel', foreign_keys='SliceSubSliceModel.slice_uuid', back_populates='slice_subslices', lazy='joined')

    subslice = relationship('SliceModel', foreign_keys='SliceSubSliceModel.subslice_uuid', lazy='joined')