Add Metadata API

Signed-off-by: Xavier Geerinck <[email protected]>

Author: XavierGeerinck

CHANGELOG.md

@@ -9,6 +9,8 @@ Version 2.0.0 brings a lot of changes to the Dapr JS SDK that were long due. Bel
 * Actor Support has been added
 * Actor Proxy has been added for Actor Access
 * The HTTP Connection is now being reused to reduce the CONNRESET errors when intensively using the JS SDK 
+* The [Metadata API](https://docs.dapr.io/reference/api/metadata_api/) is supported
+* The [Health API](https://docs.dapr.io/reference/api/health_api/) is supported 
 
 #### Breaking Changes
 
@@ -18,5 +20,8 @@ Version 2.0.0 brings a lot of changes to the Dapr JS SDK that were long due. Bel
 #### Major Changes
 
 * KeepAlive for HTTP has been added and a new method in the `DaprClient` has been added named `stop()` to stop the client and release the connections kept by the sockets.
+* `healthz` endpoint was implemented as `client.health.isHealthy()` for gRPC this checks the `getMetadata` function since it does not have a Health PROTO.
+* Server startup now ensures the Dapr Sidecar is healthy before starting
+* Add metadata API for gRPC and HTTP
 
 ## 1.x release

src/implementation/Client/DaprClient.ts

@@ -3,27 +3,30 @@ import IClientPubSub from '../../interfaces/Client/IClientPubSub';
 import IClientState from '../../interfaces/Client/IClientState';
 import IClientInvoker from '../../interfaces/Client/IClientInvoker';
 import IClientSecret from '../../interfaces/Client/IClientSecret';
+import IClientHealth from '../../interfaces/Client/IClientHealth';
+import IClientMetadata from '../../interfaces/Client/IClientMetadata';
 import IClient from '../../interfaces/Client/IClient';
 
 import GRPCClientBinding from './GRPCClient/binding';
 import GRPCClientPubSub from './GRPCClient/pubsub';
 import GRPCClientState from './GRPCClient/state';
 import GRPCClientInvoker from './GRPCClient/invoker';
 import GRPCClientSecret from './GRPCClient/secret';
+import GRPCClientHealth from './GRPCClient/health';
+import GRPCClientMetadata from './GRPCClient/metadata';
 import GRPCClient from './GRPCClient/GRPCClient';
 
 import HTTPClientBinding from './HTTPClient/binding';
 import HTTPClientPubSub from './HTTPClient/pubsub';
 import HTTPClientState from './HTTPClient/state';
 import HTTPClientInvoker from './HTTPClient/invoker';
 import HTTPClientSecret from './HTTPClient/secret';
+import HTTPClientHealth from './HTTPClient/health';
+import HTTPClientMetadata from './HTTPClient/metadata';
 import HTTPClient from './HTTPClient/HTTPClient';
 
 import CommunicationProtocolEnum from '../../enum/CommunicationProtocol.enum';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
-import HTTPClientHealth from './HTTPClient/health';
-import IClientHealth from '../../interfaces/Client/IClientHealth';
-import GRPCClientHealth from './GRPCClient/health';
 
 export default class DaprClient {
   readonly daprHost: string;
@@ -38,6 +41,7 @@ export default class DaprClient {
   readonly invoker: IClientInvoker;
   readonly secret: IClientSecret;
   readonly health: IClientHealth;
+  readonly metadata: IClientMetadata;
 
   constructor(
     daprHost: string
@@ -69,6 +73,7 @@ export default class DaprClient {
         this.invoker = new GRPCClientInvoker(client);
         this.secret = new GRPCClientSecret(client);
         this.health = new GRPCClientHealth(client);
+        this.metadata = new GRPCClientMetadata(client);
         break;
       }
       case CommunicationProtocolEnum.HTTP:
@@ -82,6 +87,7 @@ export default class DaprClient {
         this.invoker = new HTTPClientInvoker(client);
         this.secret = new HTTPClientSecret(client);
         this.health = new HTTPClientHealth(client);
+        this.metadata = new HTTPClientMetadata(client);
         break;
       }
     }

src/implementation/Client/GRPCClient/metadata.ts

@@ -0,0 +1,63 @@
+import GRPCClient from './GRPCClient';
+import { GetMetadataResponse, SetMetadataRequest } from '../../../proto/dapr/proto/runtime/v1/dapr_pb';
+import { Empty } from "google-protobuf/google/protobuf/empty_pb";
+import IClientMetadata from '../../../interfaces/Client/IClientMetadata';
+import { GetMetadataResponse as GetMetadataResponseResult } from '../../../types/metadata/GetMetadataResponse';
+
+// https://docs.dapr.io/reference/api/metadata_api
+export default class GRPCClientMetadata implements IClientMetadata {
+  client: GRPCClient;
+
+  constructor(client: GRPCClient) {
+    this.client = client;
+  }
+
+  // There is no gRPC implementation of /healthz, so we try to fetch the metadata
+  async get(): Promise<GetMetadataResponseResult> {
+    return new Promise((resolve, reject) => {
+      const client = this.client.getClient();
+      client.getMetadata(new Empty(), (err, res: GetMetadataResponse) => {
+        if (err) {
+          return reject(err);
+        }
+
+        const wrapped: GetMetadataResponseResult = {
+          id: res.getId(),
+          actors: res.getActiveActorsCountList().map(a => ({
+            type: a.getType(),
+            count: a.getCount()
+          })),
+          extended: res.getExtendedMetadataMap().toObject().reduce((result: object, [key, value]) => {
+            // @ts-ignore
+            result[key] = value;
+            return result
+          }, {}),
+          components: res.getRegisteredComponentsList().map(c => ({
+            name: c.getName(),
+            type: c.getType(),
+            version: c.getVersion()
+          }))
+        }
+
+        return resolve(wrapped);
+      });
+    });
+  }
+
+  async set(key: string, value: string): Promise<boolean> {
+    const msg = new SetMetadataRequest();
+    msg.setKey(key);
+    msg.setValue(value);
+
+    return new Promise((resolve, reject) => {
+      const client = this.client.getClient();
+      client.setMetadata(msg, (err, res: Empty) => {
+        if (err) {
+          return reject(false);
+        }
+
+        return resolve(true);
+      });
+    });
+  }
+}

src/implementation/Client/HTTPClient/metadata.ts

@@ -0,0 +1,29 @@
+import HTTPClient from './HTTPClient';
+import { GetMetadataResponse } from '../../../types/metadata/GetMetadataResponse';
+import IClientMetadata from '../../../interfaces/Client/IClientMetadata';
+
+// https://docs.dapr.io/reference/api/metadata_api
+export default class HTTPClientMetadata implements IClientMetadata {
+  client: HTTPClient;
+
+  constructor(client: HTTPClient) {
+    this.client = client;
+  }
+
+  async get(): Promise<GetMetadataResponse> {
+    const result = await this.client.execute(`/metadata`);
+    return result as GetMetadataResponse;
+  }
+
+  async set(key: string, value: string): Promise<boolean> {
+    const result = await this.client.execute(`/metadata/${key}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "text/plain"
+      },
+      body: value
+    });
+
+    return true;
+  }
+}

src/interfaces/Client/IClientMetadata.ts

@@ -0,0 +1,6 @@
+import { GetMetadataResponse } from "../../types/metadata/GetMetadataResponse";
+
+export default interface IClientMetadata {
+  get(): Promise<GetMetadataResponse>;
+  set(key: string, value: string): Promise<boolean>;
+}

src/types/metadata/GetMetadataResponse.ts

@@ -0,0 +1,19 @@
+import { KeyValuePairType } from "../KeyValuePair.type";
+
+export type GetMetadataResponse = {
+  id: string;
+  actors: MetadataRegisteredActor[]
+  extended: KeyValueType;
+  components: MetadataComponent[]
+}
+
+type MetadataRegisteredActor = {
+  type: string;
+  count: number;
+}
+
+type MetadataComponent = {
+  name: string;
+  type: string;
+  version: string;
+}

test/e2e/main.grpc.test.ts

@@ -32,6 +32,35 @@ describe('grpc/main', () => {
     await server.stop();
   });
 
+  describe('metadata', () => {
+    it('should be able to get the metadata of the Dapr sidecar', async () => {
+      const res = await client.metadata.get();
+
+      // app id is not set in grpc?
+      // expect(res.id.length).toBeGreaterThan(0);
+      // expect(res.components.length).toBeGreaterThan(0);
+    });
+
+    it('should be able to set a custom metadata value of the Dapr sidecar', async () => {
+      await client.metadata.set("testKey", "Hello World");
+
+      const res = await client.metadata.get();
+
+      // app id is not set in grpc?
+      // expect(res.id.length).toBeGreaterThan(0);
+      // expect(res.id.length).toBeGreaterThan(0);
+      // expect(res.components.length).toBeGreaterThan(0);
+      expect(res.extended["testKey"]).toEqual("Hello World");
+    });
+  });
+
+  describe('health', () => {
+    it('should return true if Dapr is ready', async () => {
+      const res = await client.health.isHealthy();
+      expect(res).toEqual(true);
+    });
+  });
+
   describe('binding', () => {
     it('should be able to receive events', async () => {
       await client.binding.send('binding-mqtt', 'create', { hello: 'world' });

test/e2e/main.http.test.ts

@@ -37,9 +37,34 @@ describe('http/main', () => {
     await client.stop();
   });
 
+  describe('metadata', () => {
+    it('should be able to get the metadata of the Dapr sidecar', async () => {
+      const res = await client.metadata.get();
+
+      expect(res.id.length).toBeGreaterThan(0);
+      expect(res.components.length).toBeGreaterThan(0);
+    });
+
+    it('should be able to set a custom metadata value of the Dapr sidecar', async () => {
+      await client.metadata.set("testKey", "Hello World");
+
+      const res = await client.metadata.get();
+
+      expect(res.id.length).toBeGreaterThan(0);
+      expect(res.components.length).toBeGreaterThan(0);
+      expect(res.extended["testKey"]).toEqual("Hello World");
+    });
+  });
+
+  describe('health', () => {
+    it('should return true if Dapr is ready', async () => {
+      const res = await client.health.isHealthy();
+      expect(res).toEqual(true);
+    });
+  });
+
   describe('binding', () => {
     it('should be able to receive events', async () => {
-      console.log("STARTING TEST")
       await client.binding.send('binding-mqtt', 'create', { hello: 'world' });
 
       // Delay a bit for event to arrive