wispjs 2.2.0 → 2.3.4

package/dist/wisp_socket/index.d.ts

@@ -88,20 +88,22 @@ export declare class WispSocket {
      * Performs a git pull operation on the given directory
      *
      * @param dir The full directory path to perform a pull on
+     * @param timeout In milliseconds, how long to wait before timing out
      *
      * @public
      */
-    gitPull(dir: string, useAuth?: boolean): Promise<any>;
+    gitPull(dir: string, useAuth?: boolean, timeout?: number): Promise<any>;
     /**
      * Clones a new Repo to the given directory
      *
      * @param url The HTTPS URL of the repository
      * @param dir The full path of the directory to clone the repository to
      * @param branch The branch of the repository to clone
+     * @param timeout In milliseconds, how long to wait before timing out
      *
      * @public
      */
-    gitClone(url: string, dir: string, branch: string): Promise<any>;
+    gitClone(url: string, dir: string, branch: string, timeout?: number): Promise<any>;
     /**
      * Sets up the console listener worker
      *
@@ -154,7 +156,7 @@ export declare class WispSocket {
      *
      * @param nonce The short, unique string that your output will be prefixed with
      * @param command The full command string to send
-     * @param timeout How long to wait for output before timing out
+     * @param timeout In milliseconds, how long to wait for output before timing out
      *
      * @public
      */

package/dist/wisp_socket/index.js

@@ -118,10 +118,11 @@ export class WispSocket {
      * Performs a git pull operation on the given directory
      *
      * @param dir The full directory path to perform a pull on
+     * @param timeout In milliseconds, how long to wait before timing out
      *
      * @public
      */
-    async gitPull(dir, useAuth = false) {
+    async gitPull(dir, useAuth = false, timeout = 10000) {
         await this.verifyPool();
         const pullResult = await this.pool.run((worker) => {
             const socket = worker.socket;
@@ -129,7 +130,12 @@ export class WispSocket {
             logger.log("Running gitPull:", dir);
             return new Promise((resolve, reject) => {
                 let isPrivate = false;
-                const finished = (success, output) => {
+                let finished;
+                const timeoutObj = setTimeout(() => {
+                    logger.error("Rejected gitPull: 'Timeout'");
+                    finished(false, "Timeout");
+                }, timeout);
+                finished = (success, output) => {
                     socket.removeAllListeners("git-pull");
                     socket.removeAllListeners("git-error");
                     socket.removeAllListeners("git-success");
@@ -144,6 +150,7 @@ export class WispSocket {
                         logger.error("Rejected gitPull:", dir, output);
                         reject(output);
                     }
+                    clearTimeout(timeoutObj);
                 };
                 const sendRequest = (includeAuth = false) => {
                     const data = { dir: dir };
@@ -188,10 +195,11 @@ export class WispSocket {
      * @param url The HTTPS URL of the repository
      * @param dir The full path of the directory to clone the repository to
      * @param branch The branch of the repository to clone
+     * @param timeout In milliseconds, how long to wait before timing out
      *
      * @public
      */
-    async gitClone(url, dir, branch) {
+    async gitClone(url, dir, branch, timeout = 20000) {
         await this.verifyPool();
         return await this.pool.run((worker) => {
             const socket = worker.socket;
@@ -199,7 +207,12 @@ export class WispSocket {
             logger.log("Running gitClone:", url, dir, branch);
             return new Promise((resolve, reject) => {
                 let isPrivate = false;
-                const finished = (success, message) => {
+                let finished;
+                const timeoutObj = setTimeout(() => {
+                    logger.error("Rejected gitClone: 'Timeout'");
+                    finished(false, "Timeout");
+                }, timeout);
+                finished = (success, message) => {
                     socket.removeAllListeners("git-clone");
                     socket.removeAllListeners("git-error");
                     socket.removeAllListeners("git-success");
@@ -213,6 +226,7 @@ export class WispSocket {
                         logger.error("Rejected gitClone:", url, dir, branch, message);
                         reject(message);
                     }
+                    clearTimeout(timeoutObj);
                 };
                 const sendRequest = (includeAuth = false) => {
                     const data = { dir: dir, url: url, branch: branch };
@@ -333,7 +347,7 @@ export class WispSocket {
      *
      * @param nonce The short, unique string that your output will be prefixed with
      * @param command The full command string to send
-     * @param timeout How long to wait for output before timing out
+     * @param timeout In milliseconds, how long to wait for output before timing out
      *
      * @public
      */

package/dist/wisp_socket/pool.d.ts

@@ -1,4 +1,9 @@
 import { Socket } from "socket.io-client";
+type Logger = {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+};
 /**
  * The struct used to define the events that can be sent from the server to the client
  *
@@ -133,10 +138,8 @@ interface PoolWorker {
     idx: number;
     token: string;
     ready: boolean;
-    logger: {
-        log(...args: any[]): void;
-        error(...args: any[]): void;
-    };
+    done: boolean;
+    logger: Logger;
 }
 /**
  * A single Worker within a {@link WebsocketPool}
@@ -147,10 +150,9 @@ interface PoolWorker {
  */
 declare class PoolWorker {
     constructor(pool: WebsocketPool);
-    available(): boolean;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    run(work: (worker: PoolWorker) => Promise<any>): Promise<any>;
+    private processWork;
 }
 /**
  * Struct used to manage a pool of WebSocket workers
@@ -160,6 +162,7 @@ export interface WebsocketPool {
     token: string;
     url: string;
     maxWorkers: number;
+    logger: Logger;
     queue: ((worker: PoolWorker) => Promise<any>)[];
 }
 /**
@@ -175,9 +178,8 @@ export interface WebsocketPool {
  */
 export declare class WebsocketPool {
     constructor(url: string, token: string);
-    createWorker(): Promise<PoolWorker>;
+    getWork(): ((worker: PoolWorker) => Promise<any>) | undefined;
     disconnect(): Promise<void>;
-    processQueue(): Promise<any>;
     run(work: (worker: PoolWorker) => Promise<any>): Promise<any>;
 }
 export {};

package/dist/wisp_socket/pool.js

@@ -1,4 +1,5 @@
 import { io } from "socket.io-client";
+const WISP_DEBUG = process.env.WISP_DEBUG === "true";
 /**
  * A single Worker within a {@link WebsocketPool}
  *
@@ -10,6 +11,7 @@ class PoolWorker {
     constructor(pool) {
         this.pool = pool;
         this.ready = false;
+        this.done = false;
         this.idx = pool.workers.length;
         this.token = pool.token;
         this.socket = io(pool.url, {
@@ -22,10 +24,13 @@ class PoolWorker {
         this.logger = {
             log: (...args) => console.log(logPrefix, args),
             error: (...args) => console.error(logPrefix, args),
+            debug: (...args) => {
+                if (!WISP_DEBUG)
+                    return;
+                console.debug(logPrefix, args);
+            }
         };
-    }
-    available() {
-        return this.ready && this.socket.connected;
+        this.connect().then(() => this.processWork()).catch(err => this.logger.error(err));
     }
     connect() {
         const socket = this.socket;
@@ -33,12 +38,9 @@ class PoolWorker {
         socket.onAnyOutgoing(this.logger.log);
         logger.log("Connecting to websocket...");
         return new Promise((resolve, reject) => {
-            let connectedOnce = false;
             const timeout = setTimeout(() => {
-                if (!connectedOnce) {
-                    logger.error("Socket didn't connect in time");
-                    reject("Connection Timeout");
-                }
+                logger.error("Socket didn't connect in time");
+                reject("Connection Timeout");
             }, 10000);
             socket.on("connect", () => {
                 logger.log("Connected to WebSocket");
@@ -50,23 +52,18 @@ class PoolWorker {
             });
             socket.on("connect_error", (error) => {
                 logger.error(`WebSocket Connect error: ${error.toString()}`);
-                if (!connectedOnce) {
-                    connectedOnce = true;
-                    clearTimeout(timeout);
-                    reject(`Connection error: ${error.toString()}`);
-                }
+                this.done = true;
+                clearTimeout(timeout);
+                reject(`Connection error: ${error.toString()}`);
             });
             socket.on("disconnect", (reason) => {
                 logger.log(`Disconnected from WebSocket: ${reason}`);
             });
             socket.on("auth_success", () => {
                 logger.log("Auth success");
-                if (!connectedOnce) {
-                    connectedOnce = true;
-                    this.ready = true;
-                    clearTimeout(timeout);
-                    resolve();
-                }
+                this.ready = true;
+                clearTimeout(timeout);
+                resolve();
             });
             socket.connect();
         });
@@ -79,25 +76,38 @@ class PoolWorker {
                 reject();
             }, 5000);
             this.socket.once("disconnect", () => {
+                this.done = true;
                 clearTimeout(timeout);
                 resolve();
             });
             this.socket.disconnect();
         });
     }
-    async run(work) {
-        this.ready = false;
-        // TODO: Verify that a finally is what we want here
-        try {
-            return await work(this);
-        }
-        catch (e) {
-            this.logger.error(e);
-            throw e;
-        }
-        finally {
-            this.ready = true;
-            this.pool.processQueue();
+    async processWork() {
+        while (!this.done) {
+            if (!this.ready) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+                continue;
+            }
+            const work = this.pool.getWork();
+            if (work) {
+                this.ready = false;
+                try {
+                    this.logger.debug("Running my work");
+                    await work(this);
+                    this.logger.debug("Done with my work, ready for more");
+                }
+                catch (e) {
+                    this.logger.error("Failed to run work");
+                    this.logger.error(e);
+                }
+                finally {
+                    this.ready = true;
+                }
+            }
+            else {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
         }
     }
 }
@@ -114,44 +124,34 @@ class PoolWorker {
  */
 export class WebsocketPool {
     constructor(url, token) {
-        this.maxWorkers = 5;
+        const envMaxWorkers = process.env.WISP_MAX_WORKERS;
+        this.maxWorkers = envMaxWorkers ? parseInt(envMaxWorkers) : 5;
         this.token = token;
         this.url = url;
+        const logPrefix = "[Pool]";
+        this.logger = {
+            log: (...args) => console.log(logPrefix, args),
+            error: (...args) => console.error(logPrefix, args),
+            debug: (...args) => {
+                if (!WISP_DEBUG)
+                    return;
+                console.debug(logPrefix, args);
+            }
+        };
         this.workers = [];
         this.queue = [];
+        this.logger.log(`Creating a new Pool with ${this.maxWorkers} workers`);
+        for (let i = 0; i < this.maxWorkers; i++) {
+            this.workers.push(new PoolWorker(this));
+        }
     }
-    async createWorker() {
-        console.log("Creating a new Pool worker");
-        const worker = new PoolWorker(this);
-        this.workers.push(worker);
-        await worker.connect();
-        return worker;
+    getWork() {
+        return this.queue.shift();
     }
     async disconnect() {
+        this.logger.log("Disconnecting all workers...");
         await Promise.all(this.workers.map((worker) => worker.disconnect()));
-    }
-    async processQueue() {
-        if (this.queue.length == 0) {
-            return;
-        }
-        const work = this.queue.shift();
-        if (!work) {
-            return;
-        }
-        let worker;
-        if (this.workers.length == 0) {
-            worker = await this.createWorker();
-        }
-        worker = worker || this.workers.find((worker) => worker.available());
-        if (!worker) {
-            if (this.workers.length < this.maxWorkers) {
-                worker = await this.createWorker();
-            }
-            else {
-                return;
-            }
-        }
-        return await worker.run(work);
+        this.logger.log("All workers disconnected");
     }
     async run(work) {
         return new Promise(async (resolve, reject) => {
@@ -165,7 +165,6 @@ export class WebsocketPool {
                     reject(e);
                 }
             });
-            return this.processQueue();
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispjs",
-  "version": "2.2.0",
+  "version": "2.3.4",
   "type": "module",
   "description": "A package for interacting with Wisp-based server panels",
   "main": "dist/wisp.js",