Merge pull request #149 from XavierGeerinck/master

Add Metadata & Health API

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,20 +3,26 @@ 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';
@@ -34,6 +40,8 @@ export default class DaprClient {
   readonly binding: IClientBinding;
   readonly invoker: IClientInvoker;
   readonly secret: IClientSecret;
+  readonly health: IClientHealth;
+  readonly metadata: IClientMetadata;
 
   constructor(
     daprHost: string
@@ -64,6 +72,8 @@ export default class DaprClient {
         this.binding = new GRPCClientBinding(client);
         this.invoker = new GRPCClientInvoker(client);
         this.secret = new GRPCClientSecret(client);
+        this.health = new GRPCClientHealth(client);
+        this.metadata = new GRPCClientMetadata(client);
         break;
       }
       case CommunicationProtocolEnum.HTTP:
@@ -76,6 +86,8 @@ export default class DaprClient {
         this.binding = new HTTPClientBinding(client);
         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/health.ts

@@ -0,0 +1,32 @@
+import GRPCClient from './GRPCClient';
+import IClientHealth from '../../../interfaces/Client/IClientHealth';
+import { GetMetadataResponse } from '../../../proto/dapr/proto/runtime/v1/dapr_pb';
+import { Empty } from "google-protobuf/google/protobuf/empty_pb";
+
+// https://docs.dapr.io/reference/api/health_api/
+export default class GRPCClientHealth implements IClientHealth {
+  client: GRPCClient;
+
+  constructor(client: GRPCClient) {
+    this.client = client;
+  }
+
+  // There is no gRPC implementation of /healthz, so we try to fetch the metadata
+  async isHealthy(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const client = this.client.getClient();
+
+      try {
+        client.getMetadata(new Empty(), (err, res: GetMetadataResponse) => {
+          if (err) {
+            return resolve(false);
+          }
+
+          return resolve(true);
+        });
+      } catch (e) {
+        return resolve(false);
+      }
+    });
+  }
+}

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/GRPCClient/state.ts

@@ -1,12 +1,14 @@
 import GRPCClient from './GRPCClient';
-import { DeleteStateRequest, ExecuteStateTransactionRequest, GetBulkStateRequest, GetBulkStateResponse, GetStateRequest, GetStateResponse, SaveStateRequest, TransactionalStateOperation } from '../../../proto/dapr/proto/runtime/v1/dapr_pb';
+import { DeleteStateRequest, ExecuteStateTransactionRequest, GetBulkStateRequest, GetBulkStateResponse, GetStateRequest, GetStateResponse, QueryStateRequest, QueryStateResponse, SaveStateRequest, TransactionalStateOperation } from '../../../proto/dapr/proto/runtime/v1/dapr_pb';
 import { Etag, StateItem, StateOptions } from '../../../proto/dapr/proto/common/v1/common_pb';
 import { KeyValuePairType } from '../../../types/KeyValuePair.type';
 import { OperationType } from '../../../types/Operation.type';
 import { IRequestMetadata } from '../../../types/RequestMetadata.type';
 import IClientState from '../../../interfaces/Client/IClientState';
 import { KeyValueType } from '../../../types/KeyValue.type';
 import { merge } from '../../../utils/Map.util';
+import { StateQueryType } from '../../../types/StateQuery.type';
+import { StateQueryResponseType } from '../../../types/StateQueryResponse.type';
 
 // https://docs.dapr.io/reference/api/state_api/
 export default class GRPCClientState implements IClientState {
@@ -25,7 +27,7 @@ export default class GRPCClientState implements IClientState {
       si.setValue(Buffer.from(typeof stateObject.value === "object" ? JSON.stringify(stateObject.value) : stateObject.value.toString(), "utf-8"));
       stateList.push(si);
     }
-    
+
     const msgService = new SaveStateRequest();
     msgService.setStoreName(storeName);
     msgService.setStatesList(stateList);
@@ -48,7 +50,7 @@ export default class GRPCClientState implements IClientState {
     msgService.setStoreName(storeName);
     msgService.setKey(key)
 
-    
+
     // @todo: https://docs.dapr.io/reference/api/state_api/#optional-behaviors
     // msgService.setConsistency()
 
@@ -96,7 +98,7 @@ export default class GRPCClientState implements IClientState {
           let data: string;
           try {
             data = JSON.parse(resDataStr);
-          } catch(e) {
+          } catch (e) {
             data = resDataStr;
           }
           return {
@@ -180,4 +182,33 @@ export default class GRPCClientState implements IClientState {
       });
     });
   }
+
+  async query(storeName: string, query: StateQueryType): Promise<StateQueryResponseType> {
+    const msgService = new QueryStateRequest();
+    msgService.setStoreName(storeName);
+    msgService.setQuery(JSON.stringify(query))
+
+    return new Promise((resolve, reject) => {
+      const client = this.client.getClient();
+      client.queryStateAlpha1(msgService, (err, res: QueryStateResponse) => {
+        if (err) {
+          return reject(err);
+        }
+
+        // https://docs.dapr.io/reference/api/state_api/#response-body
+        // map the res from gRPC 
+        let resMapped: StateQueryResponseType = {
+          results: res.getResultsList().map((i) => ({
+            key: i.getKey(),
+            data: i.getData(),
+            etag: i.getEtag(),
+            error: i.getError(),
+          })),
+          token: res.getToken()
+        };
+
+        return resolve(resMapped);
+      });
+    });
+  }
 }

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -73,6 +73,11 @@ export default class HTTPClient implements IClient {
     this.httpsAgent.destroy();
   }
 
+  async executeWithApiVersion(apiVersion: string = "v1.0", url: string, params: any = {}): Promise<object | string> {
+    const newClientUrl = this.clientUrl.replace("v1.0", apiVersion);
+    return await this.execute(`${newClientUrl}${url}`, params);
+  }
+
   async execute(url: string, params: any = {}): Promise<object | string> {
     if (!params?.headers) {
       params.headers = {};

src/implementation/Client/HTTPClient/health.ts

@@ -0,0 +1,27 @@
+import HTTPClient from './HTTPClient';
+import IClientHealth from '../../../interfaces/Client/IClientHealth';
+
+// https://docs.dapr.io/reference/api/health_api/
+export default class HTTPClientHealth implements IClientHealth {
+  client: HTTPClient;
+
+  constructor(client: HTTPClient) {
+    this.client = client;
+  }
+
+  // Send an event to an external system
+  async isHealthy(): Promise<boolean> {
+    try {
+      const result = await this.client.execute(`/healthz`, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        }
+      });
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}

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/implementation/Client/HTTPClient/state.ts

@@ -4,6 +4,8 @@ import { OperationType } from '../../../types/Operation.type';
 import { IRequestMetadata } from '../../../types/RequestMetadata.type';
 import IClientState from '../../../interfaces/Client/IClientState';
 import { KeyValueType } from '../../../types/KeyValue.type';
+import { StateQueryType } from '../../../types/StateQuery.type';
+import { StateQueryResponseType } from '../../../types/StateQueryResponse.type';
 
 // https://docs.dapr.io/reference/api/state_api/
 export default class HTTPClientState implements IClientState {
@@ -61,4 +63,18 @@ export default class HTTPClientState implements IClientState {
       })
     });
   }
+
+  async query(storeName: string, query: StateQueryType): Promise<StateQueryResponseType> {
+    const result = await this.client.executeWithApiVersion("v1.0-alpha1", `/state/${storeName}/query`, {
+      method: 'POST',
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query
+      })
+    });
+
+    return result as StateQueryResponseType;
+  }
 }