def recover_proxy(*, proxy_reload_from_db: ABCProxy,
register: bool) -> ABCProxy:
"""
Creates a proxy list from a properties list representing the
serialization of the proxy. Optionally, the resulting object may be
registered with the ActorRegistry so that it becomes visible
to the rest of the system.
@param proxy_reload_from_db proxy_reload_from_db
@param register If true, the resulting proxy is registered with the
container's ActorRegistry
@return Proxy
@throws Exception in case of error
"""
from fabric_cf.actor.core.container.globals import GlobalsSingleton
proxy_reload_from_db.set_logger(
logger=GlobalsSingleton.get().get_logger())
if register:
if proxy_reload_from_db.callback:
ActorRegistrySingleton.get().register_callback(
callback=proxy_reload_from_db)
else:
ActorRegistrySingleton.get().register_proxy(
proxy=proxy_reload_from_db)
return proxy_reload_from_db
def get_proxy(*, proxy_reload_from_db) -> ABCProxy:
"""
Obtains a proxy object from the specified properties list. If a suitable
proxy object has already been created and registered with the
ActorRegistry, the already existing object is returned and
no new object is created. Otherwise, the method creates the proxy object
and registers it with the ActorRegistry
@param proxy_reload_from_db proxy_reload_from_db
@return IProxy
@throws Exception in case of error
"""
proxy_type = proxy_reload_from_db.get_type()
name = proxy_reload_from_db.get_name()
is_callback = proxy_reload_from_db.callback
proxy = None
if is_callback:
proxy = ActorRegistrySingleton.get().get_callback(
protocol=proxy_type, actor_name=name)
else:
proxy = ActorRegistrySingleton.get().get_proxy(protocol=proxy_type,
actor_name=name)
if proxy is None:
proxy = Proxy.recover_proxy(
proxy_reload_from_db=proxy_reload_from_db, register=True)
else:
proxy = Proxy.recover_proxy(
proxy_reload_from_db=proxy_reload_from_db, register=False)
return proxy
def get_proxy(protocol: str, identity: ABCActorIdentity, location: ActorLocation, proxy_type: str = None):
proxy = ActorRegistrySingleton.get().get_proxy(protocol=protocol, actor_name=identity.get_name())
if proxy is None:
proxy = ProxyFactorySingleton.get().new_proxy(protocol=protocol, identity=identity, location=location,
proxy_type=proxy_type)
ActorRegistrySingleton.get().register_proxy(proxy=proxy)
return proxy
def test_d_extend_lease(self):
site = self.get_authority()
policy = site.get_policy()
controller = self.get_controller()
proxy = ControllerCallbackHelper(name=controller.get_name(), guid=controller.get_guid())
auth_proxy = ControllerCallbackHelper(name=site.get_name(), guid=site.get_guid())
ActorRegistrySingleton.get().register_callback(callback=proxy)
ActorRegistrySingleton.get().register_callback(callback=auth_proxy)
delegation = self.get_delegation(site)
policy.donate_delegation(delegation=delegation)
request = self.get_redeem_request(site, delegation)
extend = self.get_extend_lease_request(site, delegation, request)
class UpdateLeaseHandler(IUpdateLeaseHandler):
def __init__(self, parent, request):
self.waiting_for_extend_lease = False
self.waiting_for_lease = True
self.waiting_for_close = False
self.parent = parent
self.request = request
def handle_update_lease(self, reservation: ABCReservationMixin, update_data: UpdateData, caller: AuthToken):
if self.waiting_for_lease:
self.parent.check_incoming_lease(self.request, reservation)
self.waiting_for_lease = False
self.waiting_for_close = True
elif self.waiting_for_close:
self.parent.assertTrue(site.get_current_cycle() >= AuthorityCalendarPolicyTest.TicketEndCycle)
self.parent.check_incoming_close_lease(self.request, reservation)
self.waiting_for_close = False
else:
raise AuthorityException(Constants.INVALID_STATE)
def check_termination(self):
self.parent.assertFalse(self.waiting_for_lease)
self.parent.assertFalse(self.waiting_for_close)
handler = UpdateLeaseHandler(self, request)
proxy.set_update_lease_handler(handler=handler)
cycle = 1
site.external_tick(cycle=cycle)
cycle += 1
print("Redeeming request")
# Force delegation to be in Delegated State
delegation.state = DelegationState.Delegated
site.redeem(reservation=request, callback=proxy, caller=proxy.get_identity())
for cycle in range(cycle, self.DonateEndCycle):
if cycle == self.TicketEndCycle - 50:
print("Extending Lease")
site.extend_lease(reservation=extend, caller=proxy.get_identity())
site.external_tick(cycle=cycle)
while site.get_current_cycle() != cycle:
time.sleep(0.001)
handler.check_termination()
def register_new_actor(self, *, actor: ABCActorMixin):
db = self.get_container_database()
db.remove_actor(actor_name=actor.get_name())
db.add_actor(actor=actor)
ActorRegistrySingleton.get().unregister(actor=actor)
ActorRegistrySingleton.get().register_actor(actor=actor)
actor.actor_added()
actor.start()
def unregister_actor(self, *, actor: ABCActorMixin):
"""
Unregisters the actor from the container.
@param actor actor
@raises Exception in case of error
"""
self.management_object_manager.unload_actor_manager_objects(actor_name=actor.get_name())
ActorRegistrySingleton.get().unregister(actor=actor)
def test_b_allocate_ticket(self):
"""
Requests a ticket for all resources. Checks if the ticket is
allocated for what was asked. Checks the term. Checks whether the
reservation is closed when it expires.
"""
self.broker = self.get_broker()
controller = self.get_controller()
clock = self.broker.get_actor_clock()
proxy = ClientCallbackHelper(name=controller.get_name(),
guid=controller.get_guid())
broker_callback = ClientCallbackHelper(name=self.broker.get_name(),
guid=self.broker.get_guid())
ActorRegistrySingleton.get().register_callback(callback=proxy)
ActorRegistrySingleton.get().register_callback(
callback=broker_callback)
last_called = proxy.get_called()
inv_slice = SliceFactory.create(slice_id=ID(), name="inventory-slice")
inv_slice.set_inventory(value=True)
source = self.get_source_delegation(self.broker, inv_slice)
self.broker.register_slice(slice_object=inv_slice)
self.broker.register_delegation(delegation=source)
self.broker.donate_delegation(delegation=source)
cycle = 1
self.broker.external_tick(cycle=cycle)
cycle += 1
units = 1
start = clock.cycle_start_date(cycle=self.DonateStartCycle)
end = clock.cycle_end_date(cycle=self.DonateEndCycle - 1)
sliver = self.build_sliver()
request = self.get_reservation_for_network_node(start, end, sliver)
self.broker.ticket(reservation=request,
callback=proxy,
caller=proxy.get_identity())
for c in range(cycle, self.DonateEndCycle):
self.broker.external_tick(cycle=c)
while self.broker.get_current_cycle() != c:
time.sleep(0.001)
if last_called < proxy.get_called():
self.assert_ticketed(proxy.get_reservation(), units,
request.get_type(), start, end)
last_called = proxy.get_called()
self.broker.await_no_pending_reservations()
self.assertEqual(1, proxy.get_called())
self.assertTrue(request.is_closed())
def register_common(self, *, actor: ABCActorMixin):
"""
Performs the common steps required to register an actor with the container.
@param actor actor
@raises Exception in case of error
"""
ActorRegistrySingleton.get().register_actor(actor=actor)
self.register_proxies(actor=actor)
RemoteActorCacheSingleton.get().register_with_registry(actor=actor)
def remove_actor(self, *, actor_name: str):
"""
Remove actor metadata
@param actor_name actor name;
@raises Exception in case of error
"""
self.db.remove_actor(actor_name=actor_name)
actor = ActorRegistrySingleton.get().get_actor(actor_name_or_guid=actor_name)
if actor is not None:
ActorRegistrySingleton.get().unregister(actor=actor)
actor.actor_removed()
def get_authority_proxy(self) -> ABCAuthorityProxy:
auth = AuthToken(name="mysite", guid=ID())
from fabric_cf.actor.core.container.globals import GlobalsSingleton
proxy = KafkaAuthorityProxy(kafka_topic="test-topic",
identity=auth,
logger=GlobalsSingleton.get().get_logger())
if ActorRegistrySingleton.get().get_proxy(Constants.PROTOCOL_LOCAL,
"mysite") is None:
dummy = DummyAuthorityProxy(auth=auth)
ActorRegistrySingleton.get().register_proxy(dummy)
return proxy
def reclaim_delegation_client(self, *, delegation_id: str = None, slice_object: ABCSlice = None,
broker: ABCBrokerProxy = None, id_token: str = None) -> ABCDelegation:
if delegation_id is None:
raise BrokerException(error_code=ExceptionErrorCode.INVALID_ARGUMENT, msg="delegation_id")
if broker is None:
broker = self.get_default_broker()
if slice_object is None:
slice_object = self.get_default_slice()
if slice_object is None:
slice_object = SliceFactory.create(slice_id=ID(), name=self.identity.get_name())
slice_object.set_owner(owner=self.identity)
slice_object.set_inventory(value=True)
delegation = BrokerDelegationFactory.create(did=delegation_id, slice_id=slice_object.get_slice_id(),
broker=broker)
delegation.set_slice_object(slice_object=slice_object)
delegation.set_exported(value=True)
callback = ActorRegistrySingleton.get().get_callback(protocol=Constants.PROTOCOL_KAFKA,
actor_name=self.get_name())
if callback is None:
raise BrokerException(error_code=ExceptionErrorCode.NOT_SUPPORTED, msg="callback is None")
delegation.prepare(callback=callback, logger=self.logger)
delegation.validate_outgoing()
self.wrapper.reclaim_delegation_request(delegation=delegation, caller=broker, callback=callback,
id_token=id_token)
return delegation
def new_proxy(self, *, identity: ABCActorIdentity, location: ActorLocation, proxy_type: str = None) -> ABCProxy:
actor = ActorRegistrySingleton.get().get_actor(actor_name_or_guid=identity.get_name())
if actor is not None:
if isinstance(actor, ABCAuthority):
return LocalAuthority(actor=actor)
elif isinstance(actor, ABCBrokerMixin):
return LocalBroker(actor=actor)
return None
def get_actors_from_registry(*, atype: int, caller: AuthToken):
result = []
actors = ActorRegistrySingleton.get().get_actors()
if actors is not None:
for a in actors:
if atype == ActorType.All.value or atype == a.get_type():
result.append(a)
return result
def prepare_update_lease(self, *, reservation: ABCAuthorityReservation, update_data: UpdateData,
callback: ABCCallbackProxy, caller: AuthToken) -> ABCRPCRequestState:
state = ClientCallbackHelper.MyRequestState()
state.reservation = LocalReturn.pass_reservation(reservation=reservation,
plugin=ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=self.token.get_name()).get_plugin())
state.update_data = UpdateData()
state.update_data.absorb(other=update_data)
return state
def prepare_update_ticket(self, *, reservation: ABCBrokerReservation, update_data: UpdateData,
callback: ABCCallbackProxy, caller: AuthToken) -> ABCRPCRequestState:
state = self.MyRequestState()
state.reservation = LocalReturn.pass_reservation(reservation=reservation,
plugin=ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=self.token.get_name()).get_plugin())
self.prepared += 1
return state
def shutdown(self):
try:
self.logger.info("Actor container shutting down")
self.remove_state_file()
self.stop()
self.logger.info("Stopping RPC Manager")
from fabric_cf.actor.core.kernel.rpc_manager_singleton import RPCManagerSingleton
RPCManagerSingleton.get().stop()
self.logger.info("Stopping actors")
actors = ActorRegistrySingleton.get().get_actors()
for actor in actors:
self.logger.info(f"Stopping actor: {actor.get_name()}")
actor.stop()
self.unregister_actor(actor=actor)
ActorRegistrySingleton.get().clear()
self.logger.info("Container is no longer active")
except Exception as e:
self.logger.error(f"Exception occurred while shutting down e: {e}")
self.logger.error(traceback.format_exc())
def fill_actor_from_db(*, actor: ABCActorMixin) -> ActorAvro:
result = ActorAvro()
result.set_description(actor.get_description())
result.set_name(actor.get_name())
result.set_type(actor.get_type().value)
from fabric_cf.actor.core.registry.actor_registry import ActorRegistrySingleton
aa = ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=actor.get_name())
result.set_online(aa is not None)
return result
def translate_ticket_from_avro(*, avro_ticket: AvroTicket) -> Ticket:
ticket = Ticket()
ticket.delegation_id = avro_ticket.delegation_id
auth_identity = Translate.translate_auth_from_avro(auth_avro=avro_ticket.authority)
ticket.authority = ActorRegistrySingleton.get().get_proxy(protocol=Constants.PROTOCOL_KAFKA,
actor_name=auth_identity.get_name())
ticket.old_units = avro_ticket.old_units
if avro_ticket.resource_ticket is not None:
ticket.resource_ticket = Translate.translate_resource_ticket_from_avro(
resource_ticket=avro_ticket.resource_ticket)
return ticket
def new_callback(self, *, identity: ABCActorIdentity,
location: ActorLocation) -> ABCCallbackProxy:
result = None
actor = ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=identity.get_name())
if actor is not None:
descriptor = location.get_descriptor()
if descriptor is not None and descriptor.get_location(
) is not None:
kafka_topic = descriptor.get_location()
result = KafkaReturn(kafka_topic=kafka_topic,
identity=actor.get_identity(),
logger=actor.get_logger())
return result
def do_get_proxies(self,
*,
atype: ActorType,
protocol: str,
caller: AuthToken,
id_token: str = None) -> ResultProxyAvro:
result = ResultProxyAvro()
result.status = ResultAvro()
if caller is None or protocol is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.name)
return result
try:
proxies = None
if atype == ActorType.Broker:
proxies = ActorRegistrySingleton.get().get_broker_proxies(
protocol=protocol)
elif atype == ActorType.Authority:
proxies = ActorRegistrySingleton.get().get_site_proxies(
protocol=protocol)
else:
proxies = ActorRegistrySingleton.get().get_proxies(
protocol=protocol)
result.proxies = Converter.fill_proxies(proxies=proxies)
except Exception as e:
self.logger.error("get_broker_proxies {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def register_proxies(self, *, actor: ABCActorMixin):
"""
Registers all proxies for the specified actor.
@param actor actor
@raises Exception in case of error
"""
self.logger.debug(f"Registering proxies for actor: {actor.get_name()}")
for protocol in self.protocols.values():
self.logger.debug(f"Processing protocol {protocol.get_protocol()}")
location = ActorLocation()
location.set_descriptor(descriptor=protocol)
proxy = ProxyFactorySingleton.get().new_proxy(protocol=protocol.get_protocol(),
identity=actor.get_identity(), location=location)
if proxy is not None:
self.logger.debug(f"Registering proxy {actor.get_name()} for protocol {protocol.get_protocol()}")
ActorRegistrySingleton.get().register_proxy(proxy=proxy)
callback = ProxyFactorySingleton.get().new_callback(protocol=protocol.get_protocol(),
identity=actor.get_identity(), location=location)
if callback is not None:
self.logger.debug(f"Registering callback {actor.get_name()} for protocol {protocol.get_protocol()}")
ActorRegistrySingleton.get().register_callback(callback=callback)
def new_proxy(self,
*,
identity: ABCActorIdentity,
location: ActorLocation,
proxy_type: str = None) -> ABCProxy:
result = None
actor = ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=identity.get_name())
if actor is not None:
descriptor = location.get_descriptor()
if descriptor is not None and descriptor.get_location(
) is not None:
if isinstance(actor, ABCAuthority):
result = KafkaAuthorityProxy(
kafka_topic=descriptor.get_location(),
identity=actor.get_identity(),
logger=actor.get_logger())
elif isinstance(actor, ABCBrokerMixin):
result = KafkaBrokerProxy(
kafka_topic=descriptor.get_location(),
identity=actor.get_identity(),
logger=actor.get_logger())
else:
kafka_topic = location.get_location()
if proxy_type is not None:
from fabric_cf.actor.core.container.globals import GlobalsSingleton
if proxy_type.lower() == ActorType.Authority.name.lower():
result = KafkaAuthorityProxy(
kafka_topic=kafka_topic,
identity=identity.get_identity(),
logger=GlobalsSingleton.get().get_logger())
elif proxy_type.lower() == ActorType.Broker.name.lower():
result = KafkaBrokerProxy(
kafka_topic=kafka_topic,
identity=identity.get_identity(),
logger=GlobalsSingleton.get().get_logger())
else:
raise ProxyException(
"Unsupported proxy type: {}".format(proxy_type))
else:
raise ProxyException(
Constants.NOT_SPECIFIED_PREFIX.format("proxy type"))
return result
def recover(self):
actor_name = None
if Constants.PROPERTY_ACTOR_NAME in self.serial:
actor_name = self.serial[Constants.PROPERTY_ACTOR_NAME]
else:
raise ManageException(
Constants.NOT_SPECIFIED_PREFIX.format("actor name"))
actor = ActorRegistrySingleton.get().get_actor(
actor_name_or_guid=actor_name)
if actor is None:
raise ManageException(
Constants.OBJECT_NOT_FOUND.format("Managed Object",
actor_name))
self.set_actor(actor=actor)
def pass_client_delegation(self, *, delegation: DelegationAvro,
caller: AuthToken) -> ABCDelegation:
slice_obj = Translate.translate_slice(slice_avro=delegation.slice)
dlg = BrokerDelegationFactory.create(
did=delegation.get_delegation_id(),
slice_id=slice_obj.get_slice_id(),
broker=None)
dlg.restore(actor=self.actor, slice_obj=slice_obj)
site_proxy = ActorRegistrySingleton.get().get_proxy(
protocol=Constants.PROTOCOL_KAFKA, actor_name=caller.get_name())
dlg.set_site_proxy(site_proxy=site_proxy)
if delegation.graph is not None:
dlg.load_graph(graph_str=delegation.graph)
return dlg
def get_callback(*, actor: ABCActorMixin,
protocol: str) -> ABCCallbackProxy:
"""
Obtains a callback for the specified actor
@param actor actor
@param protocol protocol
@return ICallbackProxy
"""
if actor is None:
raise ProxyException(
Constants.NOT_SPECIFIED_PREFIX.format("actor"))
callback = ActorRegistrySingleton.get().get_callback(
protocol=protocol, actor_name=actor.get_name())
if callback is None:
raise ProxyException(
"Could not obtain callback proxy: protocol={}".format(
protocol))
return callback
def new_callback(self, *, identity: ABCActorIdentity, location: ActorLocation) -> ABCCallbackProxy:
actor = ActorRegistrySingleton.get().get_actor(actor_name_or_guid=identity.get_name())
if actor is not None:
return LocalReturn(actor=actor)
return None
def get_actor(self) -> ABCActorMixin:
result = ActorRegistrySingleton.get().get_actor(self.get_name())
if result is None:
raise ProxyException("Actor does not exist.")
return result
def _test_h_request_insufficient_cores(self):
broker = self.get_broker()
controller = self.get_controller()
policy = broker.get_policy()
policy.allocation_horizon = 10
clock = broker.get_actor_clock()
proxy = ClientCallbackHelper(name=controller.get_name(),
guid=controller.get_guid())
broker_callback = ClientCallbackHelper(name=broker.get_name(),
guid=broker.get_guid())
ActorRegistrySingleton.get().register_callback(callback=proxy)
ActorRegistrySingleton.get().register_callback(
callback=broker_callback)
slice_obj = SliceFactory.create(slice_id=ID(), name="inventory_slice")
slice_obj.set_inventory(value=True)
source = self.get_source_delegation(self.broker, slice_obj)
self.broker.register_slice(slice_object=slice_obj)
self.broker.register_delegation(delegation=source)
self.broker.donate_delegation(delegation=source)
cycle = 1
broker.external_tick(cycle=cycle)
cycle += 1
start = clock.cycle_start_date(cycle=self.DonateStartCycle)
end = clock.cycle_end_date(cycle=self.DonateEndCycle - 1)
sliver = self.build_sliver_with_components()
caphint = CapacityHints(instance_type="fabric.c64.m384.d4000")
sliver.set_capacity_hints(caphint=caphint)
request = self.get_reservation_for_network_node(start,
end,
sliver=sliver)
broker.ticket(reservation=request,
callback=proxy,
caller=proxy.get_identity())
self.assertEqual(proxy.prepared, 0)
self.assertEqual(proxy.called, 0)
for c in range(cycle, self.DonateEndCycle):
broker.external_tick(cycle=c)
while broker.get_current_cycle() != c:
time.sleep(0.001)
while proxy.prepared != 1:
time.sleep(0.001)
self.assert_failed(request)
self.assertEqual(1, proxy.prepared)
if proxy.called > 0:
print("Proxy Called")
# self.assert_failed(proxy.get_reservation(), proxy.update_data)
broker.await_no_pending_reservations()
self.assertEqual(1, proxy.get_called())
self.assertTrue(request.is_closed())
