Remove duplicated logic

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

Author: XavierGeerinck

src/implementation/Client/DaprClient.ts

@@ -10,6 +10,7 @@ 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 * as NodeJSUtils from "../../utils/NodeJS.util";
 
 import IClientBinding from '../../interfaces/Client/IClientBinding';
 import IClientPubSub from '../../interfaces/Client/IClientPubSub';
@@ -133,13 +134,43 @@ export default class DaprClient {
     await this.daprClient.stop();
   }
 
+  async awaitSidecarStarted(): Promise<void> {
+    // Dapr will probe every 50ms to see if we are listening on our port: https://github.com/dapr/dapr/blob/a43712c97ead550ca2f733e9f7e7769ecb195d8b/pkg/runtime/runtime.go#L1694
+    // if we are using actors we will change this to 4s to let the placement tables update
+    let isHealthy = false;
+    let isHealthyRetryCount = 0;
+    const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
+
+    console.log(`[Dapr-JS][Client] Awaiting Sidecar to be Started`);
+    while (!isHealthy) {
+      console.log(`[Dapr-JS][Client] Waiting till Dapr Sidecar Started (#${isHealthyRetryCount})`);
+      await NodeJSUtils.sleep(Settings.getDaprSidecarPollingDelayMs());
+
+      // Implement API call manually as we need to enable calling without initialization
+      // everything routes through the `execute` method
+      // to check health, we just ping the /metadata endpoint and see if we get a response
+      isHealthy = await this.health.isHealthy();
+
+      // Finally, Handle the retry logic
+      isHealthyRetryCount++;
+
+      if (isHealthyRetryCount > isHealthyMaxRetryCount) {
+        throw new Error("DAPR_SIDECAR_COULD_NOT_BE_STARTED");
+      }
+    }
+  }
+
   /**
-   * Ensure the sidecar connection has been initialized
-   * this method is not mandatory to be utilized as we will 
-   * ensure the sidecar connection is initialized in the methods that require it
+   * Ensure the client is started, this takes care of:
+   * 1. Making sure the sidecar is started
+   * 2. Making sure the connection is established (e.g. in gRPC)
+   * 3. Making sure the client is ready to be used
    */
   async start(): Promise<void> {
+    await this.awaitSidecarStarted();
     await this.daprClient.start();
+    await this.daprClient.setIsInitialized(true);
+    console.log(`[Dapr-JS][Client] Sidecar Started`);
   }
 
   getDaprClient(): IClient {

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -17,9 +17,6 @@ import IClient from "../../../interfaces/Client/IClient";
 import CommunicationProtocolEnum from "../../../enum/CommunicationProtocol.enum";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
 import { Settings } from '../../../utils/Settings.util';
-import * as NodeJSUtils from "../../../utils/NodeJS.util";
-import { Empty } from "google-protobuf/google/protobuf/empty_pb";
-import { GetMetadataResponse } from "../../../proto/dapr/proto/runtime/v1/dapr_pb";
 
 export default class GRPCClient implements IClient {
   private isInitialized: boolean;
@@ -67,20 +64,8 @@ export default class GRPCClient implements IClient {
     return this.options;
   }
 
-  async isSidecarStarted(): Promise<boolean> {
-    return new Promise((resolve, _reject) => {
-      try {
-        this.client.getMetadata(new Empty(), (err, _res: GetMetadataResponse) => {
-          if (err) {
-            return resolve(false);
-          }
-
-          return resolve(true);
-        });
-      } catch (e) {
-        return resolve(false);
-      }
-    });
+  setIsInitialized(isInitialized: boolean): void {
+    this.isInitialized = isInitialized;
   }
 
   async stop(): Promise<void> {
@@ -93,6 +78,7 @@ export default class GRPCClient implements IClient {
     return new Promise((resolve, reject) => {
       this.client.waitForReady(deadline, (err?) => {
         if (err) {
+          console.error(err);
           return reject();
         }
 
@@ -103,33 +89,5 @@ export default class GRPCClient implements IClient {
 
   async start(): Promise<void> {
     await this._startWaitForClientReady();
-
-    // Dapr will probe every 50ms to see if we are listening on our port: https://github.com/dapr/dapr/blob/a43712c97ead550ca2f733e9f7e7769ecb195d8b/pkg/runtime/runtime.go#L1694
-    // if we are using actors we will change this to 4s to let the placement tables update
-    let isHealthy = false;
-    let isHealthyRetryCount = 0;
-    const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
-
-    console.log(`[Dapr-JS][Client] Awaiting Sidecar to be Started`);
-    while (!isHealthy) {
-      console.log(`[Dapr-JS][Client] Waiting till Dapr Sidecar Started (#${isHealthyRetryCount})`);
-      await NodeJSUtils.sleep(Settings.getDaprSidecarPollingDelayMs());
-
-      // Implement API call manually as we need to enable calling without initialization
-      // everything routes through the `execute` method
-      // to check health, we just ping the /metadata endpoint and see if we get a response
-      isHealthy = await this.isSidecarStarted();
-
-      // Finally, Handle the retry logic
-      isHealthyRetryCount++;
-
-      if (isHealthyRetryCount > isHealthyMaxRetryCount) {
-        throw new Error("DAPR_SIDECAR_COULD_NOT_BE_STARTED");
-      }
-    }
-
-    // We are initialized
-    this.isInitialized = true;
-    console.log(`[Dapr-JS][Client] Sidecar Started`);
   }
 }

src/implementation/Client/GRPCClient/health.ts

@@ -13,6 +13,8 @@ limitations under the License.
 
 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 {
@@ -24,6 +26,20 @@ export default class GRPCClientHealth implements IClientHealth {
 
   // There is no gRPC implementation of /healthz, so we try to fetch the metadata
   async isHealthy(): Promise<boolean> {
-    return this.client.isSidecarStarted();
+    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/HTTPClient/HTTPClient.ts

@@ -18,7 +18,6 @@ import http from "http";
 import https from "https";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
 import { Settings } from '../../../utils/Settings.util';
-import * as NodeJSUtils from "../../../utils/NodeJS.util";
 import { THTTPExecuteParams } from "../../../types/http/THTTPExecuteParams.type"
 
 export default class HTTPClient implements IClient {
@@ -89,48 +88,16 @@ export default class HTTPClient implements IClient {
     return this.options;
   }
 
+  setIsInitialized(isInitialized: boolean): void {
+    this.isInitialized = isInitialized;
+  }
+
   async stop(): Promise<void> {
     this.httpAgent.destroy();
     this.httpsAgent.destroy();
   }
 
-  async isSidecarStarted(): Promise<boolean> {
-    try {
-      await this.execute(`/metadata`, null, false);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
   async start(): Promise<void> {
-    // Dapr will probe every 50ms to see if we are listening on our port: https://github.com/dapr/dapr/blob/a43712c97ead550ca2f733e9f7e7769ecb195d8b/pkg/runtime/runtime.go#L1694
-    // if we are using actors we will change this to 4s to let the placement tables update
-    let isHealthy = false;
-    let isHealthyRetryCount = 0;
-    const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
-
-    console.log(`[Dapr-JS][Client] Awaiting Sidecar to be Started`);
-    while (!isHealthy) {
-      console.log(`[Dapr-JS][Client] Waiting till Dapr Sidecar Started (#${isHealthyRetryCount})`);
-      await NodeJSUtils.sleep(Settings.getDaprSidecarPollingDelayMs());
-
-      // Implement API call manually as we need to enable calling without initialization
-      // everything routes through the `execute` method
-      // to check health, we just ping the /metadata endpoint and see if we get a response
-      isHealthy = await this.isSidecarStarted();
-
-      // Finally, Handle the retry logic
-      isHealthyRetryCount++;
-
-      if (isHealthyRetryCount > isHealthyMaxRetryCount) {
-        throw new Error("DAPR_SIDECAR_COULD_NOT_BE_STARTED");
-      }
-    }
-
-    // We are initialized
-    this.isInitialized = true;
-    console.log(`[Dapr-JS][Client] Sidecar Started`);
   }
 
   async executeWithApiVersion(apiVersion = "v1.0", url: string, params: any = {}): Promise<object | string> {

src/implementation/Client/HTTPClient/health.ts

@@ -24,6 +24,11 @@ export default class HTTPClientHealth implements IClientHealth {
 
   // Send an event to an external system
   async isHealthy(): Promise<boolean> {
-    return this.client.isSidecarStarted();
+    try {
+      const result = await this.client.execute(`/metadata`);
+      return !!result;
+    } catch (e) {
+      return false;
+    }
   }
 }

src/implementation/Server/DaprServer.ts

@@ -110,24 +110,8 @@ export default class DaprServer {
     // First start the server as we need to initialize routes for PubSub, Bindings, ...
     await this.daprServer.start(this.serverHost, this.serverPort.toString());
 
-    // Ensure our sidecar starts
-    // Dapr will probe every 50ms to see if we are listening on our port: https://github.com/dapr/dapr/blob/a43712c97ead550ca2f733e9f7e7769ecb195d8b/pkg/runtime/runtime.go#L1694
-    // if we are using actors we will change this to 4s to let the placement tables update
-    let isHealthy = false;
-    let isHealthyRetryCount = 0;
-    const isHealthyMaxRetryCount = 60; // 1s startup delay and we try max for 60s
-
-    console.log(`[Dapr-JS][Server] Awaiting Sidecar to be Started`);
-    while (!isHealthy) {
-      console.log(`[Dapr-JS][Server] Waiting till Dapr Sidecar Started (#${isHealthyRetryCount})`);
-      await NodeJSUtils.sleep(Settings.getDaprSidecarPollingDelayMs());
-      isHealthy = await this.client.getDaprClient().isSidecarStarted();
-      isHealthyRetryCount++;
-
-      if (isHealthyRetryCount > isHealthyMaxRetryCount) {
-        throw new Error("DAPR_SIDECAR_COULD_NOT_BE_STARTED");
-      }
-    }
+    // Ensure our sidecar starts and the client is ready
+    await this.client.start();
 
     // We are initialized
     console.log(`[Dapr-JS][Server] Sidecar Started`);

src/interfaces/Client/IClient.ts

@@ -20,7 +20,7 @@ export default interface IClient {
   getClientPort(): string;
   getClientCommunicationProtocol(): CommunicationProtocolEnum;
   getOptions(): DaprClientOptions;
-  isSidecarStarted(): Promise<boolean>;
+  setIsInitialized(isInitialized: boolean): void;
   stop(): Promise<void>;
   start(): Promise<void>;
 }

test/e2e/grpc/client.test.ts

@@ -37,7 +37,7 @@ describe('grpc/client', () => {
       // there is however a delay between the sidecar being ready and the app starting as they are started asynchronously
       // if Dapr has to connect to a component, it might introduce a delay
       // the test will thus randomly have isStarted = true or isStarted = false depending on the startup delay of the sidecar
-      await client.getDaprClient().isSidecarStarted();
+      await client.health.isHealthy();
       // expect(isStarted).toBe(false);
     })
   });

test/e2e/http/client.test.ts

@@ -39,7 +39,7 @@ describe('http/client', () => {
       // there is however a delay between the sidecar being ready and the app starting as they are started asynchronously
       // if Dapr has to connect to a component, it might introduce a delay
       // the test will thus randomly have isStarted = true or isStarted = false depending on the startup delay of the sidecar
-      await client.getDaprClient().isSidecarStarted();
+      await client.health.isHealthy();
       // expect(isStarted).toBe(false);
     })
   });