@phystack/hub-client 4.4.29

package/src/services/online-status-subscription.service.ts

@@ -0,0 +1,127 @@
+import axios from 'axios';
+const url = 'https://screen.omborigrid.com/is-online.json';
+const getUrl = () => `${url}?r=${Math.random()}`;
+
+interface OnlineSubscriptionOptions {
+  checkIntervalMs: number;
+  checkIntervalMsWhenOfflineMs: number;
+}
+
+const defaultOptions = {
+  checkIntervalMs: 30 * 1000,
+  checkIntervalMsWhenOfflineMs: 10 * 1000,
+};
+
+type OnlineStatusSubscriptionListener = (props: GetOnlineStatusRequestResponse) => void;
+
+type GetOnlineStatusRequestResponse = {
+  isOnline: boolean;
+  message?: string;
+};
+
+export const getOnlineStatusRequest = (timeoutMs: number) => {
+  return new Promise<GetOnlineStatusRequestResponse>((resolve, _reject) => {
+    const requestTimeout = setTimeout(
+      () =>
+        resolve({
+          isOnline: false,
+          message: 'manual promise timeout',
+        }),
+      timeoutMs
+    );
+
+    axios
+      .get(getUrl())
+      .then(response => {
+        resolve({
+          isOnline: response.data.isOnline,
+          message: 'ping success',
+        });
+      })
+      .catch(err =>
+        resolve({
+          isOnline: false,
+          message: `ping error, ${err.message}`,
+        })
+      )
+      .finally(() => clearTimeout(requestTimeout));
+  });
+};
+
+class OnlineStatusSubscription {
+  private onlineCheckTimeout: NodeJS.Timeout | undefined;
+  private readonly options: OnlineSubscriptionOptions;
+  private activatedAt: number | null = null;
+  private listeners: OnlineStatusSubscriptionListener[] = [];
+
+  public isOnline: boolean | null = null;
+
+  constructor(options?: Partial<OnlineSubscriptionOptions> | undefined) {
+    this.options = { ...defaultOptions, ...options };
+  }
+
+  private getPollingIntervalDuration = () => {
+    return this.isOnline ? this.options.checkIntervalMs : this.options.checkIntervalMsWhenOfflineMs;
+  };
+
+  private getOnlineStatus = () => {
+    const timeout = this.getPollingIntervalDuration() - 1;
+    return getOnlineStatusRequest(timeout);
+  };
+
+  private pollOnlineStatus = () => {
+    const startActivatedAt = this.activatedAt;
+    this.getOnlineStatus()
+      .then(({ isOnline, message }) => {
+        if (this.activatedAt && startActivatedAt === this.activatedAt) {
+          if (this.isOnline !== isOnline) {
+            this.isOnline = isOnline;
+            this.emit({ isOnline, message });
+          }
+        }
+      })
+      .catch(err => {
+        // this is not expected, there should be no error from the function
+        console.error(`Error getting online status: ${err}`);
+      })
+      .finally(() => {
+        if (this.activatedAt && startActivatedAt === this.activatedAt) {
+          this.onlineCheckTimeout = setTimeout(
+            this.pollOnlineStatus,
+            this.getPollingIntervalDuration()
+          );
+        }
+      });
+  };
+
+  public start = () => {
+    if (!this.activatedAt) {
+      this.activatedAt = Date.now();
+      this.pollOnlineStatus();
+    }
+  };
+
+  public stop = () => {
+    if (this.onlineCheckTimeout) {
+      clearTimeout(this.onlineCheckTimeout);
+    }
+    this.activatedAt = null;
+  };
+
+  private emit = (props: GetOnlineStatusRequestResponse) => {
+    for (const listener of this.listeners) {
+      listener(props);
+    }
+  };
+
+  public subscribe = (listener: OnlineStatusSubscriptionListener) => {
+    this.listeners = this.listeners.concat([listener]);
+    return () => this.unsubscribe(listener);
+  };
+
+  public unsubscribe = (listener: OnlineStatusSubscriptionListener) => {
+    this.listeners = this.listeners.filter(activeListener => activeListener !== listener);
+  };
+}
+
+export default OnlineStatusSubscription;

package/src/services/phyhub-connection.service.ts

@@ -0,0 +1,213 @@
+import { Socket } from 'socket.io-client';
+import { get } from 'lodash';
+import { isBrowser } from '../helpers/browser.helper';
+import { getSocketIOWithProxy } from '@phystack/socket.io-proxy';
+interface UrlConfig {
+  url: string;
+  timeout: number;
+  options: Record<string, any>;
+}
+
+export class PhyHubConnection {
+  private static instance: PhyHubConnection | null = null;
+  private phygridSocketSingleton: Socket | null = null;
+  private socketUrls: UrlConfig[] = [];
+  private instanceId: string | undefined;
+  private moduleName: string | undefined;
+
+  private constructor(
+    params: { instanceId?: string; moduleName?: string; dataResidency?: string } = {}
+  ) {
+    this.instanceId = params.instanceId;
+    this.moduleName = params.moduleName;
+    this.setSocketUrls(params.dataResidency);
+    this.fetchPhygridSocketInstance();
+  }
+
+  private getTopWindow(): Window & typeof globalThis {
+    let topWindow: Window & typeof globalThis = window;
+    while (topWindow.parent !== topWindow) {
+      try {
+        topWindow = topWindow.parent as Window & typeof globalThis;
+      } catch (e) {
+        break;
+      }
+    }
+    return topWindow;
+  }
+
+  private fetchPhygridSocketInstance = () => {
+    if (isBrowser) {
+      const topWindow = this.getTopWindow();
+      if ((topWindow as any).edgeHub) {
+        this.phygridSocketSingleton = (topWindow as any).edgeHub;
+      } else if ((topWindow as any).phygridSocketSingleton) {
+        this.phygridSocketSingleton = (topWindow as any).phygridSocketSingleton;
+      }
+    }
+  };
+
+  private setSocketUrls(dataResidency: string | undefined = undefined): void {
+    // Todo this should be resolved once phyos resolves to correct ip
+    if (!isBrowser) {
+      this.socketUrls = [{ url: `http://phyos:55000`, timeout: 5000, options: {} }];
+    } else {
+      this.socketUrls.push({ url: 'https://phyos:55500', timeout: 5000, options: {} });
+      // if (dataResidency !== undefined) { // TOOD: tmp disabled since we will need this in mobile apps later
+      this.socketUrls.push({
+        url: `https://phyhub.${dataResidency || 'eu'}.omborigrid.net:443`,
+        timeout: 10000,
+        options: {},
+      });
+      // }
+    }
+    console.log('socketUrls', this.socketUrls);
+  }
+
+  private async getSocketIoInstance(): Promise<Socket> {
+    while (true) {
+      // Keep trying until we connect or explicitly throw
+      for (const { url, timeout, options } of this.socketUrls) {
+        let socket: Socket | null = null;
+        try {
+          console.info(`Attempting to connect to ${url}...`);
+          const auth = { instanceId: this.instanceId, moduleName: this.moduleName };
+          socket = await getSocketIOWithProxy(url, {
+            ...options,
+            auth,
+            reconnectionAttempts: 1,
+            timeout: timeout,
+            debug: true,
+          });
+
+          // Wait for the connection to be established
+          await new Promise((resolve, reject) => {
+            socket!.on('connect', () => {
+              console.info(`Successfully connected to ${url}`);
+              resolve(true);
+            });
+
+            socket!.on('connect_error', error => {
+              console.info(`Failed to connect to ${url}: ${error.message}`);
+              reject(error);
+            });
+
+            // Add timeout for the connection attempt
+            setTimeout(() => {
+              reject(new Error(`Connection timeout to ${url}`));
+            }, timeout);
+          });
+
+          // If we get here, the connection was successful
+          return socket; // Exit both the loop and the while(true)
+        } catch (error) {
+          // console.info(`Failed to connect to ${url}. Trying next option...`);
+          // Cleanup the failed socket
+          try {
+            socket?.disconnect();
+          } catch (e) {
+            // Ignore cleanup errors
+          }
+        }
+      }
+      // console.info('Failed to connect to any socket.io server. Retrying in 1 second...');
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+
+  public static getInstance(
+    params: { instanceId?: string; moduleName?: string; dataResidency?: string } = {}
+  ): PhyHubConnection {
+    if (!PhyHubConnection.instance) {
+      PhyHubConnection.instance = new PhyHubConnection(params);
+    } else if (
+      (params.instanceId && PhyHubConnection.instance.instanceId !== params.instanceId) ||
+      (params.moduleName && PhyHubConnection.instance.moduleName !== params.moduleName)
+    ) {
+      // Update instance parameters if they are different
+      PhyHubConnection.instance.instanceId = params.instanceId;
+      PhyHubConnection.instance.moduleName = params.moduleName;
+      if (params.dataResidency) {
+        PhyHubConnection.instance.setSocketUrls(params.dataResidency);
+      }
+    }
+    return PhyHubConnection.instance;
+  }
+
+  public async getPhyHubSocket(): Promise<Socket> {
+    console.info(`getPhyHubSocket(): Getting phyhub socket`);
+
+    // Always check top window first
+    if (isBrowser) {
+      const topWindow = this.getTopWindow();
+      console.log('Checking for edgeHub in top window...', {
+        hasEdgeHub: !!(topWindow as any).edgeHub,
+        hasPhygridSocket: !!(topWindow as any).phygridSocketSingleton,
+      });
+
+      if ((topWindow as any).edgeHub) {
+        console.log('Found edgeHub in top window, using it instead of creating new connection');
+        this.phygridSocketSingleton = (topWindow as any).edgeHub;
+        if (this.phygridSocketSingleton) {
+          console.log('Successfully initialized edgeHub socket');
+          return this.phygridSocketSingleton;
+        }
+      }
+      if ((topWindow as any).phygridSocketSingleton) {
+        console.log('Found existing socket in top window, reusing it');
+        this.phygridSocketSingleton = (topWindow as any).phygridSocketSingleton;
+        if (this.phygridSocketSingleton) {
+          console.log('Successfully initialized existing socket');
+          return this.phygridSocketSingleton;
+        }
+      }
+    }
+
+    // Only proceed with new connection if we haven't found an existing one
+    if (!this.phygridSocketSingleton) {
+      console.log('No existing socket found, creating new connection...');
+      while (true) {
+        try {
+          const tmpSocket = await this.getSocketIoInstance();
+          const PHYHUB_URL = get(tmpSocket, 'io.uri', false);
+          tmpSocket.disconnect();
+
+          if (PHYHUB_URL) {
+            const { instanceId, moduleName } = this;
+            console.log('PHYHUB_URL', PHYHUB_URL);
+            const auth = { instanceId, moduleName };
+            console.log('auth', JSON.stringify(auth, null, 2));
+            const socket = await getSocketIOWithProxy(PHYHUB_URL, {
+              auth,
+            });
+
+            await new Promise((resolve, reject) => {
+              socket.on('connect', () => {
+                console.info(`Successfully connected to final socket at ${PHYHUB_URL}`);
+                if (isBrowser) {
+                  // Store in top window immediately upon successful connection
+                  const topWindow = this.getTopWindow();
+                  (topWindow as any).phygridSocketSingleton = socket;
+                }
+                this.phygridSocketSingleton = socket;
+                resolve(true);
+              });
+
+              socket.on('connect_error', error => {
+                this.phygridSocketSingleton = null;
+                reject(error);
+              });
+            });
+
+            break; // Connection successful
+          }
+        } catch (error) {
+          console.error('Failed to connect to PhyHub', error);
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+      }
+    }
+
+    return this.phygridSocketSingleton as Socket;
+  }
+}