def translate_auth_to_avro(*, auth: AuthToken) -> AuthAvro:
result = AuthAvro()
result.name = auth.get_name()
result.guid = str(auth.get_guid())
result.oidc_sub_claim = auth.get_oidc_sub_claim()
result.email = auth.get_email()
return result
def __init__(self, *, auth: AuthToken = None):
self.logger = None
self.proxy_type = None
self.callback = False
self.actor_name = None
if auth is not None:
self.actor_name = auth.get_name()
self.actor_guid = None
if auth is not None:
self.actor_guid = auth.get_guid()
self.auth = auth
def advertise(self, *, info: ExportAdvertisement):
"""
Advertise a delegation
@param info advertisement information
@raises ConfigurationException in case of error
"""
self.logger.debug(
f"Using Server Actor {info.exporter.__class__.__name__} to export resources"
)
delegation = self.aggregate_delegation_models.get(
info.delegation, None)
if delegation is None:
raise ConfigurationException(
f"Aggregate Delegation Model not found for delegation: {info.delegation}"
)
client = AuthToken(name=info.client.get_name(),
guid=ID(uid=info.client.get_guid()))
info.exported = info.exporter.advertise_resources(
delegation=delegation,
delegation_name=info.delegation,
client=client)
if info.exported is None:
raise ConfigurationException(
f"Could not export resources from actor: {info.exporter.get_name()} to actor:"
f" {info.client.get_name()} Error = {info.exporter.get_last_error()}"
)
def do_reclaim_delegation(self,
*,
actor: ABCActorMixin,
proxy: ABCBrokerProxy,
delegation: ABCDelegation,
callback: ABCClientCallbackProxy,
caller: AuthToken,
id_token: str = None):
proxy.get_logger().info(
"Outbound reclaim delegation request from <{}>: {}".format(
caller.get_name(), delegation))
state = proxy.prepare_reclaim_delegation(delegation=delegation,
callback=callback,
caller=caller,
id_token=id_token)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.ReclaimDelegation)
rpc = RPCRequest(request=state,
actor=actor,
proxy=proxy,
delegation=delegation,
sequence=delegation.get_sequence_out())
# Schedule a timeout
rpc.timer = KernelTimer.schedule(queue=actor,
task=ReclaimTimeout(req=rpc),
delay=self.CLAIM_TIMEOUT_SECONDS)
proxy.get_logger().info("Timer started: {} for Reclaim".format(
rpc.timer))
self.enqueue(rpc=rpc)
def make_actor_instance(*, actor_config: ActorConfig) -> ABCActorMixin:
"""
Creates Actor instance
@param actor_config actor config
@raises ConfigurationException in case of error
"""
actor_type = ActorType.get_actor_type_from_string(
actor_type=actor_config.get_type())
actor = None
if actor_type == ActorType.Orchestrator:
actor = Controller()
elif actor_type == ActorType.Broker:
actor = Broker()
elif actor_type == ActorType.Authority:
actor = Authority()
else:
raise ConfigurationException(
f"Unsupported actor type: {actor_type}")
actor_guid = ID()
if actor_config.get_guid() is not None:
actor_guid = ID(uid=actor_config.get_guid())
auth_token = AuthToken(name=actor_config.get_name(), guid=actor_guid)
actor.set_identity(token=auth_token)
if actor_config.get_description() is not None:
actor.set_description(description=actor_config.get_description())
from fabric_cf.actor.core.container.globals import GlobalsSingleton
actor.set_actor_clock(
clock=GlobalsSingleton.get().get_container().get_actor_clock())
return actor
def set_identity(self, *, token: AuthToken):
"""
Set identity
@param token token
"""
self.identity = token
self.name = self.identity.get_name()
self.guid = token.get_guid()
def get_uninitialized_authority(self, *, name: str,
guid: ID) -> ABCAuthority:
actor = self.get_authority_instance()
token = AuthToken(name=name, guid=guid)
actor.set_identity(token=token)
actor.set_actor_clock(clock=self.get_actor_clock())
actor.set_policy(policy=self.get_authority_policy())
actor.set_plugin(plugin=self.get_plugin(name=name))
return actor
def advertise(self, *, delegation: ABCPropertyGraph, delegation_name: str, client: AuthToken) -> str:
slice_obj = SliceFactory.create(slice_id=ID(), name=client.get_name())
slice_obj.set_owner(owner=client)
slice_obj.set_broker_client()
dlg_obj = DelegationFactory.create(did=delegation.get_graph_id(), slice_id=slice_obj.get_slice_id(),
delegation_name=delegation_name)
dlg_obj.set_slice_object(slice_object=slice_obj)
dlg_obj.set_graph(graph=delegation)
self.wrapper.advertise(delegation=dlg_obj, client=client)
return dlg_obj.get_delegation_id()
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 do_query_result(self, *, actor: ABCActorMixin,
remote_actor: ABCCallbackProxy, request_id: str,
response: dict, caller: AuthToken):
remote_actor.get_logger().info(
"Outbound query_result request from <{}>".format(
caller.get_name()))
state = remote_actor.prepare_query_result(request_id=request_id,
response=response,
caller=caller)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.QueryResult)
rpc = RPCRequest(request=state, actor=actor, proxy=remote_actor)
self.enqueue(rpc=rpc)
class ActorIdentity(ABCActorIdentity):
"""
Represent Actor Identity
"""
def __init__(self, *, name: str, guid: ID):
self.auth = AuthToken(name=name, guid=guid)
def get_guid(self) -> ID:
"""
Return guid
@return guid
"""
return self.auth.get_guid()
def get_identity(self) -> AuthToken:
"""
Return identity
@return identity
"""
return self.auth
def get_name(self) -> str:
return self.auth.get_name()
def translate_auth_from_avro(*, auth_avro: AuthAvro) -> AuthToken:
if auth_avro is None:
return None
result = AuthToken()
result.name = auth_avro.name
result.guid = auth_avro.guid
result.oidc_sub_claim = auth_avro.oidc_sub_claim
result.email = auth_avro.email
return result
def do_close(self, *, actor: ABCActorMixin, proxy: ABCAuthorityProxy,
reservation: ABCControllerReservation,
callback: ABCControllerCallbackProxy, caller: AuthToken):
proxy.get_logger().info("Outbound close request from <{}>: {}".format(
caller.get_name(), reservation))
state = proxy.prepare_close(reservation=reservation,
callback=callback,
caller=caller)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.Close)
rpc = RPCRequest(request=state,
actor=actor,
proxy=proxy,
reservation=reservation,
sequence=reservation.get_lease_sequence_out())
self.enqueue(rpc=rpc)
def do_ticket(self, *, actor: ABCActorMixin, proxy: ABCBrokerProxy,
reservation: ABCClientReservation,
callback: ABCClientCallbackProxy, caller: AuthToken):
proxy.get_logger().info("Outbound ticket request from <{}>: {}".format(
caller.get_name(), reservation))
state = proxy.prepare_ticket(reservation=reservation,
callback=callback,
caller=caller)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.Ticket)
rpc = RPCRequest(request=state,
actor=actor,
proxy=proxy,
reservation=reservation,
sequence=reservation.get_ticket_sequence_out())
self.enqueue(rpc=rpc)
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 do_update_delegation(self, *, actor: ABCActorMixin,
proxy: ABCClientCallbackProxy,
delegation: ABCDelegation,
update_data: UpdateData,
callback: ABCCallbackProxy, caller: AuthToken):
proxy.get_logger().info(
"Outbound update delegation request from <{}>: {}".format(
caller.get_name(), delegation))
state = proxy.prepare_update_delegation(delegation=delegation,
update_data=update_data,
callback=callback,
caller=caller)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.UpdateDelegation)
rpc = RPCRequest(request=state,
actor=actor,
proxy=proxy,
delegation=delegation,
sequence=delegation.get_sequence_out())
self.enqueue(rpc=rpc)
def do_query(self, *, actor: ABCActorMixin, remote_actor: ABCActorProxy,
local_actor: ABCCallbackProxy, query: dict,
handler: ABCQueryResponseHandler, caller: AuthToken,
id_token: str):
remote_actor.get_logger().info(
"Outbound query request from <{}>".format(caller.get_name()))
state = remote_actor.prepare_query(callback=local_actor,
query=query,
caller=caller,
id_token=id_token)
state.set_caller(caller=caller)
state.set_type(rtype=RPCRequestType.Query)
rpc = RPCRequest(request=state,
actor=actor,
proxy=remote_actor,
handler=handler)
# Timer
rpc.timer = KernelTimer.schedule(queue=actor,
task=QueryTimeout(req=rpc),
delay=self.QUERY_TIMEOUT_SECONDS)
remote_actor.get_logger().info("Timer started: {} for Query".format(
rpc.timer))
self.enqueue(rpc=rpc)
class ClientCallbackHelper(ABCClientCallbackProxy):
class MyRequestState(RPCRequestState):
def __init__(self):
super().__init__()
self.reservation = None
self.update_data = None
def __init__(self, *, name: str, guid: ID):
self.token = AuthToken(name=name, guid=guid)
self.called = 0
self.prepared = 0
self.reservation = None
def get_called(self) -> int:
return self.called
def get_guid(self) -> ID:
return self.token.get_guid()
def get_identity(self) -> AuthToken:
return self.token
def get_name(self) -> str:
return self.token.get_name()
def get_reservation(self) -> ABCReservationMixin:
return self.reservation
def get_type(self):
return Constants.PROTOCOL_LOCAL
def prepare_update_delegation(self, *, delegation: ABCDelegation, update_data: UpdateData,
callback: ABCCallbackProxy, caller: AuthToken) -> ABCRPCRequestState:
raise NotImplementedError
def set_logger(self, *, logger):
pass
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 execute(self, *, request: ABCRPCRequestState, producer: AvroProducerApi):
if request.get_type() == RPCRequestType.UpdateTicket:
self.called += 1
self.reservation = request.reservation
def get_logger(self):
from fabric_cf.actor.core.container.globals import GlobalsSingleton
return GlobalsSingleton.get().get_logger()
def prepare_query_result(self, *, request_id: str, response, caller: AuthToken) -> ABCRPCRequestState:
raise NotImplementedError
def prepare_failed_request(self, *, request_id: str, failed_request_type,
failed_reservation_id: ID, error: str, caller: AuthToken) -> ABCRPCRequestState:
raise NotImplementedError
def get_auth_token(self) -> AuthToken:
"""
Get auth token
:return:
"""
return AuthToken(name=self.name, guid=self.guid)
def __init__(self, *, name: str, guid: ID):
self.auth = AuthToken(name=name, guid=guid)
def __init__(self, *, name: str, guid: ID):
self.token = AuthToken(name=name, guid=guid)
self.called = 0
self.prepared = 0
self.reservation = None
