@bbk47/toolbox 1.0.6 → 1.0.8

package/README.md

@@ -13,4 +13,6 @@ A tool library for bbk/abc
 - md5 encrypt
 - socks5 addr parse and build
 - uuid util
-- merge object
+- merge function
+- deferred function
+- retry function

package/lib/deferred.js

@@ -0,0 +1,8 @@
+module.exports = function deferred(){
+    const defer = {};
+    defer.promise = new Promise((resolve,reject)=>{
+        defer.resolve=resolve;
+        defer.reject=reject;
+    });
+    return defer;
+}

package/lib/index.js

@@ -3,4 +3,10 @@ exports.logger = require('./logger');
 exports.md5 = require('./md5');
 exports.socks5 = require('./socks5');
 exports.uuid = require('./uuid');
-exports.progress = require('./progress');
+exports.retry = require('./retry');
+exports.deferred = require('./deferred');
+exports.merge = require('./merge');
+exports.timeout = require('./timeout');
+exports.transport = require('./transport');
+exports.proxy = require('./proxy');
+exports.server = require('./server');

package/lib/logger.js

@@ -15,13 +15,10 @@ function getCustomLogger(label, level) {
     function getter(target, key, handler) {
         if (levelVal[key].piv <= setPiv) {
             const colour = levelVal[key].colour;
-            return function () {
-                let args = [].slice.call(arguments);
+            return function (msg) {
                 let date = dateFormat('yyyy/MM/dd hh:mm:ss', new Date());
                 var prefix = `${date} [${key[0].toUpperCase()}] ${label} `;
-                // console.log(colour, prefix, msg);
-                args.unshift(colour,prefix);
-                console.log.apply(console, args);
+                console.log(colour, prefix, msg);
             };
         } else {
             return noop;

package/lib/merge.js

@@ -1,29 +1,18 @@
-function factory(overide) {
-    return function assign(target) {
-        target = target || {};
-        var args = [].slice.call(arguments, 1);
-        args.forEach((temp) => {
-            if (temp) {
-                Object.keys(temp).forEach((key) => {
-                    if (overide) {
-                        target[key] = temp[key];
-                    } else if (temp[key]) {
-                        target[key] = temp[key];
-                    }
-                });
-            }
-        });
-        return target;
-    };
-}
-
 function merge(target) {
-    return factory(false).apply(target, arguments);
+    target = target || {};
+    var args = [].slice.call(arguments, 1);
+    args.forEach((temp) => {
+        if (temp) {
+            Object.keys(temp).forEach((key) => {
+                if (temp[key]) {
+                    target[key] = temp[key];
+                }
+            });
+        }
+    });
+    return target;
 }
 
-function assign(target) {
-    return factory(true).apply(target, arguments);
-}
+module.exports = merge;
 
-exports.objectMerge = merge;
-exports.objectAssign = assign;
+// console.log(merge({}, { sss: 123 }, { bb: 456 },{sss:null}));

package/lib/proxy.js

@@ -0,0 +1,62 @@
+const net = require('net');
+const socks5 = require('./socks5');
+
+exports.createSocks5Proxy = function (cSock, onConnect) {
+    var stage = 'INIT';
+    cSock.on('data', function dataListener(data) {
+        if (stage === 'INIT') {
+            cSock.write('\x05\x00');
+            stage = 'ADDR';
+            return;
+        } else if (stage === 'ADDR') {
+            onConnect(data.slice(3), (err) => {
+                if (!err) {
+                    stage = 'STREAM';
+                    cSock.write('\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00');
+                    cSock.removeAllListeners('data');
+                    cSock.pause(); // for pipe start stream
+                } else {
+                    cSock.destroy();
+                }
+            });
+            return;
+        }
+    });
+
+    cSock.on('error', function (error) {
+        cSock.destroy();
+    });
+};
+
+exports.createConnectProxy = function (cSock, onConnect) {
+    var stage = 'INIT';
+    cSock.on('data', (data) => {
+        if (stage === 'INIT') {
+            const str = data.toString('ascii');
+            const lines = str.split(/\s/g);
+            if (lines[0] !== 'CONNECT') {
+                cSock.destroy();
+                return;
+            }
+            const hoststr = lines[1];
+            const reqhost = hoststr.split(':');
+            const hostname = reqhost[0];
+            const port = Number(reqhost[1]);
+            const socksAddrInfo = socks5.buildSocks5Addr(hostname, port);
+            onConnect(socksAddrInfo, (err) => {
+                if (!err) {
+                    cSock.write(Buffer.from('HTTP/1.1 200 Connection Established\r\n\r\n'));
+                    stage = 'STREAM';
+                    cSock.removeAllListeners('data');
+                    cSock.pause(); // for pipe start stream
+                } else {
+                    cSock.destroy();
+                }
+            });
+        }
+    });
+
+    cSock.on('error', function (error) {
+        cSock.destroy();
+    });
+};

package/lib/retry.js

@@ -0,0 +1,25 @@
+var timeoutPromise = (time) =>
+    new Promise((resolve) => setTimeout(resolve, time));
+
+function retryPromise(fn, opts = {}, errcall) {
+    var retryCount = opts.times || 5;
+
+    function invoker(idx) {
+        if (idx >= retryCount) {
+            return Promise.reject(
+                Error(`expect retryCount ${retryCount} is attached!`)
+            );
+        }
+        return fn.call(null).catch((err) => {
+            errcall && errcall(err);
+            if (opts.interval) {
+                return timeoutPromise(opts.interval).then(() => invoker(idx + 1));
+            } else {
+                return invoker(idx + 1);
+            }
+        });
+    }
+    return invoker(0);
+}
+
+module.exports = retryPromise;

package/lib/server.js

@@ -0,0 +1,61 @@
+const net = require('net');
+const http = require('http');
+const tls = require('tls');
+const http2 = require('http2');
+const url = require('url');
+const WebSocket = require('ws');
+
+exports.createWsServer = function (workPath, handler, httpHandler) {
+    const server = http.createServer(function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    const wss = new WebSocket.Server({ noServer: true, clientTracking: false });
+    wss.on('connection', function (wsconn) {
+        handler(wsconn);
+    });
+    server.on('upgrade', function (request, socket, head) {
+        const pathname = url.parse(request.url).pathname;
+        if (pathname === workPath) {
+            wss.handleUpgrade(request, socket, head, function done(ws) {
+                wss.emit('connection', ws, request);
+            });
+        } else {
+            socket.destroy();
+        }
+    });
+    return server;
+};
+
+exports.createHttp2Server = function (tlsOpts, workPath, handler, httpHandler) {
+    const http2Opts = Object.assign({ allowHTTP1: true }, tlsOpts);
+    const server = http2.createSecureServer(http2Opts, function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    server.on('stream', function (stream, headers) {
+        const path = headers[':path'];
+        if (path === workPath) {
+            handler(stream);
+        } else {
+            stream.destroy();
+        }
+    });
+    return server;
+};
+
+exports.createTcpServer = function (handler) {
+    const server = net.createServer(function (conn) {
+        handler(conn);
+    });
+    return server;
+};
+
+exports.createTlsServer = function (tlsOpts, handler) {
+    const server = tls.createServer(tlsOpts, function (conn) {
+        handler(conn);
+    });
+    return server;
+};

package/lib/timeout.js

@@ -0,0 +1,3 @@
+const timeoutPromise = (time) => new Promise((resolve) => setTimeout(() => resolve('timeout:' + time), time));
+
+exports.timeoutPromise = timeoutPromise;

package/lib/transport/creater.js

@@ -0,0 +1,64 @@
+const WebSocket = require('ws');
+const net = require('net');
+const http2 = require('http2');
+const tls = require('tls');
+
+const Transport = require('./transport');
+
+exports.createWebsocketTransport = function (params, onOpen) {
+    let tunnelWsUrl = `${params.secure ? 'wss' : 'ws'}://${params.host}:${params.port}${params.path}`;
+    const ws = new WebSocket(tunnelWsUrl, { perMessageDeflate: false, handshakeTimeout: 3000 });
+    const ts = new Transport({ type: 'ws', conn: ws });
+    ws.on('open', onOpen);
+    return ts;
+};
+
+exports.createHttp2Transport = function (params, onOpen) {
+    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 });
+    return ts;
+};
+
+exports.createTlsTransport = function (params, onOpen) {
+    const tlsOpts = {
+        rejectUnauthorized: false,
+        host: params.host,
+        port: params.port,
+    };
+    const tlsConn = tls.connect(tlsOpts, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'tls', conn: tlsConn });
+    return ts;
+};
+
+exports.createTcpTransport = function (params, onOpen) {
+    const socket = new net.Socket();
+    socket.connect(params.port, params.host, function () {
+        onOpen();
+    });
+    return new Transport({ type: 'tcp', conn: socket });
+};
+
+exports.createUnixsocketTransport = function (params, onOpen) {
+    const socket = new net.Socket();
+    socket.connect(params.path, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'domainsocket', conn: socket });
+    return ts;
+};
+
+exports.wrapSocket = function (type, conn) {
+    return new Transport({ type, conn });
+};

package/lib/transport/helper.js

@@ -0,0 +1,62 @@
+const WebSocket = require('ws');
+
+function bindStreamSocket(stream, onData, onError, onClose) {
+    var buffcache = Buffer.from([]);
+    stream.on('data', function (data) {
+        buffcache = Buffer.concat([buffcache, data]);
+        var datalen = 0;
+        var pack;
+        while (true) {
+            if (buffcache.length <= 2) {
+                return;
+            }
+            datalen = buffcache[0] * 256 + buffcache[1];
+            if (buffcache.length < datalen + 2) {
+                return;
+            }
+            pack = buffcache.slice(2, datalen + 2);
+            buffcache = buffcache.slice(datalen + 2);
+            onData(pack);
+        }
+    });
+    stream.on('close', function (code) {
+        onClose(code);
+    });
+    stream.on('error', function (err) {
+        stream.destroy();
+        onError(err);
+    });
+}
+
+function bindWebsocket(ws, onData, onError, onClose) {
+    ws.on('message', onData);
+    ws.on('close', (code) => {
+        onClose(code);
+    });
+    ws.on('error', (err) => {
+        ws.close();
+        onError(err);
+    });
+}
+
+function tcpsocketSend(socket, data) {
+    var datalen = data.length;
+    if (socket.writable) {
+        socket.write(Buffer.concat([Buffer.from([datalen >> 8, datalen % 256]), data]));
+    } else {
+        throw Error('socket cannot writeable!');
+    }
+}
+
+function websocketSend(ws, data) {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data, { binary: true });
+    } else {
+        throw Error('ws socket not open!' + ws.readyState);
+    }
+}
+
+exports.websocketSend = websocketSend;
+exports.tcpsocketSend = tcpsocketSend;
+exports.bindStreamSocket = bindStreamSocket;
+exports.bindWebsocket = bindWebsocket;

package/lib/transport/index.js

@@ -0,0 +1,11 @@
+const Transport = require('./transport');
+const creater = require('./creater');
+const helper = require('./helper');
+
+exports.Transport = Transport;
+exports.creater = creater;
+exports.helper = helper;
+
+exports.wrapSocket = function (type, conn) {
+    return new Transport({ type, conn });
+};

package/lib/transport/transport.js

@@ -0,0 +1,38 @@
+const { websocketSend, tcpsocketSend, bindWebsocket, bindStreamSocket } = require('./helper');
+
+class Transport {
+    constructor(opts) {
+        this.type = opts.type;
+        this.conn = opts.conn;
+    }
+
+    sendPacket(binarydata) {
+        if (this.type === 'ws') {
+            websocketSend(this.conn, binarydata);
+        } else {
+            tcpsocketSend(this.conn, binarydata);
+        }
+    }
+
+    bindEvents(onData, onError, onClose) {
+        if (this.type === 'ws') {
+            bindWebsocket(this.conn, onData, onError, onClose);
+        } else {
+            bindStreamSocket(this.conn, onData, onError, onClose);
+        }
+    }
+
+    close() {
+        try {
+            if (this.type === 'ws' || this.type === 'h2') {
+                this.conn.close();
+            } else {
+                this.conn.destroy();
+            }
+        } catch (err) {
+            // ignore
+        }
+    }
+}
+
+module.exports = Transport;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bbk47/toolbox",
-    "version": "1.0.6",
+    "version": "1.0.8",
     "description": "toolbox for bbk",
     "main": "lib/index.js",
     "scripts": {
@@ -17,7 +17,8 @@
     },
     "homepage": "https://github.com/bbk47/toolboxjs#readme",
     "dependencies": {
-        "date-format": "^3.0.0"
+        "date-format": "^3.0.0",
+        "ws": "2.3.x"
     },
     "devDependencies": {
         "mocha": "^5.2.0"

package/test/deferred.js

@@ -0,0 +1,24 @@
+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/merge.js

@@ -4,14 +4,8 @@ const { describe } = require('mocha');
 
 describe('socks5', function () {
     it('test object merge', function () {
-        var obj = merge.objectMerge({ sss: 1 }, { sss: 123 }, { bb: 456 }, { sss: null });
+        var obj = merge({ sss: 1 }, { sss: 123 }, { bb: 456 }, { sss: null });
         assert.equal(obj.sss, 123);
         assert.equal(obj.bb, 456);
     });
-
-    it('test object assign', function () {
-        var obj = merge.objectAssign({ sss: 12 }, { sss: 123 }, { bb: 456 }, { sss: null ,bb:789});
-        assert.equal(obj.sss, null);
-        assert.equal(obj.bb, 789);
-    });
 });

package/test/retry.js

@@ -0,0 +1,61 @@
+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/lib/progress.js

@@ -1,34 +0,0 @@
-// const chalk = require('chalk');
-
-var print = {
-    setFormat: function(fn) {
-        this.format = fn || ((result) => 'complete.');
-    },
-    printStatus(result) {
-        if (!this.numOfLinesToClear) {
-            this.numOfLinesToClear = true;
-        } else {
-            process.stdout.moveCursor(0, -1);
-        }
-        process.stdout.clearLine();
-        process.stdout.cursorTo(0);
-        let output = this.format(result);
-        process.stdout.write(output || 'none');
-    },
-};
-
-function progress(formatfn) {
-    var printer = Object.create(print);
-    printer.setFormat(formatfn);
-    return printer;
-}
-
-// var printer = progress((result) => {
-//     return `fetch cve total: ${chalk.cyan(result.total)}, complete:${chalk.green(result.complete)}\n`;
-// });
-
-// for (var i = 0; i < 10000; i++) {
-//     printer.printStatus({ total: 10000, complete: i });
-// }
-
-module.exports = progress;