Monitoring: add logic to pick the available stack for a service

packages/monitoring/example/stackAvilablity.ts

@@ -0,0 +1,26 @@
+const gridproxy = ["test", "hello", "https://gridproxy.dev.grid.tf/"];
+const rmb = ["wsefews://tfin.dev.grid.tf/ws", "wss://relay.dev.grid.tf"];
+const graphql = ["https://graphql.dev.grid.tf/graphql"];
+const tfChain = ["wss://tfchain.dev.grid.tf/ws", "wsss://tfchain.dev.grid.tf/ws"];
+const mnemonic = "<MNEMONIC>";
+
+import { ServiceUrlManager, StackPickerOptions } from "../src";
+
+async function checkStacksAvailability(services: StackPickerOptions) {
+  try {
+    const pickedUrls = await new ServiceUrlManager(services).getAvailableServices();
+    await Promise.all(Object.values(pickedUrls));
+    console.log(pickedUrls);
+    process.exit(0);
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+checkStacksAvailability({
+  tfChain,
+  rmb,
+  graphql,
+  gridproxy,
+  mnemonic,
+});

packages/monitoring/package.json

@@ -3,11 +3,21 @@
   "version": "2.5.0",
   "description": "Threefold monitoring package",
   "license": "Apache-2.0",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/node/index.js",
+  "module": "./dist/es6/index.js",
+  "exports": {
+    "require": "./dist/node/index.js",
+    "import": "./dist/es6/index.js"
+  },
+  "types": "dist/es6/index.d.ts",
+  "files": [
+    "/dist"
+  ],
   "scripts": {
     "example": "yarn run ts-node --project tsconfig.json example/index.ts",
-    "build": "tsc",
+    "build": "npm-run-all es6-build node-build",
+    "node-build": "tsc --build tsconfig-node.json",
+    "es6-build": "tsc --build tsconfig-es6.json",
     "test": "jest "
   },
   "author": "Omar Kassem",
@@ -19,7 +29,6 @@
     "@threefold/rmb_direct_client": "2.5.0",
     "@threefold/tfchain_client": "2.5.0",
     "@threefold/types": "2.5.0",
-    "axios": "^0.27.2",
     "chalk": "4.1.2",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.3"

packages/monitoring/src/helpers/events.ts

@@ -17,21 +17,25 @@ class MonitorEventEmitter extends EventEmitter {
     this.addListener(MonitorEvents.storeStatus, this.addToServiceSummary);
     this.addListener(MonitorEvents.summarize, this.printStatusSummary);
   }
-  public log(message: string) {
-    this.emit("MonitorLog", message);
+  public log(message: string, color?: string) {
+    this.emit("MonitorLog", message, color);
   }
   public summarize() {
     this.emit("MonitorSummarize");
   }
   public storeStatus(serviceName: string, isAlive: boolean) {
     this.emit("MonitorStoreStatus", serviceName, isAlive);
   }
-  public serviceDown(serviceName: string, error: Error) {
+  public serviceDown(serviceName: string, error?: Error) {
     this.emit("MonitorServiceDown", serviceName, error);
   }
 
-  private monitorLogsHandler(msg) {
-    console.log(msg);
+  private monitorLogsHandler(msg: unknown, color?: string) {
+    if (color && chalk[color]) {
+      console.log(chalk[color](msg));
+    } else {
+      console.log(msg);
+    }
   }
   private serviceDownHandler(serviceName: string, error: Error) {
     console.log(`${chalk.red.bold(serviceName + " is Down")}`);

packages/monitoring/src/helpers/utils.ts

@@ -1,15 +1,13 @@
 import { RequestError } from "@threefold/types";
-import axios, { AxiosError, AxiosRequestConfig } from "axios";
-import { ServiceStatus } from "src/types";
 
-export async function sendGetRequest(url: string, options: AxiosRequestConfig = {}) {
+import { ServiceStatus } from "../types";
+
+export async function sendRequest(url: string, options: RequestInit) {
   try {
-    return await axios.get(url, options);
+    const res = await fetch(url, options);
+    if (!res?.ok) throw Error(`HTTP Response Code: ${res?.status}`);
   } catch (e) {
-    const { response } = e as AxiosError;
-    const errorMessage = (response?.data as { error: string })?.error || (e as Error).message;
-
-    throw new RequestError(`HTTP request failed ${errorMessage ? "due to " + errorMessage : ""}.`);
+    throw new RequestError(`HTTP request failed due to  ${e}.`);
   }
 }
 

packages/monitoring/src/index.ts

@@ -1 +1,2 @@
 export * from "./serviceMonitor/index";
+export * from "./types";

packages/monitoring/src/serviceMonitor/activation.ts

@@ -0,0 +1,22 @@
+import { resolveServiceStatus, sendRequest } from "../helpers/utils";
+import { ILivenessChecker, ServiceStatus } from "../types";
+
+export class Activation implements ILivenessChecker {
+  private readonly name = "Activation";
+  private url: string;
+  constructor(activationServiceUrl: string) {
+    this.url = activationServiceUrl;
+  }
+  serviceName() {
+    return this.name;
+  }
+  serviceUrl() {
+    return this.url;
+  }
+  updateUrl(url: string) {
+    this.url = url;
+  }
+  async isAlive(): Promise<ServiceStatus> {
+    return resolveServiceStatus(sendRequest(this.url, { method: "Get" }));
+  }
+}

packages/monitoring/src/serviceMonitor/alivenessChecker.ts

@@ -1,5 +1,20 @@
+import { KeypairType } from "@polkadot/util-crypto/types";
+
 import { monitorEvents } from "../helpers/events";
-import { IDisconnectHandler, ILivenessChecker } from "../types";
+import {
+  IDisconnectHandler,
+  ILivenessChecker,
+  ServiceName,
+  ServicesUrls,
+  ServiceUrl,
+  StackPickerOptions,
+} from "../types";
+import { Activation } from "./activation";
+import { GraphQLMonitor } from "./graphql";
+import { GridProxyMonitor } from "./gridproxy";
+import { RMBMonitor } from "./rmb";
+import { Stats } from "./stats";
+import { TFChainMonitor } from "./tfChain";
 
 /**
  * Represents a service monitor that periodically checks the liveness of multiple services.
@@ -77,3 +92,209 @@ export class ServiceMonitor {
     await this.disconnect();
   }
 }
+
+/**
+ * Manages service URLs, checking their availability and ensuring they are reachable.
+ *
+ * @property {number} retries - Number of retry attempts for each URL.
+ * @property {string[]} [ServiceName.tfChain] - URLs for tfChain service.
+ * @property {string[]} [ServiceName.GraphQl] - URLs for GraphQL service.
+ * @property {string[]} [ServiceName.RMB] - URLs for RMB service.
+ * @property {string[]} [ServiceName.GridPrixy] - URLs for GridProxy service.
+ * @property {string[]} [ServiceName.Stats] - URLs for stats service.
+ * @property {string[]} [ServiceName.Activation] - URLs for activation service.
+ * @property {string} [mnemonic] - Mnemonic required for RMB service.
+ * @property {KeypairType} keypairType - Type of keypair, default is "sr25519".
+ * @property {boolean} rmbValidatesChain - Indicates if RMB will validate the chain url.
+ * @property {string[]} rmbTFchainUrls - URLs of TFChain for RMB service, Required in case there is no TFChain urls for tfChain service.
+ * If there is a tfChain availability service provided, and it's result is valid, we will ignore the rmb-tfChain options
+ * @property {boolean} silent - To return null instead of throw an Error, Default is False
+ */
+export class ServiceUrlManager<N extends boolean = false> {
+  private result: ServicesUrls<N> = {};
+  private retries = 3;
+  private [ServiceName.tfChain]?: string[];
+  private [ServiceName.GraphQl]?: string[];
+  private [ServiceName.RMB]?: string[];
+  private [ServiceName.GridPrixy]?: string[];
+  private [ServiceName.Activation]?: string[];
+  private [ServiceName.Stats]?: string[];
+  private mnemonic?: string;
+  private keypairType: KeypairType = "sr25519";
+  private rmbValidatesChain = false;
+  private rmbTFchainUrls: string[];
+  private silent: N = false as N;
+
+  constructor(options?: StackPickerOptions<N>) {
+    Object.assign(this, options);
+  }
+
+  /**
+   * Pings the given service to check if it is alive.
+   *
+   * This method checks the liveness of the provided service by calling its `isAlive` method.
+   * If the service supports disconnection (implements IDisconnectHandler), it calls the `disconnect` method after the liveness check.
+   *
+   * @param {ILivenessChecker} service - An instance of ILivenessChecker that provides methods to check the service's liveness.
+   *
+   * @returns {Promise<{alive: boolean, error?: Error}>} - A promise that resolves with the liveness status of the service.
+   */
+  private async pingService(service: ILivenessChecker) {
+    const status = await service.isAlive();
+    if ("disconnect" in service) {
+      await (service as IDisconnectHandler).disconnect();
+    }
+    return status;
+  }
+
+  /**
+   * Attempts to find a reachable service URL from a list of provided URLs.
+   *
+   * This method iterates through the list of URLs, repeatedly pinging the service to
+   * check if it is alive. If a reachable URL is found, it is returned. If all URLs
+   * are exhausted without finding a reachable service, an error is thrown.
+   *
+   * @param {string[]} urls - An array of service URLs to check for reachability.
+   * @param {ILivenessChecker} service - An instance of ILivenessChecker that provides methods
+   * to check the service's liveness and manage service URLs.
+   *
+   * @returns {Promise<string>} - A promise that resolves with the reachable service URL.
+   *
+   * @throws {Error} - Throws an error if no reachable service URL is found after checking all URLs.
+   *
+   */
+  async getAvailableServiceStack(urls: string[], service: ILivenessChecker): Promise<ServiceUrl<N>> {
+    let error: Error | string = "";
+    for (let i = 0; i < urls.length; i++) {
+      if (i != 0) await service.updateUrl(urls[i]);
+      monitorEvents.log(`${service.serviceName()}: pinging ${service.serviceUrl()}`, "gray");
+      for (let retry = 0; retry < this.retries; retry++) {
+        const status = await this.pingService(service);
+        if (status.alive) {
+          monitorEvents.log(`${service.serviceName()} on ${service.serviceUrl()} Success!`, "green");
+          return service.serviceUrl();
+        }
+        error = status.error ?? "";
+      }
+      monitorEvents.log(
+        `${service.serviceName()}: failed to ping ${service.serviceUrl()} after ${this.retries} retries; ${error}`,
+        "red",
+      );
+    }
+    if (this.silent) return null as any;
+    throw new Error(` Failed to reach ${service.serviceName()} on all provided stacks`);
+  }
+
+  /**
+   * Fetches available service URLs for tfChain and RMB services.
+   *
+   * This method checks the availability of URLs for services by utilizing
+   * the `getAvailableServiceStack` method. It updates the `result` property with the reachable URLs.
+   *
+   * @returns {Promise<ServicesUrls>} - A promise that resolves with an object containing the available service URLs.
+   */
+  async getAvailableServices(): Promise<ServicesUrls<N>> {
+    const result: any = {};
+
+    if (this[ServiceName.GraphQl]) {
+      if (this[ServiceName.GraphQl]?.length == 0)
+        result[ServiceName.GraphQl] = this.handleSilent(
+          "Can't validate GraphQL stacks; There is GraphQL urls provided",
+        );
+      else {
+        result[ServiceName.GraphQl] = this.getAvailableServiceStack(
+          this[ServiceName.GraphQl],
+          new GraphQLMonitor(this[ServiceName.GraphQl][0]),
+        );
+      }
+    }
+
+    if (this[ServiceName.GridPrixy]) {
+      if (this[ServiceName.GridPrixy]?.length == 0) {
+        result[ServiceName.GridPrixy] = this.handleSilent(
+          "Can't validate GridProxy stacks; There is GridProxy urls provided",
+        );
+      } else {
+        result[ServiceName.GridPrixy] = this.getAvailableServiceStack(
+          this[ServiceName.GridPrixy],
+          new GridProxyMonitor(this[ServiceName.GridPrixy][0]),
+        );
+      }
+    }
+
+    if (this[ServiceName.Stats]) {
+      if (this[ServiceName.Stats]?.length == 0) {
+        result[ServiceName.Stats] = this.handleSilent("Can't validate Stats stacks; There is Stats urls provided");
+      } else {
+        result[ServiceName.Stats] = this.getAvailableServiceStack(
+          this[ServiceName.Stats],
+          new Stats(this[ServiceName.Stats][0]),
+        );
+      }
+    }
+
+    if (this[ServiceName.Activation]) {
+      if (this[ServiceName.Activation]?.length == 0) {
+        result[ServiceName.Activation] = this.handleSilent(
+          "Can't validate Activation stacks; There is Activation urls provided",
+        );
+      } else {
+        result[ServiceName.Activation] = this.getAvailableServiceStack(
+          this[ServiceName.Activation],
+          new Activation(this[ServiceName.Activation][0]),
+        );
+      }
+    }
+
+    if (this[ServiceName.tfChain]) {
+      if (this[ServiceName.tfChain]?.length == 0) {
+        result[ServiceName.tfChain] = this.handleSilent(
+          "Can't validate tfChain stacks; There is tfChain urls provided",
+        );
+      } else {
+        result[ServiceName.tfChain] = this.getAvailableServiceStack(
+          this[ServiceName.tfChain],
+          new TFChainMonitor(this[ServiceName.tfChain][0]),
+        );
+      }
+    }
+
+    if (this[ServiceName.RMB])
+      result[ServiceName.RMB] = this.validateRMBStacks(this[ServiceName.RMB], this.result?.tfChain);
+
+    const entries = Object.entries(result);
+    const values = await Promise.all(entries.map(r => r[1]));
+    for (let i = 0; i < entries.length; i++) this.result[entries[i][0]] = values[i];
+    return this.result;
+  }
+
+  private handleSilent(errorMsg: string) {
+    if (this.silent) {
+      console.log(errorMsg);
+      return null;
+    }
+    throw new Error(errorMsg);
+  }
+
+  private async validateRMBStacks(rmbUrls: string[], validatedChainUrl?: ServiceUrl<N> | undefined) {
+    if (!this.mnemonic) return this.handleSilent("Failed to validate RMB, Mnemonic is required");
+
+    let chainUrl: ServiceUrl<N> | undefined = undefined;
+    if (rmbUrls.length == 0) return this.handleSilent("Can't validate RMB stacks; There is RMB urls provided");
+    if (!validatedChainUrl && (!this.rmbTFchainUrls || this.rmbTFchainUrls.length == 0))
+      return this.handleSilent("Can't validate RMB urls; There is no Chain urls provided");
+
+    // chain Url
+    if (validatedChainUrl) chainUrl = validatedChainUrl;
+    else
+      chainUrl = this.rmbValidatesChain
+        ? await this.getAvailableServiceStack(this.rmbTFchainUrls, new TFChainMonitor(this.rmbTFchainUrls[0]))
+        : this.rmbTFchainUrls[0];
+    if (!chainUrl) return this.handleSilent("Failed to validate RMB, there is no available valid Chain url");
+
+    return this.getAvailableServiceStack(
+      rmbUrls,
+      new RMBMonitor(rmbUrls[0], chainUrl, this.mnemonic!, this.keypairType),
+    );
+  }
+}