fib-pool 1.5.4 → 1.6.1

package/.travis.yml

@@ -26,6 +26,15 @@ matrix:
     - os: linux
       env:
         - VERSION=0.27.0
+    - os: linux
+      env:
+        - VERSION=0.28.0
+    - os: linux
+      env:
+        - VERSION=0.29.0
+    - os: linux
+      env:
+        - VERSION=0.30.0
     - os: osx
       osx_image: xcode9
       env:
@@ -58,6 +67,18 @@ matrix:
       osx_image: xcode9
       env:
         - VERSION=0.27.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.28.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.29.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.30.0
 before_install:
   - OS=linux
   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then

package/appveyor.yml

@@ -9,6 +9,9 @@ environment:
     - VERSION: 0.26.0
     - VERSION: 0.26.1
     - VERSION: 0.27.0
+    - VERSION: 0.28.0
+    - VERSION: 0.29.0
+    - VERSION: 0.30.0
 
 install:
   - ps: Install-Product node $env:nodejs_version

package/lib/index.js

@@ -1,13 +1,13 @@
+"use strict";
 const coroutine = require("coroutine");
 const util = require("util");
-const timers_1 = require("timers");
 function ensureError(e) {
     if (typeof e === 'string')
         e = new Error(e);
     return e;
 }
-const Pool = function (_opt, maxsize, timeout) {
-    var opt = _opt;
+module.exports = function GetPool(_opt, maxsize, timeout) {
+    let opt = _opt;
     if (util.isFunction(_opt)) {
         opt = {
             create: _opt,
@@ -15,8 +15,8 @@ const Pool = function (_opt, maxsize, timeout) {
             timeout: timeout
         };
     }
-    var create = opt.create;
-    var destroy = opt.destroy || ((o) => {
+    const create = opt.create;
+    const destroy = opt.destroy || ((o) => {
         if (util.isFunction(o.close))
             o.close();
         if (util.isFunction(o.destroy))
@@ -26,19 +26,19 @@ const Pool = function (_opt, maxsize, timeout) {
     });
     maxsize = opt.maxsize || 10;
     timeout = opt.timeout || 60000;
-    var tm = timeout / 10;
+    let tm = timeout / 10;
     if (tm < 10)
         tm = 10;
-    var retry = opt.retry || 1;
-    var pools = [];
-    var jobs = [];
-    var count = 0;
-    var running = 0;
-    var sem = new coroutine.Semaphore(maxsize);
-    var clearTimer;
+    const retry = opt.retry || 1;
+    let pools = [];
+    const jobs = [];
+    let count = 0;
+    let running = 0;
+    const sem = new coroutine.Semaphore(maxsize);
+    let clearTimer;
     function clearPool() {
-        var c;
-        var d = new Date().getTime();
+        let c;
+        const d = new Date().getTime();
         while (count) {
             c = pools[0];
             if (d - c.time.getTime() > timeout) {
@@ -57,12 +57,12 @@ const Pool = function (_opt, maxsize, timeout) {
             }
         }
         else if (!clearTimer)
-            clearTimer = timers_1.setInterval(clearPool, tm);
+            clearTimer = setInterval(clearPool, tm);
     }
     function putback(name, o, e) {
         e = ensureError(e);
-        for (var i = 0; i < jobs.length; i++) {
-            var job = jobs[i];
+        for (let i = 0; i < jobs.length; i++) {
+            const job = jobs[i];
             if (job.name === name) {
                 jobs.splice(i, 1);
                 job.o = o;
@@ -79,15 +79,16 @@ const Pool = function (_opt, maxsize, timeout) {
             };
     }
     function connect(name) {
-        var o;
-        var cn = 0;
-        var err;
+        let o;
+        let cn = 0;
+        let err;
         while (true) {
             try {
                 o = create(name);
                 break;
             }
             catch (e) {
+                console.log(e);
                 if (++cn >= retry) {
                     err = e;
                     break;
@@ -96,21 +97,18 @@ const Pool = function (_opt, maxsize, timeout) {
         }
         putback(name, o, err);
     }
-    var pool = (...args) => {
-        var _name = args[0];
-        var func = args[1];
-        var name = _name;
-        if (util.isFunction(_name)) {
-            func = _name;
+    const pool = (name, func) => {
+        if (typeof name === 'function') {
+            func = name;
             name = "";
         }
-        var r;
-        var o;
-        var p = false;
+        let r;
+        let o;
+        let p = false;
         clearPool();
         sem.acquire();
         if (count) {
-            for (var i = count - 1; i >= 0; i--)
+            for (let i = count - 1; i >= 0; i--)
                 if (pools[i].name === name) {
                     p = true;
                     o = pools[i].o;
@@ -121,7 +119,7 @@ const Pool = function (_opt, maxsize, timeout) {
         }
         if (!p) {
             coroutine.start(connect, name);
-            var job = {
+            const job = {
                 name: name,
                 ev: new coroutine.Event()
             };
@@ -150,22 +148,17 @@ const Pool = function (_opt, maxsize, timeout) {
         }
         return r;
     };
-    pool.connections = () => {
-        return count;
-    };
-    pool.info = () => {
-        return {
-            maxsize: maxsize,
-            count: count,
-            running: running,
-            wait: sem.count(),
-            timeout: timeout
-        };
-    };
+    pool.connections = () => count;
+    pool.info = () => ({
+        maxsize: maxsize,
+        count: count,
+        running: running,
+        wait: sem.count(),
+        timeout: timeout
+    });
     pool.clear = () => {
         timeout = -1;
         clearPool();
     };
     return pool;
 };
-module.exports = Pool;

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "fib-pool",
-    "version": "1.5.4",
+    "version": "1.6.1",
     "description": "Generic resource pooling for fibjs",
     "main": "./lib",
-    "types": "@types/index.d.ts",
+    "types": "typings/index.d.ts",
     "repository": "git://github.com/fibjs/fib-pool.git",
     "author": "Liu Hu <lion@9465.net>",
     "contributors": [
@@ -20,7 +20,7 @@
         "fibjs"
     ],
     "scripts": {
-        "build": "fib-typify src -o lib",
+        "build": "ftsc ./src/* --outDir lib",
         "test": "fibjs test",
         "ci": "npm run build && npm run test",
         "prepublishOnly": "npm run build"
@@ -28,7 +28,7 @@
     "devDependencies": {
         "@fibjs/ci": "^2.3.0",
         "@fibjs/types": "^0.27.1",
-        "fib-typify": "^0.6.0"
+        "fib-typify": "^0.8.4"
     },
     "ci": {
         "type": "travis, appveyor",
@@ -40,7 +40,10 @@
             "0.25.0",
             "0.26.0",
             "0.26.1",
-            "0.27.0"
+            "0.27.0",
+            "0.28.0",
+            "0.29.0",
+            "0.30.0"
         ]
     }
 }

package/tsconfig.json

@@ -3,6 +3,11 @@
         "target": "es6",
         "module": "commonjs",
         "alwaysStrict": false,
-        "removeComments": true
+        "removeComments": true,
+        "declaration": true,
+        "declarationDir": "typings",
+        "types": [
+            "@fibjs/types"
+        ]
     }
 }

package/typings/index.d.ts

@@ -0,0 +1,41 @@
+declare namespace FibPoolNS {
+    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never;
+    interface DippedItemStruct {
+        close?: FibPoolOptionResult['destroy'];
+        destroy?: FibPoolOptionResult['destroy'];
+        dispose?: FibPoolOptionResult['destroy'];
+    }
+    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
+        create: (name: string) => T;
+        destroy?: (item?: T) => any;
+        maxsize?: number;
+        timeout?: number;
+        retry?: number | boolean;
+    }
+    interface FibPoolOptionResult<T extends DippedItemStruct = {}> {
+        create: FibPoolOptionArgs<T>['create'];
+        destroy: FibPoolOptionArgs<T>['destroy'];
+        maxsize: FibPoolOptionArgs<T>['maxsize'];
+        timeout: FibPoolOptionArgs<T>['timeout'];
+        retry: FibPoolOptionArgs<T>['retry'];
+    }
+    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
+        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN;
+    }
+    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
+        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
+        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
+    } & {
+        connections?(): number;
+        info?(): {
+            maxsize: number;
+            count: number;
+            running: number;
+            wait: number;
+            timeout: number;
+        };
+        clear?(): void;
+    };
+}
+declare const _default: <T_CREATED_ITEM extends FibPoolNS.DippedItemStruct, T_POOL_FUNC_RETURN>(_opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | ((name: string) => T_CREATED_ITEM), maxsize?: number, timeout?: number) => FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
+export = _default;

package/@types/index.d.ts

@@ -1,75 +0,0 @@
-/// <reference types="@fibjs/types" />
-
-declare namespace FibPoolNS {
-    interface FibPoolInfo {
-        maxsize: number;
-        count: number;
-        // boolean-type number
-        running: number;
-        wait: number;
-        timeout: number;
-    }
-
-    interface FibPoolOptionCreator<T = FibPoolPayloadObject> {
-        (name: string): T;
-    }
-    interface FibPoolOptionDestoryor<T = any> {
-        (item?: T): void;
-    }
-    type FibPoolRetryCountType = number | boolean
-    interface FibPoolOptionArgs<T = any> {
-        create?: FibPoolOptionCreator
-        destroy?: FibPoolOptionDestoryor<T>
-        maxsize?: number
-        timeout?: number
-        retry?: FibPoolRetryCountType
-    }
-    interface FibPoolOptionResult {
-        create: FibPoolOptionCreator
-        destroy: FibPoolOptionDestoryor
-        maxsize: number
-        timeout: number
-        retry: FibPoolRetryCountType
-    }
-    type FibPoolOptsArg = FibPoolOptionArgs | FibPoolOptionCreator
-
-    type FibPoolPayloadObject = any
-    interface FibPoolUnit<T = FibPoolPayloadObject> {
-        o: T;
-        name: string;
-        time: Date;
-    }
-    type FibPoolInnerJobName = string;
-    interface FibPoolInnerJob<T = FibPoolPayloadObject> {
-        name: FibPoolInnerJobName;
-        ev: Class_Event;
-        o?: T;
-        // Error
-        e?: FibPoolInnerErr;
-    }
-    type FibPoolInnerErr = Error;
-
-    interface FibPoolDipperFn<DippedItem = FibPoolPayloadObject, RETURN_TYPE = any> {
-        (o: DippedItem): RETURN_TYPE
-    }
-    type FibPoolCallback<T = any, T2 = any> = FibPoolDipperFn<T, T2>
-
-    interface FibPoolFunction<DippedItem = FibPoolPayloadObject, RETURN_TYPE = any> {
-        (name: string, o: FibPoolCallback<DippedItem, RETURN_TYPE>): RETURN_TYPE
-        (o: FibPoolCallback<DippedItem, RETURN_TYPE>): RETURN_TYPE
-        connections?(): number;
-        info?(): FibPoolInfo; 
-        clear?(): void;
-    }
-    interface FibPoolObjectToExtract {
-        close?: FibPoolOptionResult['destroy'] | Function;
-        destroy?: FibPoolOptionResult['destroy'] | Function;
-        dispose?: FibPoolOptionResult['destroy'] | Function;
-    }
-
-    function FibPoolGenerator<DippedItem = FibPoolPayloadObject> (opt: FibPoolOptsArg, maxsize?: number, timeout?: number): FibPoolNS.FibPoolFunction<DippedItem>;
-}
-
-declare module "fib-pool" {
-    export = FibPoolNS.FibPoolGenerator
-}

package/test/fixtures/block-avoid.js

@@ -1,16 +0,0 @@
-var Pool = require('../../')
-var co = require('coroutine')
-
-var p = Pool(() => {
-  throw new Error('Test create error')
-}, 11);
-
-co.parallel(() => {
-  try {
-    p((pooled) => {
-      console.log('tx operation: pooled value = %s', pooled)
-    })
-  } catch(e) {
-    console.log("Can't get pooled object - %s", e)
-  }
-}, p.info().maxsize /* 11 */ );

package/test/fixtures/block.js

@@ -1,23 +0,0 @@
-var Pool = require('../../')
-var co = require('coroutine')
-
-var p = Pool(() => {
-  throw new Error('Test create error')
-});
-
-// uncomment below to see fibers before process exit.
-// var timer;
-// timer = setInterval(() => {
-//     console.log('current fibers', co.fibers)
-//     clearInterval(timer);
-// }, 1000)
-
-co.parallel(() => {
-  try {
-    p((pooled) => {
-      console.log('tx operation: pooled value = %s', pooled)
-    })
-  } catch(e) {
-    console.log("Can't get pooled object - %s", e)
-  }
-}, 10);

package/test/index.js

@@ -1,436 +0,0 @@
-var test = require("test");
-test.setup();
-
-var coroutine = require("coroutine");
-
-var Pool = require("../lib");
-
-describe("pool", () => {
-    it("run", () => {
-        var p = Pool(() => {
-            return 10;
-        });
-
-        assert.equal(p((v) => {
-            return v + 1;
-        }), 11);
-    });
-
-    it("pool", () => {
-        var n = 0;
-        var running = -1;
-
-        var p = Pool(() => {
-            n++;
-            return n;
-        });
-
-        assert.equal(p((v) => {
-            running = p.info().running;
-            return v + 1;
-        }), 2);
-
-        assert.equal(running, 1);
-        assert.equal(p.info().running, 0);
-    });
-
-    it("maxsize", () => {
-        var n = 0;
-        var m = 0;
-
-        var p = Pool(() => {
-            // n++;
-            return n;
-        }, 10);
-
-        coroutine.parallel(() => {
-            p((c) => {
-                n++;
-                if (n > m)
-                    m = n;
-                coroutine.sleep(50);
-                n--;
-            });
-        }, 20);
-
-        assert.equal(m, 10);
-    });
-
-    it("name", () => {
-        var n = 0;
-
-        var p = Pool((name) => {
-            n++;
-            return name;
-        });
-
-        assert.equal(n, 0);
-
-        assert.equal(p('a', (v) => {
-            return v;
-        }), 'a');
-
-        assert.equal(n, 1);
-
-        assert.equal(p('b', (v) => {
-            return v;
-        }), 'b');
-
-        assert.equal(n, 2);
-
-        assert.equal(p('a', (v) => {
-            return v;
-        }), 'a');
-
-        assert.equal(n, 2);
-    });
-
-    it("throw", () => {
-        var n = 0;
-        var running = -1;
-
-        var p = Pool(() => {
-            n++;
-            return n;
-        });
-
-        assert.equal(p((v) => {
-            return v + 1;
-        }), 2);
-
-        assert.throws(() => {
-            p((v) => {
-                running = p.info().running;
-                throw "error";
-            });
-        });
-        assert.equal(running, 1);
-        assert.equal(p.info().running, 0);
-
-        assert.equal(p((v) => {
-            return v + 1;
-        }), 3);
-    });
-
-    it("async close when throw", () => {
-        var called = false;
-
-        var p = Pool({
-            create: () => {
-                return 100;
-            },
-            destroy: (o) => {
-                called = true;
-            }
-        });
-
-        assert.throws(() => {
-            p((v) => {
-                throw "error";
-            });
-        });
-
-        assert.isFalse(called);
-        coroutine.sleep(10);
-        assert.isTrue(called);
-    });
-
-    it("default close function", () => {
-        var called = false;
-
-        var p = Pool({
-            create: () => {
-                return {
-                    close: () => {
-                        called = true;
-                    }
-                };
-            }
-        });
-
-        assert.throws(() => {
-            p((v) => {
-                throw "error";
-            });
-        });
-
-        assert.isFalse(called);
-        coroutine.sleep(10);
-        assert.isTrue(called);
-    });
-
-    it("default destroy function", () => {
-        var called = false;
-
-        var p = Pool({
-            create: () => {
-                return {
-                    destroy: () => {
-                        called = true;
-                    }
-                };
-            }
-        });
-
-        assert.throws(() => {
-            p((v) => {
-                throw "error";
-            });
-        });
-
-        assert.isFalse(called);
-        coroutine.sleep(10);
-        assert.isTrue(called);
-    });
-
-
-    it("default destroy function, but destroy is not a function, mongodb3.0 case", () => {
-        var cnt = 0;
-        var p = Pool({
-            create: () => {
-                return {
-                    destroy: ++cnt
-                }
-            }
-        })
-
-        assert.throws(() => {
-            p((v) => {
-                throw "error";
-            });
-        });
-
-        assert.equal(cnt, 1);
-    });
-
-    it("default dispose function", () => {
-        var called = false;
-
-        var p = Pool({
-            create: () => {
-                return {
-                    dispose: () => {
-                        called = true;
-                    }
-                };
-            }
-        });
-
-        assert.throws(() => {
-            p((v) => {
-                throw "error";
-            });
-        });
-
-        assert.isFalse(called);
-        coroutine.sleep(10);
-        assert.isTrue(called);
-    });
-
-    it("clean timeout", () => {
-        var called = false;
-
-        var p = Pool({
-            create: () => {
-                return 100;
-            },
-            destroy: (o) => {
-                called = true;
-            },
-            timeout: 10
-        });
-
-        p((v) => {});
-
-        assert.isFalse(called);
-        assert.equal(p.connections(), 1);
-        coroutine.sleep(100);
-        assert.isTrue(called);
-        assert.equal(p.connections(), 0);
-    });
-
-    it("retry", () => {
-        var n = 0;
-
-        var p = Pool(() => {
-            n++;
-            throw "open error";
-        });
-
-        assert.throws(() => {
-            p((v) => {});
-        });
-
-        assert.equal(n, 1);
-
-        var n1 = 0;
-        var p1 = Pool({
-            create: () => {
-                n1++;
-                throw "open error";
-            },
-            retry: 10
-        });
-
-        assert.throws(() => {
-            p1((v) => {});
-        });
-
-        assert.equal(n1, 10);
-
-        var n2 = 0;
-        var p2 = Pool({
-            create: () => {
-                n2++;
-                if (n2 == 3)
-                    return;
-                throw "open error";
-            },
-            retry: 10
-        });
-
-        p2((v) => {});
-
-        assert.equal(n2, 3);
-    });
-
-    it("long time create", () => {
-        var called = 0;
-
-        var p = Pool({
-            create: () => {
-                called++;
-                if (called == 1)
-                    coroutine.sleep(20);
-                return called;
-            }
-        });
-
-        var cs = [];
-        coroutine.parallel([0, 1, 2, 3, 4], n => {
-            p((c) => {
-                coroutine.sleep(1);
-                cs[n] = c;
-            });
-        });
-
-        assert.deepEqual(cs, [2, 3, 4, 5, 2]);
-        assert.equal(p.info().count, 4);
-        coroutine.sleep(100);
-        assert.equal(p.info().count, 5);
-    });
-
-    it("long time fault create", () => {
-        var called = 0;
-
-        var p = Pool({
-            create: () => {
-                called++;
-                if (called == 1) {
-                    coroutine.sleep(20);
-                    throw 100;
-                }
-                return called;
-            }
-        });
-
-        var cs = [];
-        coroutine.parallel([0, 1, 2, 3, 4], n => {
-            p((c) => {
-                coroutine.sleep(1);
-                cs[n] = c;
-            });
-        });
-
-        assert.deepEqual(cs, [2, 3, 4, 5, 2]);
-        assert.equal(p.info().count, 4);
-        coroutine.sleep(100);
-        assert.equal(p.info().count, 4);
-    });
-
-    it("maxsize and create", () => {
-        var createCount = 0,
-            maxsize = 2;
-
-        var p = Pool({
-            create: () => {
-                createCount++;
-                return {};
-            },
-            maxsize: maxsize
-        });
-
-        coroutine.parallel(["a", "b", "c", "d"], n => {
-            p((n) => {
-                coroutine.sleep(50);
-            })
-        });
-
-        assert.equal(createCount, maxsize);
-    });
-
-    it("clear", () => {
-        function parallel(data) {
-            coroutine.parallel(data, function (n) {
-                p((n) => {
-                    coroutine.sleep(50);
-                })
-            });
-        };
-
-        var maxsize = 3;
-
-        var p = Pool({
-            create: () => {
-                return {};
-            },
-            maxsize: maxsize,
-            timeout: 60 * 1000
-        });
-
-        parallel(["a", "b", "c", "d"]);
-
-        assert.equal(p.info().count, maxsize);
-
-        p.clear();
-        coroutine.sleep(100);
-
-        assert.equal(p.info().count, 0);
-
-        parallel(["a"]);
-
-        assert.equal(p.info().count, 0);
-    });
-
-    it("throw real error", () => {
-        var called = false;
-        var destroyed = false;
-
-        var p = Pool({
-            create: () => {
-                return 100;
-            },
-            destroy: (o) => {
-                destroyed = true;
-            }
-        });
-
-        try {
-            p((v) => {
-                throw "error";
-            });
-        } catch (error) {
-            called = true
-            assert.isObject(error)
-            assert.equal(error.message, 'error')
-        }
-
-        assert.isTrue(called);
-
-        assert.isFalse(destroyed);
-        coroutine.sleep(10);
-        assert.isTrue(destroyed);
-    });
-});
-
-process.exit(test.run(console.DEBUG));