constructor()

in tools/awps-tunnel/server/dataHub.ts [26:117]
85 lines of code
4 McCabe index (conditional complexity)

  constructor(server: http.Server, private tunnel: HttpServerProxy, upstreamUrl: URL, dbFile: string) {
    const io = (this.io = new Server(server));
    printer.log("Webview client connecting to get the latest status");
    this.repo = new DataRepo(dbFile);
    this.endpoint = tunnel.endpoint;
    this.livetraceUrl = tunnel.getLiveTraceUrl();
    this.hub = tunnel.hub;
    this.upstreamServerUrl = upstreamUrl.toString();
    // Socket.io event handling
    io.on("connection", (socket: Socket) => {
      printer.log("A webview client connected");

      socket.on("startEmbeddedUpstream", async (callback) => {
        if (DataHub.upstreamServer) {
          const message = "Built-in Echo Server already started";
          printer.status(`[Upstream] ${message}`);
          callback({ success: true, message: message });
          return;
        }
        const url = new URL(upstreamUrl);
        try {
          DataHub.upstreamServer = await startUpstreamServer(Number.parseInt(url.port), tunnel.hub, "/eventHandler");
          this.io.emit("reportBuiltinUpstreamServerStarted", DataHub.upstreamServer !== undefined);
          const message = "Built-in Echo Server started at port " + url.port;
          printer.status(`[Upstream] ${message}`);
          callback({ success: true, message: message });
        } catch (err) {
          const message = `Built-in Echo Server failed to start at port ${url.port}:${err}`;
          this.io.emit("reportBuiltinUpstreamServerStarted", DataHub.upstreamServer !== undefined);
          printer.error(`[Upstream] ${message}`);
          callback({ success: true, message: message });
        }
      });

      socket.on("stopEmbeddedUpstream", (callback) => {
        try {
          DataHub.upstreamServer?.close();
          DataHub.upstreamServer = undefined;
          const message = `Built-in Echo Server successfully stopped`;
          this.io.emit("reportBuiltinUpstreamServerStarted", DataHub.upstreamServer !== undefined);
          printer.status(`[Upstream] ${message}`);
          callback({ success: true, message: message });
        } catch (err) {
          const message = `Built-in Echo Server failed to stop:${err}`;
          this.io.emit("reportBuiltinUpstreamServerStarted", DataHub.upstreamServer !== undefined);
          printer.error(`[Upstream] ${message}`);
          callback({ success: true, message: message });
        }
      });

      socket.on("getCurrentModel", async (callback) => {
        callback({
          ready: true,
          state: {
            endpoint: this.endpoint,
            hub: this.hub,
            clientUrl: await this.GetClientAccessUrl(),
            liveTraceUrl: this.livetraceUrl,
            upstreamServerUrl: this.upstreamServerUrl,
            tunnelConnectionStatus: this.tunnelConnectionStatus,
            tunnelServerStatus: this.tunnelServerStatus,
            serviceConfiguration: this.serviceConfiguration,
            builtinUpstreamServerStarted: DataHub.upstreamServer !== undefined,
          },
          trafficHistory: await this.getHttpHistory(),
          logs: [],
        });
      });

      socket.on("getClientAccessUrl", async (userId: string, roles: string[], groups: string[], callback) => {
        const url = await this.GetClientAccessUrl(userId, roles, groups);
        callback(url);
      });

      socket.on("generateLiveTraceToken", async (callback) => {
        const token = await this.tunnel.getLiveTraceToken();
        callback(token);
      });
      socket.on("getRestApiToken", async (url, callback) => {
        const token = await this.tunnel.getRestApiToken(url);
        callback(token);
      });
      socket.on("disconnect", () => {
        printer.log("A webview client connected");
      });

      socket.on("clearTrafficHistory", async () => {
        await this.repo.clearDataAsync();
        this.io.emit("clearTraffic");
      });
    });
  }