feat: Allow actors to be configurable (#346)

* WIP actor configurability

Signed-off-by: Shubham Sharma <[email protected]>

* Refactor config types

Signed-off-by: Shubham Sharma <[email protected]>

* Use new runtime configuration

Signed-off-by: Shubham Sharma <[email protected]>

* Remove dependency from Temporal and add unit test

Signed-off-by: Shubham Sharma <[email protected]>

* Remove commented code

Signed-off-by: Shubham Sharma <[email protected]>

* Fix lint

Signed-off-by: Shubham Sharma <[email protected]>

* Refactor

Signed-off-by: Shubham Sharma <[email protected]>

* Fix actor tests

Signed-off-by: Shubham Sharma <[email protected]>

* Lint

Signed-off-by: Shubham Sharma <[email protected]>

* Add e2e test

Signed-off-by: Shubham Sharma <[email protected]>

* Add docs

Signed-off-by: Shubham Sharma <[email protected]>

* Simplify response building

Signed-off-by: Shubham Sharma <[email protected]>

* Add link to time.ParseDuration

Signed-off-by: Shubham Sharma <[email protected]>

Signed-off-by: Shubham Sharma <[email protected]>

Author: shubham1172

daprdocs/content/en/js-sdk-docs/js-actors/_index.md

@@ -64,6 +64,38 @@ export default class ParkingSensorImpl extends AbstractActor implements ParkingS
 }
 ```
 
+### Configuring Actor Runtime
+
+To configure actor runtime, use the `DaprClientOptions`. The various parameters and their default values are documented at [How-to: Use virtual actors in Dapr](https://docs.dapr.io/developing-applications/building-blocks/actors/howto-actors/#configuration-parameters).
+
+Note, the timeouts and intervals should be formatted as [time.ParseDuration](https://pkg.go.dev/time#ParseDuration) strings.
+
+```javascript
+import { CommunicationProtocolEnum, DaprClient, DaprServer } from "@dapr/dapr";
+
+// Configure the actor runtime with the DaprClientOptions.
+const clientOptions = {
+  actor: {
+    actorIdleTimeout: '1h',
+    actorScanInterval: '30s',
+    drainOngoingCallTimeout: '1m',
+    drainRebalancedActors: true,
+    reentrancy: {
+      enabled: true,
+      maxStackDepth: 32
+    },
+    remindersStoragePartitions: 0,
+  }
+}
+
+// Use the options when creating DaprServer and DaprClient.
+
+// Note, DaprServer creates a DaprClient internally, which needs to be configured with clientOptions.
+const server = new DaprServer(serverHost, serverPort, daprHost, daprPort, clientOptions);
+
+const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.HTTP, clientOptions);
+```
+
 ## Registering Actors
 Initialize and register your actors by using the `DaprServer` package:
 
@@ -91,7 +123,7 @@ console.log(`Registered Actors: ${JSON.stringify(resRegisteredActors)}`);
 After Actors are registered, create a Proxy object that implements `ParkingSensorInterface` using the `ActorProxyBuilder`. You can invoke the actor methods by directly calling methods on the Proxy object. Internally, it translates to making a network call to the Actor API and fetches the result back.
 
 ```javascript
-import { DaprClient, ActorId } from "@dapr/dapr";
+import { ActorId, DaprClient } from "@dapr/dapr";
 import ParkingSensorImpl from "./ParkingSensorImpl";
 import ParkingSensorInterface from "./ParkingSensorInterface";
 

src/actors/runtime/ActorRuntime.ts

@@ -13,11 +13,11 @@ limitations under the License.
 
 import { DaprClient } from "../..";
 import IClient from "../../interfaces/Client/IClient";
+import { ActorRuntimeOptions } from "../../types/actors/ActorRuntimeOptions";
 import Class from "../../types/Class";
 import ActorId from "../ActorId";
 import AbstractActor from "./AbstractActor";
 import ActorManager from "./ActorManager";
-import ActorRuntimeConfig from "./ActorRuntimeConfig";
 
 /**
  * Creates instances of "Actor" and activates and deactivates "Actor"
@@ -27,7 +27,6 @@ export default class ActorRuntime {
 
   private readonly daprClient: DaprClient;
   private actorManagers: Map<string, ActorManager<any>>;
-  private actorRuntimeConfig: ActorRuntimeConfig = new ActorRuntimeConfig();
 
   // @todo: we need to make sure race condition cannot happen when accessing the active actors
   // NodeJS has an event loop (main thread -> runs JS code) and a worker pool (threadpool -> automatically created for offloading work through libuv) threads
@@ -73,12 +72,12 @@ export default class ActorRuntime {
     return Array.from(this.actorManagers.keys());
   }
 
-  getActorRuntimeConfig(): ActorRuntimeConfig {
-    return this.actorRuntimeConfig;
+  getActorRuntimeOptions(): ActorRuntimeOptions {
+    return this.daprClient.options.actor ?? {};
   }
 
-  setActorRuntimeConfig(config: ActorRuntimeConfig): void {
-    this.actorRuntimeConfig = config;
+  setActorRuntimeOptions(options: ActorRuntimeOptions): void {
+    this.daprClient.options.actor = options;
   }
 
   clearActorManagers(): void {

src/actors/runtime/ActorRuntimeConfig.ts

@@ -18,10 +18,10 @@ import Class from '../../../types/Class';
 import ActorRuntime from '../../../actors/runtime/ActorRuntime';
 import IRequest from '../../../types/http/IRequest';
 import IResponse from '../../../types/http/IResponse';
-import { GetRegisteredActorsType } from '../../../types/response/GetRegisteredActors.type';
 import BufferSerializer from '../../../actors/runtime/BufferSerializer';
 import { DaprClient } from '../../..';
 import { Logger } from '../../../logger/Logger';
+import { getRegisteredActorResponse } from '../../../utils/Actors.util';
 
 // https://docs.dapr.io/reference/api/bindings_api/
 export default class HTTPServerActor implements IServerActor {
@@ -70,19 +70,15 @@ export default class HTTPServerActor implements IServerActor {
     this.server.getServer().put("/actors/:actorTypeName/:actorId/method/remind/:reminderName", this.handlerReminder.bind(this));
   }
 
-  private async handlerHealth(req: IRequest, res: IResponse): Promise<void> {
+  private async handlerHealth(_req: IRequest, res: IResponse): Promise<void> {
     return res.send("ok");
   }
 
-  private async handlerConfig(req: IRequest, res: IResponse): Promise<void> {
+  private async handlerConfig(_req: IRequest, res: IResponse): Promise<void> {
     const actorRuntime = ActorRuntime.getInstance(this.client.getDaprClient());
-
-    const result: GetRegisteredActorsType = {
-      entities: actorRuntime.getRegisteredActorTypes(),
-      ...actorRuntime.getActorRuntimeConfig().toDictionary()
-    }
-
-    return res.send(result);
+    return res.send(getRegisteredActorResponse(
+        actorRuntime.getRegisteredActorTypes(), 
+        actorRuntime.getActorRuntimeOptions()));
   }
 
   private async handlerDeactivate(req: IRequest, res: IResponse): Promise<void> {

src/implementation/Server/HTTPServer/actor.ts

@@ -11,6 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { ActorRuntimeOptions } from "./actors/ActorRuntimeOptions";
 import { LoggerOptions } from "./logger/LoggerOptions";
 
 export type DaprClientOptions = {
@@ -24,4 +25,9 @@ export type DaprClientOptions = {
    * Options related to logging.
    */
   logger?: LoggerOptions;
+
+  /**
+   * Options related to actors.
+   */
+  actor?: ActorRuntimeOptions;
 }

src/types/DaprClientOptions.ts

@@ -0,0 +1,29 @@
+/*
+Copyright 2022 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * ActorReentrancyOptions provides options for configuring reentrancy in actors.
+ * For more, see https://docs.dapr.io/developing-applications/building-blocks/actors/actor-reentrancy/.
+ */
+export type ActorReentrancyOptions = {
+     /**
+     * Configure the reentrancy behavior for an actor. If not provided, reentrancy is disabled.
+     */
+    enabled?: boolean;
+
+    /**
+     * If reentrancy is enabled, this specifies the limit after which concurrent reentrant 
+     * requests to an actor are stopped. This is a safety measure against infinite reentrant calls.
+     */
+    maxStackDepth?: number;
+}

src/types/actors/ActorReentrancyOptions.ts

@@ -0,0 +1,58 @@
+/*
+Copyright 2022 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { ActorReentrancyOptions } from "./ActorReentrancyOptions";
+
+/**
+ * ActorRuntimeOptions provides options for configuring the actor runtime in Dapr.
+ * For more, see https://docs.dapr.io/developing-applications/building-blocks/actors/howto-actors/.
+ */
+export type ActorRuntimeOptions = {
+    /**
+     * The timeout before deactivating an idle actor. 
+     * Checks for timeouts occur every `actorScanInterval` interval.
+     * It uses the format required by [time.ParseDuration](https://pkg.go.dev/time#ParseDuration).
+     */
+    actorIdleTimeout?: string;
+
+    /**
+     * Specifies how often to scan for idle actors to deactivate them.
+     * Actors that have been idle longer than `actorIdleTimeout` will be deactivated. 
+     * It uses the format required by [time.ParseDuration](https://pkg.go.dev/time#ParseDuration).
+     */
+    actorScanInterval?: string;
+
+    /**
+     * The timeout before draining current active actor methods. 
+     * If there is no current actor method call, this is ignored.
+     * It uses the format required by [time.ParseDuration](https://pkg.go.dev/time#ParseDuration).
+     */
+    drainOngoingCallTimeout?: string;
+
+    /**
+     * If true, Dapr will wait for `drainOngoingCallTimeout` before 
+     * draining current active actor methods.
+     */
+    drainRebalancedActors?: boolean;
+
+    /**
+     * Configures different reentrancy parameters.
+     */
+    reentrancy?: ActorReentrancyOptions;
+
+    /**
+     * Specifies the number of partitions for actor’s reminders.
+     * If not provided, all reminders are saved as a single record in actor’s state store.
+     */
+    remindersStoragePartitions?: number;
+}

src/types/actors/ActorRuntimeOptions.ts

@@ -0,0 +1,26 @@
+/*
+Copyright 2022 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { ActorRuntimeOptions } from "../types/actors/ActorRuntimeOptions";
+import { KeyValueType } from "../types/KeyValue.type";
+
+/**
+ * Get response object for /dapr/config API call.
+ * See https://docs.dapr.io/reference/api/actors_api/#get-registered-actors
+ */
+export function getRegisteredActorResponse(entities: string[], options: ActorRuntimeOptions): KeyValueType {
+    return {
+        "entities": entities,
+        ...options
+    }
+}