bdy 1.22.33-dev → 1.22.34-stage

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.22.33-dev",
+  "version": "1.22.34-stage",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/tunnel/agent.js

@@ -9,7 +9,9 @@ const http2_1 = __importDefault(require("http2"));
 const uuid_1 = require("uuid");
 const texts_1 = require("../texts");
 const CONNECTION_TIMEOUT = 5000;
-const STREAM_LIMIT = 10;
+const HTTP2_MAX_POOL_SIZE = 4;
+const HTTP2_MAX_CONCURRENT_STREAMS = 100;
+const HTTP2_MAX_LIFETIME_REQUESTS = 1000;
 class TunnelAgent {
     static httpAgent1;
     static httpsAgent1;
@@ -40,34 +42,68 @@ class TunnelAgent {
                 TunnelAgent.deleteClient(authority, client, id);
                 reject(new Error(texts_1.ERR_CONNECTION_TIMEOUT));
             }, CONNECTION_TIMEOUT);
+            let pingTs;
             const client = http2_1.default.connect(authority, {
                 rejectUnauthorized: verify,
                 maxSessionMemory: 100,
                 servername,
             });
+            client.setTimeout(60000);
             client.once('close', () => {
+                clearInterval(pingTs);
+                TunnelAgent.deleteClient(authority, client, id);
+            });
+            client.once('goaway', () => {
+                clearInterval(pingTs);
                 TunnelAgent.deleteClient(authority, client, id);
             });
             client.once('timeout', () => {
+                clearInterval(pingTs);
                 TunnelAgent.deleteClient(authority, client, id);
             });
             client.once('error', () => {
                 clearTimeout(ts);
+                clearInterval(pingTs);
                 TunnelAgent.deleteClient(authority, client, id);
                 reject(new Error(texts_1.ERR_CONNECTION_ERROR));
             });
             client.once('connect', () => {
                 clearTimeout(ts);
+                pingTs = setInterval(() => {
+                    if (client.closed || client.destroyed)
+                        return;
+                    let acked = false;
+                    const ackTs = setTimeout(() => {
+                        if (!acked) {
+                            clearInterval(pingTs);
+                            TunnelAgent.deleteClient(authority, client, id);
+                        }
+                    }, 5000);
+                    try {
+                        client.ping(() => {
+                            acked = true;
+                            clearTimeout(ackTs);
+                        });
+                    }
+                    catch {
+                        clearTimeout(ackTs);
+                        clearInterval(pingTs);
+                        TunnelAgent.deleteClient(authority, client, id);
+                    }
+                }, 10000);
                 resolve(client);
             });
         });
     }
     static deleteClient(authority, client, id) {
         if (this.http2Clients && this.http2Clients[authority]) {
-            if (this.http2Clients[authority][id])
+            if (this.http2Clients[authority][id]) {
+                this.http2Clients[authority][id].closed = true;
                 delete this.http2Clients[authority][id];
-            if (!Object.keys(this.http2Clients[authority]).length)
+            }
+            if (!Object.keys(this.http2Clients[authority]).length) {
                 delete this.http2Clients[authority];
+            }
         }
         try {
             client.removeAllListeners();
@@ -82,22 +118,49 @@ class TunnelAgent {
             this.http2Clients = {};
         if (!this.http2Clients[authority])
             this.http2Clients[authority] = {};
-        const keys = Object.keys(this.http2Clients[authority]);
+        const pool = this.http2Clients[authority];
+        let best = null;
+        let bestLoad = Infinity;
+        const keys = Object.keys(pool);
         for (let i = 0; i < keys.length; i += 1) {
             const id = keys[i];
-            const { promise, streamCount } = this.http2Clients[authority][id];
-            if (streamCount < STREAM_LIMIT) {
-                this.http2Clients[authority][id].streamCount += 1;
-                return promise;
+            const c = pool[id];
+            if (c.hasCapacity() && c.concurrent < bestLoad) {
+                best = c;
+                bestLoad = c.concurrent;
+            }
+        }
+        if (best)
+            return best;
+        if (keys.length >= HTTP2_MAX_POOL_SIZE) {
+            for (let i = 0; i < keys.length; i += 1) {
+                const id = keys[i];
+                const c = pool[id];
+                if (c.concurrent < bestLoad) {
+                    best = c;
+                    bestLoad = c.concurrent;
+                }
             }
         }
+        if (best)
+            return best;
         const id = (0, uuid_1.v4)();
         const promise = this.createHttp2Client(authority, servername, verify, id);
-        this.http2Clients[authority][id] = {
+        best = {
             promise,
-            streamCount: 1,
+            closed: false,
+            requests: 0,
+            concurrent: 0,
+            hasCapacity: function () {
+                if (this.closed)
+                    return false;
+                if (this.requests >= HTTP2_MAX_LIFETIME_REQUESTS)
+                    return false;
+                return this.concurrent < HTTP2_MAX_CONCURRENT_STREAMS;
+            },
         };
-        return promise;
+        this.http2Clients[authority][id] = best;
+        return best;
     }
 }
 exports.default = TunnelAgent;

package/distTs/src/tunnel/http.js

@@ -243,10 +243,14 @@ class TunnelHttp extends events_1.default {
             const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
-                (0, node_stream_1.pipeline)(this.proxyRes, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(this.proxyRes, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => {
+                    this.clear();
+                });
             }
             else {
-                (0, node_stream_1.pipeline)(this.proxyRes, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(this.proxyRes, compression_1.default.compress(compressionMethod), this.res, () => {
+                    this.clear();
+                });
             }
             if (this.httpLog) {
                 this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
@@ -286,10 +290,14 @@ class TunnelHttp extends events_1.default {
             const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
-                (0, node_stream_1.pipeline)(this.proxyRes, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(this.proxyRes, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => {
+                    this.clear();
+                });
             }
             else {
-                (0, node_stream_1.pipeline)(this.proxyRes, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(this.proxyRes, compression_1.default.compress(compressionMethod), this.res, () => {
+                    this.clear();
+                });
             }
             if (this.httpLog) {
                 this.httpLog.newResponse(statusCode, resHeaders, this.logRequest);
@@ -314,10 +322,14 @@ class TunnelHttp extends events_1.default {
                 const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
                 this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
                 if (this.logRequest) {
-                    (0, node_stream_1.pipeline)(stream, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                    (0, node_stream_1.pipeline)(stream, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => {
+                        this.clear();
+                    });
                 }
                 else {
-                    (0, node_stream_1.pipeline)(stream, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                    (0, node_stream_1.pipeline)(stream, compression_1.default.compress(compressionMethod), this.res, () => {
+                        this.clear();
+                    });
                 }
             }
             if (this.httpLog) {
@@ -326,10 +338,32 @@ class TunnelHttp extends events_1.default {
         });
         return r;
     }
+    async getHttp2Client(authority) {
+        let c = agent_1.default.getHttp2Client(authority, this.host || '', this.verify || false);
+        let client;
+        try {
+            client = await c.promise;
+        }
+        catch {
+            // do nothing
+        }
+        if (c.closed || !client || client.closed || client.destroyed) {
+            // try again
+            c = agent_1.default.getHttp2Client(authority, this.host || '', this.verify || false);
+            client = await c.promise;
+        }
+        if (c.closed || !client || client.closed || client.destroyed) {
+            throw new Error(texts_1.ERR_CONNECTION_ERROR);
+        }
+        return {
+            client,
+            c,
+        };
+    }
     async createRequestHttps2() {
         const reqHeaders = this.req.headers;
         const authority = `${this.proto}://${(0, utils_1.getRealTargetHost)(this.host)}:${this.port}`;
-        const client = await agent_1.default.getHttp2Client(authority, this.host || '', this.verify || false);
+        const { c, client } = await this.getHttp2Client(authority);
         const method = this.getMethod();
         const path = this.getPath();
         const headers = {
@@ -337,28 +371,53 @@ class TunnelHttp extends events_1.default {
             ...this.headers,
             ...this.getRequestHeaders(true),
         };
-        const r = client.request(headers);
+        c.requests += 1;
+        c.concurrent += 1;
+        let concurrentDecremented = false;
+        const decrementConcurrent = () => {
+            if (concurrentDecremented)
+                return;
+            concurrentDecremented = true;
+            if (c.concurrent > 0)
+                c.concurrent -= 1;
+        };
+        let r;
+        try {
+            r = client.request(headers);
+        }
+        catch (err) {
+            decrementConcurrent();
+            throw err;
+        }
         if (this.httpLog) {
             this.logRequest = this.httpLog.newRequest(method, headers, path, tunnel_1.TUNNEL_HTTP_IDENTIFY.HTTP2, this.req);
         }
         r.on('error', () => {
             try {
+                decrementConcurrent();
                 this.res.end();
             }
             catch {
                 // do nothing
             }
         });
+        r.once('close', decrementConcurrent);
         r.on('response', (resHeaders) => {
             r.setTimeout(0);
             const status = resHeaders[':status'] || 200;
             const compressionMethod = compression_1.default.detect(this.compression || false, reqHeaders, resHeaders);
             this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
             if (this.logRequest) {
-                (0, node_stream_1.pipeline)(r, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(r, this.logRequest.responseBody, compression_1.default.compress(compressionMethod), this.res, () => {
+                    decrementConcurrent();
+                    this.clear();
+                });
             }
             else {
-                (0, node_stream_1.pipeline)(r, compression_1.default.compress(compressionMethod), this.res, () => { this.clear(); });
+                (0, node_stream_1.pipeline)(r, compression_1.default.compress(compressionMethod), this.res, () => {
+                    decrementConcurrent();
+                    this.clear();
+                });
             }
             if (this.httpLog) {
                 this.httpLog.newResponse(status, resHeaders, this.logRequest);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.22.33-dev",
+  "version": "1.22.34-stage",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {