bdy 1.12.8-dev → 1.12.8-dev-pipeline-run

package/distTs/src/tunnel/http/log.js

@@ -1,218 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TunnelHttpLogRequest = void 0;
-const events_1 = __importDefault(require("events"));
-const uuid_1 = require("uuid");
-const stream_1 = __importDefault(require("./stream"));
-const isbinaryfile_1 = require("isbinaryfile");
-const utils_1 = require("../../utils");
-const tunnel_1 = require("../../types/tunnel");
-class TunnelHttpLogRequest extends events_1.default {
-    method;
-    headers;
-    responseHeaders;
-    url;
-    httpVersion;
-    status;
-    start;
-    finished;
-    id;
-    requestBody;
-    responseBody;
-    time;
-    constructor(method, headers, url, httpVersion) {
-        super();
-        this.method = method;
-        this.headers = headers;
-        this.url = url;
-        this.httpVersion = httpVersion;
-        this.status = 'NEW';
-        this.start = process.hrtime();
-        this.finished = false;
-        this.id = (0, uuid_1.v4)();
-        this.requestBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
-        this.requestBody.once('close', () => {
-            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_REQUEST_END);
-        });
-        this.responseBody = new stream_1.default(utils_1.TUNNEL_HTTP_LOG_MAX_BODY);
-        this.responseBody.once('close', () => {
-            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE_END);
-        });
-    }
-    response(statusCode, headers) {
-        this.status = statusCode;
-        this.responseHeaders = headers;
-        const end = process.hrtime(this.start);
-        this.time = Math.round(end[0] * 1000 + end[1] / 1000000);
-        this.finished = true;
-    }
-    toSocket() {
-        let requestBody = null;
-        let requestBodyLength = 0;
-        let requestBodyTooLarge = false;
-        let requestBodyBinary = false;
-        let responseBody = null;
-        let responseBodyLength = 0;
-        let responseBodyTooLarge = false;
-        let responseBodyBinary = false;
-        if (this.requestBody.realLength > 0) {
-            requestBodyLength = this.requestBody.realLength;
-            requestBodyTooLarge =
-                requestBodyLength >= utils_1.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC;
-            requestBodyBinary = (0, isbinaryfile_1.isBinaryFileSync)(this.requestBody.data);
-            if (!requestBodyTooLarge && !requestBodyBinary) {
-                requestBody = this.requestBody.data.toString('base64');
-            }
-        }
-        if (this.responseBody.realLength > 0) {
-            responseBodyLength = this.responseBody.realLength;
-            responseBodyTooLarge =
-                requestBodyLength >= utils_1.TUNNEL_MAX_REQUEST_SIZE_TO_SYNC;
-            responseBodyBinary = (0, isbinaryfile_1.isBinaryFileSync)(this.responseBody.data);
-            if (!responseBodyTooLarge && !responseBodyBinary) {
-                responseBody = this.responseBody.data.toString('base64');
-            }
-        }
-        return {
-            method: this.method,
-            headers: this.headers,
-            url: this.url,
-            httpVersion: this.httpVersion,
-            status: this.status,
-            finished: this.finished,
-            id: this.id,
-            responseHeaders: this.responseHeaders,
-            time: this.time,
-            requestBody,
-            requestBodyTooLarge,
-            requestBodyBinary,
-            requestBodyLength,
-            responseBody,
-            responseBodyTooLarge,
-            responseBodyBinary,
-            responseBodyLength,
-        };
-    }
-}
-exports.TunnelHttpLogRequest = TunnelHttpLogRequest;
-class TunnelHttpLog extends events_1.default {
-    log;
-    tsRateLimit;
-    tsCb;
-    circuitBreaker;
-    rateLimit;
-    requests;
-    constructor(log, circuitBreakerThreshold) {
-        super();
-        this.log = !!log;
-        this.requests = [];
-        this.rateLimit = {};
-        this.circuitBreaker = {
-            active: circuitBreakerThreshold !== null &&
-                circuitBreakerThreshold !== undefined,
-            threshold: circuitBreakerThreshold || 0,
-            open: false,
-            test: false,
-            total: 0,
-            failed: 0,
-        };
-        this.tsRateLimit = setInterval(() => {
-            this.rateLimit = {};
-        }, utils_1.TUNNEL_HTTP_RATE_WINDOW);
-        if (this.circuitBreaker.active) {
-            this.tsCb = setInterval(() => {
-                const t = this.circuitBreaker.total;
-                const f = this.circuitBreaker.failed;
-                const r = !t ? 0 : f / t;
-                this.circuitBreaker.test = false;
-                if (!this.circuitBreaker.open) {
-                    if (f > 0 &&
-                        t >= utils_1.TUNNEL_HTTP_CB_MIN_REQUESTS &&
-                        r > this.circuitBreaker.threshold) {
-                        this.circuitBreaker.open = true;
-                    }
-                }
-                else {
-                    this.circuitBreaker.open = false;
-                    this.circuitBreaker.test = true;
-                }
-                this.circuitBreaker.total = 0;
-                this.circuitBreaker.failed = 0;
-            }, utils_1.TUNNEL_HTTP_CB_WINDOW);
-        }
-    }
-    stop() {
-        if (this.tsRateLimit) {
-            clearInterval(this.tsRateLimit);
-            this.tsRateLimit = null;
-        }
-        if (this.tsCb) {
-            clearInterval(this.tsCb);
-            this.tsCb = null;
-        }
-    }
-    getIp(req) {
-        let ip;
-        if (req.httpVersion === '2.0') {
-            ip = req.socket.stream ? req.socket.stream.remoteAddress : '::1';
-        }
-        else {
-            ip = req.socket.remoteAddress;
-        }
-        return ip;
-    }
-    increaseRateLimit(req) {
-        const ip = this.getIp(req);
-        if (!this.rateLimit[ip])
-            this.rateLimit[ip] = 0;
-        this.rateLimit[ip] += 1;
-    }
-    isRateLimited(req) {
-        const ip = this.getIp(req);
-        if (!this.rateLimit[ip])
-            return false;
-        return this.rateLimit[ip] >= utils_1.TUNNEL_HTTP_RATE_LIMIT;
-    }
-    isCircuitBreakerOpen() {
-        return this.circuitBreaker.active && this.circuitBreaker.open;
-    }
-    newRequest(method, headers, url, httpVersion, originalReq) {
-        this.increaseRateLimit(originalReq);
-        if (this.log) {
-            const r = new TunnelHttpLogRequest(method, headers, url, httpVersion);
-            this.requests.unshift(r);
-            if (this.requests.length > utils_1.TUNNEL_HTTP_LOG_MAX_REQUESTS)
-                this.requests.pop();
-            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_REQUEST, r);
-            return r;
-        }
-    }
-    increaseCircuitBreaker(statusCode) {
-        if (this.circuitBreaker.active && !this.circuitBreaker.open) {
-            this.circuitBreaker.total += 1;
-            if (statusCode >= 500)
-                this.circuitBreaker.failed += 1;
-            if (this.circuitBreaker.test) {
-                const t = this.circuitBreaker.total;
-                const f = this.circuitBreaker.failed;
-                const rate = !t ? 0 : f / t;
-                if (f > 0 &&
-                    t >= utils_1.TUNNEL_HTTP_CB_MIN_REQUESTS &&
-                    rate > this.circuitBreaker.threshold) {
-                    this.circuitBreaker.open = true;
-                }
-            }
-        }
-    }
-    newResponse(statusCode, headers, logRequest) {
-        this.increaseCircuitBreaker(statusCode);
-        if (logRequest && this.log) {
-            logRequest.response(statusCode, headers);
-            this.emit(tunnel_1.TUNNEL_EVENT_HTTP.NEW_RESPONSE, logRequest);
-        }
-    }
-}
-exports.default = TunnelHttpLog;

package/distTs/src/tunnel/http/serve.js

@@ -1,133 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = __importDefault(require("events"));
-const path_1 = __importDefault(require("path"));
-const path_is_inside_1 = __importDefault(require("path-is-inside"));
-const range_parser_1 = __importDefault(require("range-parser"));
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = __importDefault(require("fs/promises"));
-const content_disposition_1 = __importDefault(require("content-disposition"));
-const mime_types_1 = __importDefault(require("mime-types"));
-const stream_1 = __importDefault(require("stream"));
-class TunnelHttpServe extends events_1.default {
-    serve;
-    constructor(serve) {
-        super();
-        this.serve = path_1.default.resolve(serve);
-    }
-    triggerError(err) {
-        this.emit('error', err);
-        this.emit('close');
-    }
-    trigger404() {
-        const s = new stream_1.default.Readable();
-        s.push('Not found');
-        s.push(null);
-        this.emit('response', 404, {
-            'content-type': 'text/plain',
-        }, s);
-        this.emit('close');
-    }
-    triggerResponse(statusCode, headers, stream) {
-        this.emit('response', statusCode, headers, stream);
-        this.emit('close');
-    }
-    async process(req) {
-        if (!['GET', 'HEAD'].includes(req.method)) {
-            this.trigger404();
-            return;
-        }
-        let relativePath;
-        try {
-            relativePath = decodeURIComponent(new URL(req.url, 'https://localhost').pathname);
-        }
-        catch (err) {
-            this.triggerError(err);
-            return;
-        }
-        let absolutePath = path_1.default.join(this.serve, relativePath);
-        if (!(0, path_is_inside_1.default)(absolutePath, this.serve)) {
-            this.trigger404();
-            return;
-        }
-        let stats;
-        try {
-            stats = await promises_1.default.lstat(absolutePath);
-        }
-        catch {
-            this.trigger404();
-            return;
-        }
-        if (stats.isDirectory()) {
-            absolutePath = path_1.default.join(absolutePath, 'index.html');
-            try {
-                stats = await promises_1.default.lstat(absolutePath);
-            }
-            catch {
-                this.trigger404();
-                return;
-            }
-        }
-        if (!stats.isFile()) {
-            this.trigger404();
-            return;
-        }
-        const streamOpts = {};
-        const headers = {};
-        let statusCode = 200;
-        if (req.headers.range && stats.size) {
-            const range = (0, range_parser_1.default)(stats.size, req.headers.range);
-            if (typeof range === 'object' && range.type === 'bytes') {
-                const { start, end } = range[0];
-                statusCode = 206;
-                streamOpts.start = start;
-                streamOpts.end = end;
-            }
-            else {
-                statusCode = 416;
-                headers['content-range'] = `bytes */${stats.size}`;
-            }
-        }
-        const { base } = path_1.default.parse(absolutePath);
-        headers['content-length'] = String(stats.size);
-        headers['content-disposition'] = (0, content_disposition_1.default)(base, {
-            type: 'inline',
-        });
-        headers['accept-ranges'] = 'bytes';
-        headers['last-modified'] = stats.mtime.toUTCString();
-        const contentType = mime_types_1.default.contentType(base);
-        if (contentType) {
-            headers['content-type'] = contentType;
-        }
-        if (streamOpts.start !== undefined && streamOpts.end !== undefined) {
-            headers['content-range'] =
-                `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
-            headers['content-length'] = String(streamOpts.end - streamOpts.start + 1);
-        }
-        if (!req.headers.range && req.headers['if-modified-since']) {
-            const ims = Math.floor(Date.parse(req.headers['if-modified-since']) / 1000);
-            const mt = Math.floor(stats.mtime.getTime() / 1000);
-            if (mt <= ims) {
-                this.triggerResponse(304, headers);
-                return;
-            }
-        }
-        if (req.method === 'HEAD') {
-            this.triggerResponse(statusCode, headers);
-            return;
-        }
-        let stream;
-        try {
-            stream = fs_1.default.createReadStream(absolutePath, streamOpts);
-        }
-        catch (err) {
-            this.triggerError(err);
-            return;
-        }
-        this.triggerResponse(statusCode, headers, stream);
-    }
-}
-exports.default = TunnelHttpServe;

package/distTs/src/tunnel/http/stream.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("stream");
-class TunnelHttpStream extends stream_1.Transform {
-    maxSize;
-    data;
-    realLength;
-    tooLarge;
-    constructor(maxSize) {
-        super();
-        this.maxSize = maxSize;
-        this.data = Buffer.alloc(0);
-        this.realLength = 0;
-        this.tooLarge = false;
-    }
-    _transform(chunk, _, callback) {
-        if (!this.tooLarge) {
-            if (this.data.length + chunk.length > this.maxSize) {
-                this.tooLarge = true;
-                this.data = Buffer.alloc(0);
-            }
-            else {
-                this.data = Buffer.concat([this.data, chunk]);
-            }
-        }
-        this.realLength += chunk.length;
-        callback(null, chunk);
-    }
-    pipeToNothing(done) {
-        this.once('end', done);
-        this.resume();
-    }
-}
-exports.default = TunnelHttpStream;