@blitzbrowser/blitzbrowser 1.1.4 → 1.1.6

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@blitzbrowser/blitzbrowser",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Deploying, scaling and managing headful browsers in docker.",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
+  "repository": {
+    "url": "https://github.com/blitzbrowser/blitzbrowser"
+  },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.911.0",
     "@blitzbrowser/tunnel": "2.0.3",

package/src/controllers/cdp.controller.ts

@@ -6,6 +6,7 @@ import { BrowserPoolService } from 'src/services/browser-pool.service';
 import { WebSocketServer } from 'ws';
 import z from 'zod';
 import { Message, Tunnel } from '@blitzbrowser/tunnel';
+import { MaxBrowserReachedError } from 'src/errors/max-browser-reached.error';
 
 export const PROXY_URL_QUERY_PARAM = 'proxyUrl';
 export const TIMEZONE_QUERY_PARAM = 'timezone';
@@ -24,8 +25,11 @@ type ConnectionOptionQueryParams = z.infer<typeof ConnectionOptionQueryParams>;
 @Controller()
 export class CDPController implements OnModuleInit {
 
+  private static readonly WAITING_BROWSER_TIMEOUT_MS = 10_000;
+
   static readonly INTERNAL_SERVER_ERROR_CODE = 4000;
   static readonly BAD_REQUEST_CODE = 4002;
+  static readonly NO_BROWSER_INSTANCE_AVAILABLE = 4003;
 
   readonly #logger = new Logger(CDPController.name);
 
@@ -37,7 +41,9 @@ export class CDPController implements OnModuleInit {
   async onModuleInit() {
     const websocket_server = new WebSocketServer({ server: (this.http_adapter_host.httpAdapter as ExpressAdapter).getHttpServer() });
 
-    websocket_server.on('connection', (cdp_websocket_client, req) => {
+    websocket_server.on('connection', async (cdp_websocket_client, req) => {
+      let tunnel: Tunnel;
+
       try {
         const url = new URL(`http://127.0.0.1${req.url}`);
         const parsed_connection_options = this.#parseConnectionOptionQueryParams(url);
@@ -47,9 +53,7 @@ export class CDPController implements OnModuleInit {
           return;
         }
 
-        const browser_instance = this.browser_pool_service.createBrowserInstance();
-
-        const tunnel = new Tunnel();
+        tunnel = new Tunnel();
 
         tunnel.on('message', message => {
           if (message.channel_id === BrowserInstance.CDP_CHANNEL_ID) {
@@ -65,6 +69,8 @@ export class CDPController implements OnModuleInit {
           tunnel.receiveMessage(Message.of(BrowserInstance.CDP_CHANNEL_ID, message.toString('utf8')));
         });
 
+        const browser_instance: BrowserInstance = await this.#getBrowserInstance();
+
         const ping_interval_id = setInterval(() => {
           cdp_websocket_client.ping();
         }, 3000);
@@ -89,6 +95,12 @@ export class CDPController implements OnModuleInit {
 
         this.#logger.log('Sent connection options');
       } catch (e) {
+        if (e instanceof MaxBrowserReachedError) {
+          tunnel.close();
+          cdp_websocket_client.close(CDPController.NO_BROWSER_INSTANCE_AVAILABLE, 'No browser instance available.');
+          return;
+        }
+
         this.#logger.error(`Error while handling client websocket.`, e?.stack || e)
 
         cdp_websocket_client.close(CDPController.INTERNAL_SERVER_ERROR_CODE, e?.stack || e);
@@ -106,6 +118,31 @@ export class CDPController implements OnModuleInit {
     });
   }
 
+  async #getBrowserInstance(): Promise<BrowserInstance> {
+    const start = Date.now();
+
+    while (start + CDPController.WAITING_BROWSER_TIMEOUT_MS > Date.now()) {
+      try {
+        const browser_instance = this.browser_pool_service.createBrowserInstance();
+
+        if (browser_instance) {
+          return browser_instance;
+        }
+      } catch (e) {
+        if (e instanceof MaxBrowserReachedError) {
+          await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+          });
+          continue;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    throw new MaxBrowserReachedError();
+  }
+
   #parseConnectionOptionQueryParams(url: URL) {
     return ConnectionOptionQueryParams.safeParse({
       timezone: this.getQueryParamValue(TIMEZONE_QUERY_PARAM, url),

package/src/errors/max-browser-reached.error.ts

@@ -0,0 +1,3 @@
+export class MaxBrowserReachedError extends Error {
+
+}

package/src/main.ts

@@ -1,5 +1,18 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import { Logger } from '@nestjs/common';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const package_json = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString('utf8'));
+const logger = new Logger();
+
+logger.log('#########################################################');
+logger.log(`# Version: ${package_json.version}`);
+logger.log(`# Website: https://blitzbrowser.com`);
+logger.log(`# Github : https://github.com/blitzbrowser/blitzbrowser`);
+logger.log(`# Discord: https://discord.com/invite/qZ3tCZJ2Ze`);
+logger.log('#########################################################');
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);

package/src/services/browser-pool.service.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
 import { BrowserInstance } from 'src/components/browser-instance.component';
 import * as EventEmitter from 'events';
 import { ModuleRef } from '@nestjs/core';
+import { MaxBrowserReachedError } from 'src/errors/max-browser-reached.error';
 
 type PoolServiceEvents = {
   browser_instance_created: [BrowserInstance];
@@ -23,7 +24,7 @@ export class BrowserPoolService extends EventEmitter<PoolServiceEvents> implemen
   readonly #started_at = new Date().toISOString();
   readonly #tags: { [key: string]: string; } = {};
 
-  readonly max_browser_instances = parseInt(process.env.MAX_BROWSER_INSTANCES);
+  readonly max_browser_instances = parseInt(process.env.MAX_BROWSER_INSTANCES || '99');
 
   readonly #browser_instances = new Map<string, BrowserInstance>();
 
@@ -91,6 +92,10 @@ export class BrowserPoolService extends EventEmitter<PoolServiceEvents> implemen
       return;
     }
 
+    if(this.#browser_instances.size === this.max_browser_instances) {
+      throw new MaxBrowserReachedError();
+    }
+
     const browser_instance = new BrowserInstance(id, this.module_ref);
 
     this.logger.log(`Created browser instance ${browser_instance.id}.`);