@browserless.io/browserless 2.0.0-beta-1 → 2.0.0-beta-2

package/src/router.ts

@@ -0,0 +1,234 @@
+import {
+  BrowserHTTPRoute,
+  BrowserManager,
+  BrowserWebsocketRoute,
+  Config,
+  HTTPManagementRoutes,
+  HTTPRoute,
+  Limiter,
+  Methods,
+  Request,
+  Response,
+  WebSocketRoute,
+  contentTypes,
+  createLogger,
+  isConnected,
+  writeResponse,
+} from '@browserless.io/browserless';
+import micromatch from 'micromatch';
+import stream from 'stream';
+
+export class Router {
+  protected log = createLogger('router');
+  protected verbose = createLogger('router:verbose');
+  protected httpRoutes: Array<HTTPRoute | BrowserHTTPRoute> = [];
+  protected webSocketRoutes: Array<WebSocketRoute | BrowserWebsocketRoute> = [];
+
+  constructor(
+    protected config: Config,
+    protected browserManager: BrowserManager,
+    protected limiter: Limiter,
+  ) {}
+
+  protected getTimeout(req: Request) {
+    const timer = req.parsed.searchParams.get('timeout');
+
+    return timer ? +timer : undefined;
+  }
+
+  protected onQueueFullHTTP = (_req: Request, res: Response) => {
+    this.log(`Queue is full, sending 429 response`);
+    return writeResponse(res, 429, 'Too many requests');
+  };
+
+  protected onQueueFullWebSocket = (_req: Request, socket: stream.Duplex) => {
+    this.log(`Queue is full, sending 429 response`);
+    return writeResponse(socket, 429, 'Too many requests');
+  };
+
+  protected onHTTPTimeout = (_req: Request, res: Response) => {
+    this.log(`HTTP job has timedout, sending 429 response`);
+    return writeResponse(res, 408, 'Request has timed out');
+  };
+
+  protected onWebsocketTimeout = (_req: Request, socket: stream.Duplex) => {
+    this.log(`Websocket job has timedout, sending 429 response`);
+    return writeResponse(socket, 408, 'Request has timed out');
+  };
+
+  protected wrapHTTPHandler =
+    (
+      route: HTTPRoute | BrowserHTTPRoute,
+      handler: HTTPRoute['handler'] | BrowserHTTPRoute['handler'],
+    ) =>
+    async (req: Request, res: Response) => {
+      if (!isConnected(res)) {
+        this.log(`HTTP Request has closed prior to running`);
+        return Promise.resolve();
+      }
+
+      if (route.browser) {
+        const browser = await this.browserManager.getBrowserForRequest(
+          req,
+          route,
+        );
+
+        if (!isConnected(res)) {
+          this.log(`HTTP Request has closed prior to running`);
+          this.browserManager.complete(browser);
+          return Promise.resolve();
+        }
+
+        if (!browser) {
+          return writeResponse(res, 500, `Error loading the browser.`);
+        }
+
+        if (!isConnected(res)) {
+          this.log(`HTTP Request has closed prior to running`);
+          return Promise.resolve();
+        }
+
+        try {
+          this.verbose(`Running found HTTP handler.`);
+          return await handler(req, res, browser);
+        } finally {
+          this.verbose(`HTTP Request handler has finished.`);
+          this.browserManager.complete(browser);
+        }
+      }
+
+      return (handler as HTTPRoute['handler'])(req, res);
+    };
+
+  protected wrapWebSocketHandler =
+    (
+      route: WebSocketRoute | BrowserWebsocketRoute,
+      handler: WebSocketRoute['handler'] | BrowserWebsocketRoute['handler'],
+    ) =>
+    async (req: Request, socket: stream.Duplex, head: Buffer) => {
+      if (!isConnected(socket)) {
+        this.log(`WebSocket Request has closed prior to running`);
+        return Promise.resolve();
+      }
+
+      if (route.browser) {
+        const browser = await this.browserManager.getBrowserForRequest(
+          req,
+          route,
+        );
+
+        if (!isConnected(socket)) {
+          this.log(`WebSocket Request has closed prior to running`);
+          this.browserManager.complete(browser);
+          return Promise.resolve();
+        }
+
+        if (!browser) {
+          return writeResponse(socket, 500, `Error loading the browser.`);
+        }
+
+        try {
+          this.verbose(`Running found WebSocket handler.`);
+          await handler(req, socket, head, browser);
+        } finally {
+          this.verbose(`WebSocket Request handler has finished.`);
+          this.browserManager.complete(browser);
+        }
+        return;
+      }
+      return (handler as WebSocketRoute['handler'])(req, socket, head);
+    };
+
+  public registerHTTPRoute(
+    route: HTTPRoute | BrowserHTTPRoute,
+  ): HTTPRoute | BrowserHTTPRoute {
+    this.verbose(
+      `Registering HTTP ${route.method.toUpperCase()} ${route.path}`,
+    );
+
+    route.getBrowserManager = () => this.browserManager;
+
+    const bound = route.handler.bind(route);
+    const wrapped = this.wrapHTTPHandler(route, bound);
+
+    route.handler = route.concurrency
+      ? this.limiter.limit(
+          wrapped,
+          this.onQueueFullHTTP,
+          this.onHTTPTimeout,
+          this.getTimeout,
+        )
+      : wrapped;
+
+    this.httpRoutes.push(route);
+
+    return route;
+  }
+
+  public registerWebSocketRoute(
+    route: WebSocketRoute | BrowserWebsocketRoute,
+  ): WebSocketRoute | BrowserWebsocketRoute {
+    this.verbose(`Registering WebSocket "${route.path}"`);
+
+    route.getBrowserManager = () => this.browserManager;
+
+    const bound = route.handler.bind(route);
+    const wrapped = this.wrapWebSocketHandler(route, bound);
+
+    route.handler = route.concurrency
+      ? this.limiter.limit(
+          wrapped,
+          this.onQueueFullWebSocket,
+          this.onWebsocketTimeout,
+          this.getTimeout,
+        )
+      : wrapped;
+
+    this.webSocketRoutes.push(route);
+
+    return route;
+  }
+
+  public teardown() {
+    this.httpRoutes = [];
+    this.webSocketRoutes = [];
+
+    return this.browserManager.stop();
+  }
+
+  public getStaticHandler() {
+    return this.httpRoutes.find(
+      (route) => route.path === HTTPManagementRoutes.static,
+    ) as HTTPRoute;
+  }
+
+  public async getRouteForHTTPRequest(req: Request) {
+    const accepts = (req.headers['accept']?.toLowerCase() || '*/*').split(',');
+    const contentType = req.headers['content-type']?.toLowerCase() as
+      | contentTypes
+      | undefined;
+
+    return (
+      this.httpRoutes.find(
+        (r) =>
+          micromatch.isMatch(req.parsed.pathname, r.path) &&
+          r.method === (req.method?.toLocaleLowerCase() as Methods) &&
+          (accepts.some((a) => a.startsWith('*/*')) ||
+            r.contentTypes.some((contentType) =>
+              accepts.includes(contentType),
+            )) &&
+          ((!contentType && r.accepts.includes(contentTypes.any)) ||
+            r.accepts.includes(contentType as contentTypes)),
+      ) ||
+      (req.method?.toLowerCase() === 'get' ? this.getStaticHandler() : null)
+    );
+  }
+
+  public async getRouteForWebSocketRequest(req: Request) {
+    const { pathname } = req.parsed;
+
+    return this.webSocketRoutes.find((r) =>
+      micromatch.isMatch(pathname, r.path),
+    );
+  }
+}

package/src/routes/chromium/http/download-post.ts

@@ -60,7 +60,7 @@ const route: BrowserHTTPRoute = {
     browser: BrowserInstance,
   ): Promise<void> =>
     new Promise(async (resolve, reject) => {
-      const { _config: getConfig, _debug: getDebug } = route;
+      const { getConfig: getConfig, getDebug: getDebug } = route;
 
       if (!getConfig || !getDebug) {
         return reject(

package/src/routes/chromium/http/function-post.ts

@@ -55,7 +55,7 @@ const route: BrowserHTTPRoute = {
     res: ServerResponse,
     browser: BrowserInstance,
   ): Promise<void> => {
-    const { _config: getConfig, _debug: getDebug } = route;
+    const { getConfig: getConfig, getDebug: getDebug } = route;
 
     if (!getConfig || !getDebug) {
       throw new ServerError(`Couldn't load configuration for request`);

package/src/routes/chromium/http/performance.ts

@@ -46,7 +46,7 @@ const route: BrowserHTTPRoute = {
     res: ServerResponse,
     browser: BrowserInstance,
   ): Promise<void> => {
-    const { _config: getConfig } = route;
+    const { getConfig: getConfig } = route;
     if (!req.body) {
       throw new BadRequest(`No JSON body present`);
     }

package/src/routes/chromium/utils/function/client.ts

@@ -8,8 +8,8 @@ type codeHandler = (params: {
 }) => Promise<unknown>;
 
 export class FunctionRunner {
-  private browser?: Browser;
-  private page?: Page;
+  protected browser?: Browser;
+  protected page?: Page;
 
   public log = () => console.log.bind(console);
 

package/src/routes/management/http/config-get.ts

@@ -41,7 +41,7 @@ const route: HTTPRoute = {
   contentTypes: [contentTypes.json],
   description: `Returns a JSON payload of the current system configuration.`,
   handler: async (_req: Request, res: ServerResponse): Promise<void> => {
-    const { _config: getConfig } = route;
+    const { getConfig: getConfig } = route;
 
     if (!getConfig) {
       throw new ServerError(`Couldn't locate the config object`);

package/src/routes/management/http/metrics-get.ts

@@ -21,7 +21,7 @@ const route: HTTPRoute = {
   contentTypes: [contentTypes.json],
   description: `Gets total metric details from the time the server started.`,
   handler: async (_req: Request, res: ServerResponse): Promise<void> => {
-    const { _fileSystem, _config } = route;
+    const { getFileSystem: _fileSystem, getConfig: _config } = route;
 
     if (!_fileSystem || !_config) {
       throw new ServerError(`Couldn't locate the file-system or config module`);

package/src/routes/management/http/metrics-total-get.ts

@@ -23,7 +23,7 @@ const route: HTTPRoute = {
   contentTypes: [contentTypes.json],
   description: `Gets total metric details summed from the time the server started.`,
   handler: async (_req: Request, res: ServerResponse): Promise<void> => {
-    const { _fileSystem, _config } = route;
+    const { getFileSystem: _fileSystem, getConfig: _config } = route;
 
     if (!_fileSystem || !_config) {
       throw new ServerError(`Couldn't locate the file-system or config module`);

package/src/routes/management/http/sessions-get.ts

@@ -20,14 +20,14 @@ const route: HTTPRoute = {
   concurrency: false,
   contentTypes: [contentTypes.json],
   description: `Lists all currently running sessions and relevant meta-data excluding potentially open pages.`,
-  handler: async (req: Request, res: ServerResponse): Promise<void> => {
-    const { _browserManager: browserManager } = route;
+  handler: async (_req: Request, res: ServerResponse): Promise<void> => {
+    const { getBrowserManager: browserManager } = route;
 
     if (!browserManager) {
       throw new BadRequest(`Couldn't load browsers running`);
     }
 
-    const response: ResponseSchema = await browserManager().getAllSessions(req);
+    const response: ResponseSchema = await browserManager().getAllSessions();
 
     return jsonResponse(res, 200, response);
   },

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

@@ -55,7 +55,7 @@ const route: HTTPRoute = {
   contentTypes: [contentTypes.any],
   description: `Serves static files inside of this "static" directory. Content-types will vary depending on the type of file being returned.`,
   handler: async (req: Request, res: ServerResponse): Promise<unknown> => {
-    const { _config: getConfig } = route;
+    const { getConfig: getConfig } = route;
     const { pathname } = req.parsed;
     const fileCache = pathMap.get(pathname);