Context component:

from .database.Link import link_delete, link_get, link_list_ids, link_list_objs, link_set

from .database.PolicyRule import (

    policyrule_delete, policyrule_get, policyrule_list_ids, policyrule_list_objs, policyrule_set)

from .database.Service import service_delete, service_get, service_list_ids, service_list_objs, service_select, service_set

from .database.Service import service_delete, service_get, service_list_ids, service_list_objs, service_select, service_set, service_unset

from .database.Slice import slice_delete, slice_get, slice_list_ids, slice_list_objs, slice_select, slice_set, slice_unset

from .database.Topology import (

    topology_delete, topology_get, topology_get_details, topology_list_ids, topology_list_objs, topology_set)

        notify_event(self.messagebroker, TOPIC_SERVICE, event_type, {'service_id': service_id})

        return ServiceId(**service_id)

    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def UnsetService(self, request : Service, context : grpc.ServicerContext) -> ServiceId:

        service_id,updated = service_unset(self.db_engine, request)

        if updated:

            event_type = EventTypeEnum.EVENTTYPE_UPDATE

            notify_event(self.messagebroker, TOPIC_SERVICE, event_type, {'service_id': service_id})

        return ServiceId(**service_id)

    @safe_and_metered_rpc_method(METRICS_POOL, LOGGER)

    def RemoveService(self, request : ServiceId, context : grpc.ServicerContext) -> Empty:

        service_id,deleted = service_delete(self.db_engine, request)

# limitations under the License.

import datetime, logging

from sqlalchemy import and_

from sqlalchemy.dialects.postgresql import insert

from sqlalchemy.engine import Engine

from sqlalchemy.orm import Session, selectinload, sessionmaker

from sqlalchemy_cockroachdb import run_transaction

from typing import Dict, List, Optional, Tuple

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

from common.proto.context_pb2 import ContextId, Service, ServiceFilter, ServiceId

from common.method_wrappers.ServiceExceptions import InvalidArgumentException, NotFoundException

from common.tools.object_factory.Context import json_context_id

    updated = run_transaction(sessionmaker(bind=db_engine), callback)

    return json_service_id(service_uuid, json_context_id(context_uuid)),updated

def service_unset(db_engine : Engine, request : Service) -> Tuple[Dict, bool]:

    raw_context_uuid = request.service_id.context_id.context_uuid.uuid

    raw_service_uuid = request.service_id.service_uuid.uuid

    raw_service_name = request.name

    service_name = raw_service_uuid if len(raw_service_name) == 0 else raw_service_name

    context_uuid,service_uuid = service_get_uuid(request.service_id, service_name=service_name, allow_random=False)

    service_endpoint_uuids : Set[str] = set()

    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}:

            raise InvalidArgumentException(

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

                endpoint_context_uuid,

                ['should be == request.service_id.context_id.context_uuid.uuid({:s})'.format(raw_context_uuid)])

        service_endpoint_uuids.add(endpoint_get_uuid(endpoint_id, allow_random=False)[2])

    now = datetime.datetime.utcnow()

    constraints = compose_constraints_data(request.service_constraints, now, service_uuid=service_uuid)

    config_rules = compose_config_rules_data(request.service_config.config_rules, now, service_uuid=service_uuid)

    def callback(session : Session) -> bool:

        num_deletes = 0

        if len(service_endpoint_uuids) > 0:

            num_deletes += session.query(ServiceEndPointModel)\

                .filter(and_(

                    ServiceEndPointModel.service_uuid == service_uuid,

                    ServiceEndPointModel.endpoint_uuid.in_(service_endpoint_uuids)

                )).delete()

        changed_constraints = upsert_constraints(session, constraints, is_delete=True, service_uuid=service_uuid)

        changed_config_rules = upsert_config_rules(session, config_rules, is_delete=True, service_uuid=service_uuid)

        return num_deletes > 0 or changed_constraints or changed_config_rules

    updated = run_transaction(sessionmaker(bind=db_engine), callback)

    return json_service_id(service_uuid, json_context_id(context_uuid)),updated

def service_delete(db_engine : Engine, request : ServiceId) -> Tuple[Dict, bool]:

    context_uuid,service_uuid = service_get_uuid(request, allow_random=False)

    def callback(session : Session) -> bool: