async def register_actor(
cls,
actor: Type[Actor],
message_serializer: Serializer = DefaultJSONSerializer(),
state_serializer: Serializer = DefaultJSONSerializer(),
http_timeout_seconds: int = settings.DAPR_HTTP_TIMEOUT_SECONDS
) -> None:
"""Registers an :class:`Actor` object with the runtime.
Args:
actor (:class:`Actor`): Actor implementation.
message_serializer (:class:`Serializer`): A serializer that serializes message
between actors.
state_serializer (:class:`Serializer`): Serializer that serializes state values.
http_timeout_seconds (:int:): a configurable timeout value
"""
type_info = ActorTypeInformation.create(actor)
# TODO: We will allow to use gRPC client later.
actor_client = DaprActorHttpClient(message_serializer,
timeout=http_timeout_seconds)
ctx = ActorRuntimeContext(type_info, message_serializer,
state_serializer, actor_client)
# Create an ActorManager, override existing entry if registered again.
async with cls._actor_managers_lock:
cls._actor_managers[type_info.type_name] = ActorManager(ctx)
cls._actor_config.update_entities(
ActorRuntime.get_registered_actor_types())
def __init__(
self,
message_serializer=DefaultJSONSerializer(),
http_timeout_seconds: int = settings.DAPR_HTTP_TIMEOUT_SECONDS):
# TODO: support serializer for state store later
self._dapr_client = DaprActorHttpClient(message_serializer, timeout=http_timeout_seconds)
self._message_serializer = message_serializer
def setUp(self):
ActorRuntime._actor_managers = {}
ActorRuntime.set_actor_config(ActorRuntimeConfig())
self._serializer = DefaultJSONSerializer()
_run(ActorRuntime.register_actor(FakeSimpleActor))
_run(ActorRuntime.register_actor(FakeMultiInterfacesActor))
_run(ActorRuntime.register_actor(FakeSimpleTimerActor))
def setUp(self):
self._testActorTypeInfo = ActorTypeInformation.create(FakeSimpleActor)
self._serializer = DefaultJSONSerializer()
self._fake_client = FakeDaprActorClient
self._fake_runtime_ctx = ActorRuntimeContext(self._testActorTypeInfo,
self._serializer,
self._serializer,
self._fake_client)
def setUp(self):
ActorRuntime._actor_managers = {}
ActorRuntime.set_actor_config(
ActorRuntimeConfig(reentrancy=ActorReentrancyConfig(enabled=True)))
self._serializer = DefaultJSONSerializer()
_run(ActorRuntime.register_actor(FakeReentrantActor))
_run(ActorRuntime.register_actor(FakeSlowReentrantActor))
_run(ActorRuntime.register_actor(FakeMultiInterfacesActor))
def setUp(self):
self._test_type_info = ActorTypeInformation.create(FakeMultiInterfacesActor)
self._serializer = DefaultJSONSerializer()
self._fake_client = FakeDaprActorClient
self._runtime_ctx = ActorRuntimeContext(
self._test_type_info, self._serializer,
self._serializer, self._fake_client)
self._manager = ActorManager(self._runtime_ctx)
def setUp(self):
self._serializer = DefaultJSONSerializer()
self._fake_client = FakeDaprActorClient
self._test_reminder_req = self._serializer.serialize({
'name': 'test_reminder',
'dueTime': timedelta(seconds=1),
'period': timedelta(seconds=1),
'data': 'cmVtaW5kZXJfc3RhdGU=',
})
def __init__(
self,
timeout: int = 60,
headers_callback: Optional[Callable[[], Dict[str, str]]] = None):
"""Invokes Dapr's API for method invocation over HTTP.
Args:
timeout (int, optional): Timeout in seconds, defaults to 60.
headers_callback (lambda: Dict[str, str]], optional): Generates header for each request.
"""
self._client = DaprHttpClient(DefaultJSONSerializer(), timeout, headers_callback)
def setUp(self):
# Create mock client
self._fake_client = FakeDaprActorClient
self._test_actor_id = ActorId('1')
self._test_type_info = ActorTypeInformation.create(FakeSimpleActor)
self._serializer = DefaultJSONSerializer()
self._runtime_ctx = ActorRuntimeContext(self._test_type_info,
self._serializer,
self._serializer,
self._fake_client)
self._fake_actor = FakeSimpleActor(self._runtime_ctx,
self._test_actor_id)
def __init__(
self,
actor_client: DaprActorClientBase,
state_serializer: Serializer = DefaultJSONSerializer()):
self._state_client = actor_client
self._state_serializer = state_serializer
def setUp(self):
self._serializer = DefaultJSONSerializer()
self._fake_client = FakeDaprActorClient
def create(self, actor_interface, actor_type, actor_id) -> ActorProxy:
return ActorProxy(self._dapr_client, actor_interface, actor_type,
actor_id, DefaultJSONSerializer())
def __init__(self, message_serializer=DefaultJSONSerializer()):
# TODO: support serializer for state store later
self._dapr_client = DaprActorHttpClient(message_serializer)
self._message_serializer = message_serializer
def __init__(self, app: FastAPI):
self._dapr_serializer = DefaultJSONSerializer()
self._router = APIRouter()
self.init_routes(self._router)
app.include_router(self._router)
def __init__(self, app=None):
self._app = app
self._dapr_serializer = DefaultJSONSerializer()
if app is not None:
self.init_routes(app)