@bbk47/toolbox 1.0.8 → 2.0.0

package/src/transport/creater.ts

@@ -0,0 +1,88 @@
+import WebSocket from 'ws';
+import net from 'net';
+import http2 from 'http2';
+import tls from 'tls';
+import { Transport, TransportConn } from './transport';
+
+export interface TransportParams {
+    host: string;
+    port: number;
+    path?: string;
+    secure?: boolean;
+}
+
+export function createWebsocketTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const tunnelWsUrl = `${params.secure ? 'wss' : 'ws'}://${params.host}:${params.port}${params.path || ''}`;
+    const ws = new WebSocket(tunnelWsUrl, {
+        perMessageDeflate: false,
+        handshakeTimeout: 3000,
+    } as any);
+    const ts = new Transport({ type: 'ws', conn: ws as unknown as TransportConn });
+    ws.on('open', onOpen);
+    return ts;
+}
+
+export function createHttp2Transport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const http2Url = `https://${params.host}:${params.port}`;
+    const client = http2.connect(http2Url, {
+        rejectUnauthorized: false,
+        requestCert: true,
+    });
+    const http2stream = client.request({
+        ':method': 'POST',
+        ':path': params.path || '/',
+        'Content-Type': 'octet-stream',
+    });
+    http2stream.on('response', onOpen);
+    const ts = new Transport({ type: 'h2', conn: http2stream as unknown as TransportConn });
+    return ts;
+}
+
+export function createTlsTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const tlsOpts: tls.ConnectionOptions = {
+        rejectUnauthorized: false,
+        host: params.host,
+        port: params.port,
+    };
+    const tlsConn = tls.connect(tlsOpts, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'tls', conn: tlsConn as unknown as TransportConn });
+    return ts;
+}
+
+export function createTcpTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const socket = new net.Socket();
+    socket.connect(params.port, params.host, function () {
+        onOpen();
+    });
+    return new Transport({ type: 'tcp', conn: socket as unknown as TransportConn });
+}
+
+export function createUnixsocketTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const socket = new net.Socket();
+    socket.connect(params.path || '', function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'domainsocket', conn: socket as unknown as TransportConn });
+    return ts;
+}
+
+export function wrapSocket(type: string, conn: TransportConn): Transport {
+    return new Transport({ type: type as any, conn });
+}

package/src/transport/helper.ts

@@ -0,0 +1,73 @@
+import WebSocket from 'ws';
+import net from 'net';
+import stream from 'stream';
+
+export type DataCallback = (data: Buffer) => void;
+export type ErrorCallback = (err: Error) => void;
+export type CloseCallback = (code?: number) => void;
+
+export function bindStreamSocket(
+    s: stream.Readable & { on: Function; destroy: Function },
+    onData: DataCallback,
+    onError: ErrorCallback,
+    onClose: CloseCallback
+): void {
+    let buffcache = Buffer.from([]);
+    s.on('data', function (data: Buffer) {
+        buffcache = Buffer.concat([buffcache, data]);
+        while (true) {
+            if (buffcache.length <= 2) {
+                return;
+            }
+            const datalen = buffcache[0] * 256 + buffcache[1];
+            if (buffcache.length < datalen + 2) {
+                return;
+            }
+            const pack = buffcache.slice(2, datalen + 2);
+            buffcache = buffcache.slice(datalen + 2);
+            onData(pack);
+        }
+    });
+    s.on('close', function (code?: number) {
+        onClose(code);
+    });
+    s.on('error', function (err: Error) {
+        (s as any).destroy();
+        onError(err);
+    });
+}
+
+export function bindWebsocket(
+    ws: WebSocket,
+    onData: DataCallback,
+    onError: ErrorCallback,
+    onClose: CloseCallback
+): void {
+    ws.on('message', onData);
+    ws.on('close', (code: number) => {
+        onClose(code);
+    });
+    ws.on('error', (err: Error) => {
+        ws.close();
+        onError(err);
+    });
+}
+
+export function tcpsocketSend(socket: net.Socket, data: Buffer): void {
+    const datalen = data.length;
+    if (socket.writable) {
+        socket.write(
+            Buffer.concat([Buffer.from([datalen >> 8, datalen % 256]), data])
+        );
+    } else {
+        throw new Error('socket cannot writeable!');
+    }
+}
+
+export function websocketSend(ws: WebSocket, data: Buffer): void {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data, { binary: true });
+    } else {
+        throw new Error('ws socket not open!' + ws.readyState);
+    }
+}

package/src/transport/index.ts

@@ -0,0 +1,6 @@
+export { Transport } from './transport';
+export type { TransportType, TransportConn } from './transport';
+export * as creater from './creater';
+export * as helper from './helper';
+
+export { wrapSocket } from './creater';

package/src/transport/transport.ts

@@ -0,0 +1,54 @@
+import WebSocket from 'ws';
+import net from 'net';
+import { websocketSend, tcpsocketSend, bindWebsocket, bindStreamSocket } from './helper';
+import type { DataCallback, ErrorCallback, CloseCallback } from './helper';
+
+export type TransportType = 'ws' | 'h2' | 'tcp' | 'tls' | 'domainsocket';
+
+export interface TransportConn {
+    close?: () => void;
+    destroy?: () => void;
+    writable?: boolean;
+    readyState?: number;
+    send?: Function;
+    on: (event: string, listener: Function) => any;
+    write?: (data: Buffer) => void;
+}
+
+export class Transport {
+    type: TransportType;
+    conn: TransportConn;
+
+    constructor(opts: { type: TransportType; conn: TransportConn }) {
+        this.type = opts.type;
+        this.conn = opts.conn;
+    }
+
+    sendPacket(binarydata: Buffer): void {
+        if (this.type === 'ws') {
+            websocketSend(this.conn as unknown as WebSocket, binarydata);
+        } else {
+            tcpsocketSend(this.conn as unknown as net.Socket, binarydata);
+        }
+    }
+
+    bindEvents(onData: DataCallback, onError: ErrorCallback, onClose: CloseCallback): void {
+        if (this.type === 'ws') {
+            bindWebsocket(this.conn as unknown as WebSocket, onData, onError, onClose);
+        } else {
+            bindStreamSocket(this.conn as any, onData, onError, onClose);
+        }
+    }
+
+    close(): void {
+        try {
+            if (this.type === 'ws' || this.type === 'h2') {
+                (this.conn as any).close();
+            } else {
+                (this.conn as any).destroy();
+            }
+        } catch (_err) {
+            // ignore
+        }
+    }
+}

package/src/uuid.ts

@@ -0,0 +1,37 @@
+const lut: string[] = [];
+for (let i = 0; i < 256; i++) {
+    lut[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+
+function e7(): string {
+    const d0 = (Math.random() * 0xffffffff) | 0;
+    const d1 = (Math.random() * 0xffffffff) | 0;
+    const d2 = (Math.random() * 0xffffffff) | 0;
+    const d3 = (Math.random() * 0xffffffff) | 0;
+    return (
+        lut[d0 & 0xff] +
+        lut[(d0 >> 8) & 0xff] +
+        lut[(d0 >> 16) & 0xff] +
+        lut[(d0 >> 24) & 0xff] +
+        '-' +
+        lut[d1 & 0xff] +
+        lut[(d1 >> 8) & 0xff] +
+        '-' +
+        lut[((d1 >> 16) & 0x0f) | 0x40] +
+        lut[(d1 >> 24) & 0xff] +
+        '-' +
+        lut[(d2 & 0x3f) | 0x80] +
+        lut[(d2 >> 8) & 0xff] +
+        '-' +
+        lut[(d2 >> 16) & 0xff] +
+        lut[(d2 >> 24) & 0xff] +
+        lut[d3 & 0xff] +
+        lut[(d3 >> 8) & 0xff] +
+        lut[(d3 >> 16) & 0xff] +
+        lut[(d3 >> 24) & 0xff]
+    );
+}
+
+export default function uuid(): string {
+    return e7().replace(/-/g, '');
+}

package/.github/workflows/test.yml

@@ -1,30 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: test
-
-on:
-    push:
-        branches: [master]
-    pull_request:
-        branches: [master]
-
-jobs:
-    build:
-        runs-on: ubuntu-latest
-
-        strategy:
-            matrix:
-                node-version: [10.x, 12.x, 14.x, 15.x]
-                # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-        steps:
-            - uses: actions/checkout@v2
-            - name: Use Node.js ${{ matrix.node-version }}
-              uses: actions/setup-node@v1
-              with:
-                  node-version: ${{ matrix.node-version }}
-            - uses: borales/actions-yarn@v2.0.0
-              with:
-                  cmd: install # will run `yarn install` command
-            - run: npm run test

package/.prettierrc

@@ -1,11 +0,0 @@
-{
-  "printWidth": 200,
-  "semi": true,
-  "singleQuote": true,
-  "trailingComma": "all",
-  "bracketSpacing": true,
-  "jsxBracketSameLine": true,
-  "arrowParens": "always",
-  "tabWidth": 4,
-  "useTabs": false
-}

package/test/deferred.js

@@ -1,24 +0,0 @@
-const assert = require('assert');
-const deferred = require('../lib/deferred');
-const { describe } = require('mocha');
-
-describe('deferred', function () {
-    it('test deferred resolve', function () {
-        var defer = deferred();
-        setTimeout(() => {
-            defer.resolve("okok")
-        }, 10);
-        return defer.promise.then(ret => {
-            assert.equal(ret, "okok");
-        });
-    });
-    it('test deferred reject', function () {
-        var defer = deferred();
-        setTimeout(() => {
-            defer.reject("err111");
-        }, 10);
-        return defer.promise.catch(err => {
-            assert.equal(err, "err111")
-        });
-    });
-});

package/test/encrypt.js

@@ -1,25 +0,0 @@
-const assert = require('assert');
-const { describe } = require('mocha');
-const encrypt = require('../lib/encrypt');
-
-describe('encrypt', function () {
-    it('test encrypt example', function () {
-        const worker = new encrypt.Encryptor('csii2019', 'aes-256-cfb');
-
-        const result1 = worker.encrypt(Buffer.from('hello,world'));
-        const result2 = worker.encrypt(Buffer.from('818c9ba2109b4c505155aebf6d3647a3'));
-        const result3 = worker.encrypt(Buffer.from('818c9ba2109b4c505155aebf6d3647a2'));
-
-        // console.log(result1.toString('hex'));
-        // console.log(result2.toString('hex'));
-        // console.log(result3.toString('hex'));
-
-        const desret1 = worker.decrypt(result1).toString();
-        const desret2 = worker.decrypt(result2).toString();
-        const desret3 = worker.decrypt(result3).toString();
-
-        assert.equal(desret1, 'hello,world', 'encrypt example1');
-        assert.equal(desret2, '818c9ba2109b4c505155aebf6d3647a3');
-        assert.equal(desret3, '818c9ba2109b4c505155aebf6d3647a2');
-    });
-});

package/test/md5.js

@@ -1,9 +0,0 @@
-const assert = require('assert');
-const md5 = require('../lib/md5');
-const { describe } = require('mocha');
-
-describe('md5', function () {
-    it('test md5 example', function () {
-        assert.equal(md5('admin'), '21232f297a57a5a743894a0e4a801fc3');
-    });
-});

package/test/merge.js

@@ -1,11 +0,0 @@
-const assert = require('assert');
-const merge = require('../lib/merge');
-const { describe } = require('mocha');
-
-describe('socks5', function () {
-    it('test object merge', function () {
-        var obj = merge({ sss: 1 }, { sss: 123 }, { bb: 456 }, { sss: null });
-        assert.equal(obj.sss, 123);
-        assert.equal(obj.bb, 456);
-    });
-});

package/test/retry.js

@@ -1,61 +0,0 @@
-const assert = require('assert');
-const retry = require('../lib/retry');
-const { describe } = require('mocha');
-
-describe('retry', function () {
-    it('test retry max count', function () {
-        const awaitErrorTask = () => {
-            return new Promise((s, reject) => reject('xxxxxx'));
-        }
-        return retry(awaitErrorTask).then(() => {
-            throw Error("unexcept exec");
-        }).catch(err => {
-            assert.equal("expect retryCount 5 is attached!", err.message);
-        });
-
-    });
-
-    it('test retry custom max count', function () {
-        let maxcount = 10;
-        const taskfn = () => {
-            return new Promise((s, reject) => reject('err'));
-        }
-        return retry(taskfn, { times: maxcount }).then(() => {
-            throw Error("unexcept exec");
-        }).catch(err => {
-            assert.equal("expect retryCount 10 is attached!", err.message);
-        });
-    });
-
-    it('test retry errorcall', function () {
-        let maxcount = 10;
-        let start = 0;
-        const taskfn = () => {
-            start++;
-            return new Promise((s, reject) => reject(Error('retryerr:' + start)));
-        }
-        return retry(taskfn, { times: maxcount }, function (err) {
-            assert.equal("retryerr:" + start, err.message);
-        }).then(() => {
-            throw Error("unexcept exec");
-        }).catch(err => {
-            assert.equal("expect retryCount 10 is attached!", err.message);
-        });
-    });
-
-    it('test retry interval args', function (done) {
-        let start = 0;
-        const taskfn = () => {
-            start++;
-            return new Promise((s, reject) => reject(Error('retryerr:' + start)));
-        }
-        let startTime =Date.now();
-        retry(taskfn, { interval: 100 }, function (err) {
-            assert.equal("retryerr:" + start, err.message);
-        }).catch(err => {
-            assert.equal(Date.now()-startTime > 5*100,true);
-            assert.equal("expect retryCount 5 is attached!", err.message);
-            done();
-        });
-    });
-});

package/test/socks5.js

@@ -1,42 +0,0 @@
-const assert = require('assert');
-const socks5 = require('../lib/socks5');
-const { describe } = require('mocha');
-
-describe('socks5', function () {
-
-    it('test socks5 parse ip example', function () {
-        const obj1 = socks5.parseSocks5Addr(Buffer.from('010102040822c3', 'hex'));
-        assert.equal(obj1.dstAddr, '1.2.4.8');
-        assert.equal(obj1.dstPort, 8899);
-
-        const obj2 = socks5.parseSocks5Addr(Buffer.from('01b53abd171566', 'hex'));
-        assert.equal(obj2.dstAddr, '181.58.189.23');
-        assert.equal(obj2.dstPort, 5478);
-    });
-
-    it('test socks5 parse domain example', function () {
-        const obj1 = socks5.parseSocks5Addr(Buffer.from('030d7777772e62616964752e636f6d044b', 'hex'));
-        assert.equal(obj1.dstAddr, 'www.baidu.com');
-        assert.equal(obj1.dstPort, 1099);
-
-        const obj2 = socks5.parseSocks5Addr(Buffer.from('03196b6566646b612e313233312e6131323362616964752e636f6dfffe', 'hex'));
-        assert.equal(obj2.dstAddr, 'kefdka.1231.a123baidu.com');
-        assert.equal(obj2.dstPort, 65534);
-    });
-
-    it('test socks5 build  ipv4 example', function () {
-        const buf1 = socks5.buildSocks5Addr("1.2.4.8",8899);
-        assert.equal(buf1.toString('hex'), '010102040822c3');
-        const buf2 = socks5.buildSocks5Addr("181.58.189.23",5478);
-        assert.equal(buf2.toString('hex'), '01b53abd171566');
-    });
-
-    it('test socks5 build  domain example', function () {
-        const buf1 = socks5.buildSocks5Addr("www.baidu.com",1099);
-        assert.equal(buf1.toString('hex'), '030d7777772e62616964752e636f6d044b');
-        const buf2 = socks5.buildSocks5Addr("kefdka.1231.a123baidu.com",65534);
-        assert.equal(buf2.toString('hex'), '03196b6566646b612e313233312e6131323362616964752e636f6dfffe');
-    });
-
-    
-});

package/test/uuid.js

@@ -1,11 +0,0 @@
-const assert = require('assert');
-const uuid = require('../lib/uuid');
-const { describe } = require('mocha');
-const reg = /^(\{){0,1}[0-9a-fA-F]{8}[0-9a-fA-F]{4}[0-9a-fA-F]{4}[0-9a-fA-F]{4}[0-9a-fA-F]{12}(\}){0,1}$/;
-
-describe('uuid', function () {
-    it('test uuid example', function () {
-        const uid = uuid();
-        assert.equal(reg.test(uid), true);
-    });
-});