Updates

src/websocket/(utils)/grab-connected-websocket-user-data-index.ts

@@ -0,0 +1,17 @@
+import { User } from "@/src/types";
+
+type Params = {
+    user: User;
+};
+
+export default function grabConnectedWebsocketUserdataIndex({ user }: Params) {
+    const user_index = global.WEBSOCKET_CONNECTED_USERS_DATA.findIndex(
+        (u) => u.user.id == user.id,
+    );
+
+    if (typeof user_index == "number" && user_index >= 0) {
+        return user_index;
+    }
+
+    return undefined;
+}

src/websocket/(utils)/grab-connected-websocket-user-data.ts

@@ -0,0 +1,21 @@
+import { User } from "@/src/types";
+import grabConnectedWebsocketUserdataIndex from "./grab-connected-websocket-user-data-index";
+
+type Params = {
+    user: User;
+};
+
+export default function grabConnectedWebsocketUserdata({ user }: Params) {
+    const connected_user_data_index = grabConnectedWebsocketUserdataIndex({
+        user,
+    });
+
+    if (typeof connected_user_data_index !== "number") {
+        throw new Error(`User Connection Data not found!`);
+    }
+
+    const connected_user_data =
+        global.WEBSOCKET_CONNECTED_USERS_DATA[connected_user_data_index];
+
+    return connected_user_data;
+}

src/websocket/(utils)/kill-all-ttyd-ports.ts

@@ -0,0 +1,20 @@
+import { AppData } from "@/src/data/app-data";
+import { execSync, ExecSyncOptions } from "child_process";
+
+type Params = {
+    exec_options?: ExecSyncOptions;
+};
+
+export default async function killAllTtydPorts(params?: Params) {
+    const start_port = AppData["DynamicPortStart"];
+    const end_port = start_port + 100;
+    const kill_ports_cmd = `ss -tlnp | awk 'NR>1 {split($4, a, ":"); port=a[length(a)]; if (port >= ${start_port} && port <= ${end_port}) print $6}' | grep -oP 'pid=\\K[0-9]+' | xargs -r kill -9`;
+
+    execSync(kill_ports_cmd, {
+        ...params?.exec_options,
+    });
+}
+
+// sudo ss -tlnp | awk 'NR>1 {split($4, a, ":"); port=a[length(a)]; if (port >= 4700 && port <= 4800) print $6}' | grep -oP 'pid=\K[0-9]+' | xargs -r sudo kill -9
+
+// ss -tlnp | awk 'NR>1 {split($4, a, ":"); port=a[length(a)]; if (port >= 4700 && port <= 4800) print $6}' | grep -oP 'pid=\K[0-9]+' | xargs -r sudo kill -9

src/websocket/(utils)/kill-port.ts

@@ -0,0 +1,14 @@
+import { execSync, ExecSyncOptions } from "child_process";
+
+type Params = {
+    port: string | number;
+    exec_options?: ExecSyncOptions;
+};
+
+export default async function killPort({ port, exec_options }: Params) {
+    const kill_ports_cmd = `ss -tlnp | awk -v p=${port} 'NR>1 {split($4,a,":"); if(a[length(a)]==p) print $6}' | grep -oP 'pid=\K[0-9]+' | xargs -r kill -9`;
+
+    execSync(kill_ports_cmd, {
+        ...exec_options,
+    });
+}

src/websocket/events/client-kill-port.ts

@@ -0,0 +1,26 @@
+import { WebSocketMessageParam } from "@/src/types";
+import sendData from "../(utils)/send-data";
+import sendError from "../(utils)/send-error";
+import grabConnectedWebsocketUserdata from "../(utils)/grab-connected-websocket-user-data";
+
+export default async function socketClientKillPort({
+    ws,
+    data,
+}: WebSocketMessageParam) {
+    try {
+        const user = ws.data.user;
+        const service = data?.service;
+        const server = data?.server;
+        const port = data?.port;
+
+        const connected_user_data = grabConnectedWebsocketUserdata({ user });
+
+        console.log("connected_user_data", connected_user_data);
+
+        sendData(ws, {
+            event: "server:killed-port",
+        });
+    } catch (error: any) {
+        sendError(ws, "Service Server Logs Error! " + error.message);
+    }
+}

src/websocket/events/client-ping.ts

@@ -1,12 +1,18 @@
+import { WebSocketMessageParam } from "@/src/types";
 import sendData from "../(utils)/send-data";
 import sendError from "../(utils)/send-error";
-import { WebSocketMessageParam } from "../socket-message";
+import grabConnectedWebsocketUserdata from "../(utils)/grab-connected-websocket-user-data";
 
 export default async function socketClientPing({
     ws,
     data,
 }: WebSocketMessageParam) {
     try {
+        const user = ws.data.user;
+        const connected_user_data = grabConnectedWebsocketUserdata({ user });
+
+        console.log("connected_user_data", connected_user_data);
+
         sendData(ws, {
             event: "server:ping",
         });

src/websocket/events/client-service-server-logs.ts

@@ -0,0 +1,32 @@
+import { WebSocketMessageParam } from "@/src/types";
+import sendData from "../(utils)/send-data";
+import sendError from "../(utils)/send-error";
+import grabTtydServerInfo from "@/src/functions/ttyd/grab-ttyd-service-info";
+
+export default async function socketClientServiceServerLogs({
+    ws,
+    data,
+}: WebSocketMessageParam) {
+    try {
+        const user = ws.data.user;
+        const service = data?.service;
+        const server = data?.server;
+
+        const ttyd = await grabTtydServerInfo({
+            server,
+            service,
+            user,
+            paradigm: "logs",
+        });
+
+        console.log("ttyd", ttyd);
+
+        sendData(ws, {
+            event: "server:service-server-logs",
+            ttyd,
+            server,
+        });
+    } catch (error: any) {
+        sendError(ws, "Service Server Logs Error! " + error.message);
+    }
+}

src/websocket/index.ts

@@ -1,6 +1,14 @@
-import { WebSocketData } from "../types";
+import { WebSocketConnectedUserData, WebSocketData } from "../types";
+import socketClose from "./socket-close";
 import socketInit from "./socket-init";
 import socketMessage from "./socket-message";
+import socketOpen from "./socket-open";
+
+declare global {
+    var WEBSOCKET_CONNECTED_USERS_DATA: WebSocketConnectedUserData[];
+}
+
+global.WEBSOCKET_CONNECTED_USERS_DATA = [];
 
 const server = Bun.serve<WebSocketData>({
     async fetch(req, server) {
@@ -27,12 +35,10 @@ const server = Bun.serve<WebSocketData>({
             }
         },
         async open(ws) {
-            const user = ws.data.user;
-            console.log(`Web Socket Opened by ${user.first_name}`);
+            await socketOpen({ ws });
         },
         async close(ws, code, message) {
-            const user = ws.data.user;
-            console.log(`Socket Closed by ${user.first_name}`);
+            await socketClose({ ws });
         },
         idleTimeout: 600,
         maxPayloadLength: 1024 * 1024 * 10,

src/websocket/socket-close.ts

@@ -0,0 +1,33 @@
+import { ServerWebSocket } from "bun";
+import { WebSocketData } from "../types";
+import killAllTtydPorts from "./(utils)/kill-all-ttyd-ports";
+
+type Param = {
+    ws: ServerWebSocket<WebSocketData>;
+};
+
+export default async function socketClose({ ws }: Param) {
+    const user = ws.data.user;
+    console.log(`Web Socket Closed by ${user.first_name}`);
+
+    const existing_connected_user_data =
+        global.WEBSOCKET_CONNECTED_USERS_DATA.find((u) => u.user.id == user.id);
+
+    if (existing_connected_user_data) {
+        for (
+            let i = 0;
+            i < existing_connected_user_data.child_processes.length;
+            i++
+        ) {
+            const child_process =
+                existing_connected_user_data.child_processes[i];
+            child_process.kill();
+        }
+
+        existing_connected_user_data.child_processes = [];
+    }
+
+    killAllTtydPorts({
+        exec_options: { stdio: "inherit" },
+    });
+}

src/websocket/socket-message.ts

@@ -1,20 +1,20 @@
 import { ServerWebSocket } from "bun";
-import { WebSocketData, WebSocketDataType } from "../types";
+import {
+    WebSocketData,
+    WebSocketDataType,
+    WebSocketMessageParam,
+} from "../types";
 import { EJSON } from "../exports/client-exports";
 import socketClientPing from "./events/client-ping";
 import debugLog from "@moduletrace/datasquirel/dist/package-shared/utils/logging/debug-log";
+import socketClientServiceServerLogs from "./events/client-service-server-logs";
+import socketClientKillPort from "./events/client-kill-port";
 
 type Param = {
     ws: ServerWebSocket<WebSocketData>;
     message: string | Buffer;
 };
 
-export type WebSocketMessageParam = {
-    ws: ServerWebSocket<WebSocketData>;
-    message?: string | Buffer;
-    data?: WebSocketDataType;
-};
-
 export default async function socketMessage({ ws, message }: Param) {
     const user = ws.data.user;
     const data = EJSON.parse(message.toString()) as
@@ -39,6 +39,22 @@ export default async function socketMessage({ ws, message }: Param) {
             });
             await socketClientPing(websocketMessageParams);
             break;
+        case "client:service-server-logs":
+            debugLog({
+                log: `${userRef} Getting Service Server Logs ...`,
+                addTime: true,
+                label,
+            });
+            await socketClientServiceServerLogs(websocketMessageParams);
+            break;
+        case "client:kill-port":
+            debugLog({
+                log: `${userRef} Killing Port ${data.port} ...`,
+                addTime: true,
+                label,
+            });
+            await socketClientKillPort(websocketMessageParams);
+            break;
 
         default:
             break;

src/websocket/socket-open.ts

@@ -0,0 +1,22 @@
+import { ServerWebSocket } from "bun";
+import { WebSocketData } from "../types";
+
+type Param = {
+    ws: ServerWebSocket<WebSocketData>;
+};
+
+export default async function socketOpen({ ws }: Param) {
+    const user = ws.data.user;
+    console.log(`Web Socket Opened by ${user.first_name}`);
+
+    const existing_connected_user_data =
+        global.WEBSOCKET_CONNECTED_USERS_DATA.find((u) => u.user.id == user.id);
+
+    if (!existing_connected_user_data) {
+        global.WEBSOCKET_CONNECTED_USERS_DATA.push({
+            user,
+            child_processes: [],
+            ports: [],
+        });
+    }
+}