def assign(
            self, *, reservation: ABCAuthorityReservation,
            delegation_name: str, graph_node: BaseSliver,
            existing_reservations: List[ABCReservationMixin]) -> ResourceSet:
        """
        Assign a reservation
        :param reservation: reservation
        :param delegation_name: Name of delegation serving the request
        :param graph_node: ARM Graph Node serving the reservation
        :param existing_reservations: Existing Reservations served by the same ARM node
        :return: ResourceSet with updated sliver annotated with properties
        :raises: AuthorityException in case the request cannot be satisfied
        """
        reservation.set_send_with_deficit(value=True)

        requested = reservation.get_requested_resources().get_sliver()
        self.__dump_sliver(sliver=requested)
        if not isinstance(requested, NetworkServiceSliver):
            raise AuthorityException(
                f"Invalid resource type {requested.get_type()}")

        current = reservation.get_resources()

        resource_type = ResourceType(resource_type=str(requested.get_type()))

        gained = None
        lost = None
        if current is None:
            self.logger.debug("check if sliver can be provisioned")
            # FIXME Add validation to check ticketed sliver against ARM
            # Refer Network Node Control for reference

            self.logger.debug(
                f"Slice properties: {reservation.get_slice().get_config_properties()}"
            )
            unit = Unit(
                rid=reservation.get_reservation_id(),
                slice_id=reservation.get_slice_id(),
                actor_id=self.authority.get_guid(),
                sliver=requested,
                rtype=resource_type,
                properties=reservation.get_slice().get_config_properties())
            gained = UnitSet(plugin=self.authority.get_plugin(),
                             units={unit.reservation_id: unit})
        else:
            # FIXME: handle modify
            self.logger.info(
                f"Extend Lease for now, no modify supported res# {reservation}"
            )
            return current

        result = ResourceSet(gained=gained, lost=lost, rtype=resource_type)
        result.set_sliver(sliver=requested)
        return result
    def assign(
            self, *, reservation: ABCAuthorityReservation,
            delegation_name: str, graph_node: BaseSliver,
            existing_reservations: List[ABCReservationMixin]) -> ResourceSet:
        """
        Assign a reservation
        :param reservation: reservation
        :param delegation_name: Name of delegation serving the request
        :param graph_node: ARM Graph Node serving the reservation
        :param existing_reservations: Existing Reservations served by the same ARM node
        :return: ResourceSet with updated sliver annotated with properties
        :raises: AuthorityException in case the request cannot be satisfied
        """

        if graph_node.capacity_delegations is None or reservation is None:
            raise AuthorityException(Constants.INVALID_ARGUMENT)

        delegated_capacities = graph_node.get_capacity_delegations()
        available_delegated_capacity = FimHelper.get_delegation(
            delegated_capacities=delegated_capacities,
            delegation_name=delegation_name)
        if available_delegated_capacity is None:
            raise AuthorityException(
                f"Allocated node {graph_node.node_id} does not have delegation: {delegation_name}"
            )

        reservation.set_send_with_deficit(value=True)

        requested = reservation.get_requested_resources().get_sliver()
        if not isinstance(requested, NodeSliver):
            raise AuthorityException(
                f"Invalid resource type {requested.get_type()}")

        current = reservation.get_resources()

        resource_type = ResourceType(resource_type=str(requested.get_type()))

        gained = None
        lost = None
        if current is None:
            # Check if Capacities can be satisfied by Delegated Capacities
            self.__check_capacities(
                rid=reservation.get_reservation_id(),
                requested_capacities=requested.get_capacity_allocations(),
                available_capacities=available_delegated_capacity,
                existing_reservations=existing_reservations)

            # Check if Capacities can be satisfied by Capacities
            self.__check_capacities(
                rid=reservation.get_reservation_id(),
                requested_capacities=requested.get_capacity_allocations(),
                available_capacities=graph_node.get_capacities(),
                existing_reservations=existing_reservations)

            # Check components
            # Check if Components can be allocated
            if requested.attached_components_info is not None:
                self.__check_components(
                    rid=reservation.get_reservation_id(),
                    requested_components=requested.attached_components_info,
                    graph_node=graph_node,
                    existing_reservations=existing_reservations)

            self.logger.debug(
                f"Slice properties: {reservation.get_slice().get_config_properties()}"
            )
            unit = Unit(
                rid=reservation.get_reservation_id(),
                slice_id=reservation.get_slice_id(),
                actor_id=self.authority.get_guid(),
                sliver=requested,
                rtype=resource_type,
                properties=reservation.get_slice().get_config_properties())
            gained = UnitSet(plugin=self.authority.get_plugin(),
                             units={unit.reservation_id: unit})
        else:
            # FIX ME: handle modify
            self.logger.info(
                f"Extend Lease for now, no modify supported res# {reservation}"
            )
            return current

        result = ResourceSet(gained=gained, lost=lost, rtype=resource_type)
        result.set_sliver(sliver=requested)
        return result