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())