@browserless.io/browserless 2.3.0 → 2.4.0-beta-3

package/src/limiter.ts

@@ -226,4 +226,17 @@ export class Limiter extends q {
         return bound;
       });
   };
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/metrics.ts

@@ -1,6 +1,8 @@
 import { IBrowserlessStats } from '@browserless.io/browserless';
 
-export class Metrics {
+import { EventEmitter } from 'events';
+
+export class Metrics extends EventEmitter {
   protected sessionTimes: number[] = [];
   protected successful = 0;
   protected queued = 0;
@@ -105,4 +107,17 @@ export class Metrics {
       ),
     };
   }
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/monitoring.ts

@@ -3,11 +3,14 @@ import {
   IResourceLoad,
   createLogger,
 } from '@browserless.io/browserless';
+import { EventEmitter } from 'events';
 import si from 'systeminformation';
 
-export class Monitoring {
+export class Monitoring extends EventEmitter {
   protected log = createLogger('hardware');
-  constructor(protected config: Config) {}
+  constructor(protected config: Config) {
+    super();
+  }
 
   public getMachineStats = async (): Promise<IResourceLoad> => {
     const [cpuLoad, memLoad] = await Promise.all([
@@ -50,4 +53,17 @@ export class Monitoring {
       memoryOverloaded,
     };
   };
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/router.ts

@@ -16,10 +16,11 @@ import {
   isConnected,
   writeResponse,
 } from '@browserless.io/browserless';
+import { EventEmitter } from 'events';
 import micromatch from 'micromatch';
 import stream from 'stream';
 
-export class Router {
+export class Router extends EventEmitter {
   protected log = createLogger('router');
   protected verbose = createLogger('router:verbose');
   protected httpRoutes: Array<HTTPRoute | BrowserHTTPRoute> = [];
@@ -29,7 +30,9 @@ export class Router {
     protected config: Config,
     protected browserManager: BrowserManager,
     protected limiter: Limiter,
-  ) {}
+  ) {
+    super();
+  }
 
   protected getTimeout(req: Request) {
     const timer = req.parsed.searchParams.get('timeout');
@@ -207,13 +210,6 @@ export class Router {
     return route;
   }
 
-  public teardown() {
-    this.httpRoutes = [];
-    this.webSocketRoutes = [];
-
-    return this.browserManager.stop();
-  }
-
   public getStaticHandler() {
     return this.httpRoutes.find((route) =>
       route.path.includes(HTTPManagementRoutes.static),
@@ -253,4 +249,19 @@ export class Router {
       (r.path as Array<PathTypes>).some((p) => micromatch.isMatch(pathname, p)),
     );
   }
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    this.httpRoutes = [];
+    this.webSocketRoutes = [];
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/routes/chrome/tests/function.spec.ts

@@ -46,6 +46,41 @@ describe('/chrome/function API', function () {
     });
   });
 
+  it('runs functions with "context"', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `export default async function ({ page, context }) {
+        if (!!context.ok) {
+          return Promise.resolve({
+            data: "ok",
+            type: "application/text",
+          });
+        }
+        return Promise.reject(new Error('Bad context!'));
+      }`,
+      context: {
+        ok: true,
+      },
+    };
+
+    await fetch('http://localhost:3000/chrome/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(res.status).to.equal(200);
+    });
+  });
+
   it('runs "application/javascript" functions', async () => {
     const config = new Config();
     config.setToken('browserless');

package/src/routes/management/http/static.get.ts

@@ -70,39 +70,49 @@ export default class StaticGetRoute extends HTTPRoute {
     }
 
     const config = this.config();
+    const sdkDir = this.staticSDKDir();
     const file = path.join(config.getStatic(), pathname);
     const indexFile = path.join(file, 'index.html');
+    const locations = [file, indexFile];
 
-    const filePath = (
-      await Promise.all([
-        fileExists(file).then((exists) => (exists ? file : undefined)),
-        fileExists(indexFile).then((exists) =>
-          exists ? indexFile : undefined,
-        ),
-      ])
-    ).find((_) => !!_);
+    if (sdkDir) {
+      const sdkPath = path.join(sdkDir, pathname);
+      locations.push(...[sdkPath, path.join(sdkPath, 'index.html')]);
+    }
+
+    const foundFilePaths = (
+      await Promise.all(
+        locations.map((l) => fileExists(l).then((e) => (e ? l : undefined))),
+      )
+    ).filter((_) => !!_) as string[];
 
-    if (!filePath) {
+    if (!foundFilePaths.length) {
       throw new NotFound(
         `No route or file found for resource ${req.method}: ${pathname}`,
       );
     }
 
-    verbose(`Found new file "${filePath}", caching path and serving`);
+    if (foundFilePaths.length > 1) {
+      debug(
+        `Multiple files found for request to "${pathname}". Only the first file is served, so please name your files uniquely.`,
+      );
+    }
+
+    const [foundFilePath] = foundFilePaths;
+    verbose(`Found new file "${foundFilePath}", caching path and serving`);
 
-    const contentType = mimeTypes.get(path.extname(filePath));
+    const contentType = mimeTypes.get(path.extname(foundFilePath));
 
     if (contentType) {
       res.setHeader('Content-Type', contentType);
     }
 
-    // Cache the assets location so we don't have to
-    // do stat checks again when requests come back
+    // Cache the file as being found so we don't have to call 'stat'
     pathMap.set(pathname, {
       contentType,
-      path: filePath,
+      path: foundFilePath,
     });
 
-    return streamFile(verbose, res, filePath, contentType);
+    return streamFile(verbose, res, foundFilePath, contentType);
   };
 }

package/src/server.ts

@@ -23,6 +23,7 @@ import {
   shimLegacyRequests,
   writeResponse,
 } from '@browserless.io/browserless';
+import { EventEmitter } from 'events';
 
 // @ts-ignore
 import Enjoi from 'enjoi';
@@ -35,7 +36,7 @@ export interface HTTPServerOptions {
   timeout: number;
 }
 
-export class HTTPServer {
+export class HTTPServer extends EventEmitter {
   protected server: http.Server = http.createServer();
   protected port: number;
   protected host?: string;
@@ -48,6 +49,7 @@ export class HTTPServer {
     protected token: Token,
     protected router: Router,
   ) {
+    super();
     this.host = config.getHost();
     this.port = config.getPort();
 
@@ -100,21 +102,6 @@ export class HTTPServer {
     });
   }
 
-  public async stop(): Promise<void> {
-    this.log(`HTTP Server is shutting down`);
-    await new Promise((r) => this.server.close(r));
-    await Promise.all([this.tearDown(), this.router.teardown()]);
-    this.log(`HTTP Server shutdown complete`);
-  }
-
-  protected tearDown() {
-    this.log(`Tearing down all listeners and internal routes`);
-    this.server && this.server.removeAllListeners();
-
-    // @ts-ignore garbage collect this reference
-    this.server = null;
-  }
-
   protected handleRequest = async (
     request: http.IncomingMessage,
     res: http.ServerResponse,
@@ -410,4 +397,19 @@ export class HTTPServer {
     this.log(`No matching WebSocket route handler for "${req.parsed.href}"`);
     return writeResponse(socket, 404, 'Not Found');
   };
+
+  public async shutdown(): Promise<void> {
+    this.log(`HTTP Server is shutting down`);
+    await new Promise((r) => this.server.close(r));
+    this.server && this.server.removeAllListeners();
+
+    // @ts-ignore garbage collect this reference
+    this.server = null;
+    this.log(`HTTP Server shutdown complete`);
+  }
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/token.ts

@@ -7,9 +7,12 @@ import {
   WebSocketRoute,
   getTokenFromRequest,
 } from '@browserless.io/browserless';
+import { EventEmitter } from 'events';
 
-export class Token {
-  constructor(protected config: Config) {}
+export class Token extends EventEmitter {
+  constructor(protected config: Config) {
+    super();
+  }
 
   public isAuthorized = async (
     req: Request,
@@ -37,4 +40,17 @@ export class Token {
 
     return (Array.isArray(token) ? token : [token]).includes(requestToken);
   };
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }

package/src/types.ts

@@ -102,6 +102,7 @@ abstract class Route {
     protected _debug: Browserless['debug'],
     protected _metrics: Browserless['metrics'],
     protected _monitoring: Browserless['monitoring'],
+    protected _staticSDKDir: Browserless['staticSDKDir'],
   ) {}
 
   /**
@@ -195,6 +196,14 @@ abstract class Route {
    */
   monitoring = () => this._monitoring;
 
+  /**
+   * When running in an SDK environment, this returns the fully-qualified
+   * directory of that static directory. When "null" then no SDK directory
+   * has been set.
+   * @returns {string | null} The full path location of the SDK's static directory
+   */
+  staticSDKDir = () => this._staticSDKDir;
+
   /**
    * The HTTP path that this route handles, eg '/my-route' OR an
    * array of paths that this route can handle.
@@ -469,19 +478,6 @@ export const debugScreenshotOpts: ScreenshotOptions = {
   type: 'jpeg',
 };
 
-declare global {
-  interface Window {
-    browserless: BrowserlessEmbeddedAPI;
-  }
-}
-
-export interface BrowserlessEmbeddedAPI {
-  getRecording: () => Promise<string>;
-  liveUrl: () => string;
-  saveRecording: () => Promise<boolean>;
-  startRecording: () => void;
-}
-
 /**
  * When bestAttempt is set to true, browserless attempt to proceed
  * when "awaited" events fail or timeout. This includes things like

package/src/webhooks.ts

@@ -1,7 +1,10 @@
 import { Config, fetchTimeout, noop } from '@browserless.io/browserless';
+import { EventEmitter } from 'events';
 
-export class WebHooks {
-  constructor(protected config: Config) {}
+export class WebHooks extends EventEmitter {
+  constructor(protected config: Config) {
+    super();
+  }
 
   protected callURL(url: string | null) {
     if (url) {
@@ -47,4 +50,17 @@ export class WebHooks {
       );
     }
   }
+
+  /**
+   * Implement any browserless-core-specific shutdown logic here.
+   * Calls the empty-SDK stop method for downstream implementations.
+   */
+  public shutdown = async () => {
+    await this.stop();
+  };
+
+  /**
+   * Left blank for downstream SDK modules to optionally implement.
+   */
+  public stop = () => {};
 }