fib-pool 1.6.2 → 1.7.1

package/Readme.md

@@ -1,8 +1,6 @@
 ## Generic resource pooling for fibjs
 
 [![NPM version](https://img.shields.io/npm/v/fib-pool.svg)](https://www.npmjs.org/package/fib-pool)
-[![Build Status](https://travis-ci.org/fibjs/fib-pool.svg)](https://travis-ci.org/fibjs/fib-pool)
-[![Build status](https://ci.appveyor.com/api/projects/status/p662f7ulpc4asu8s?svg=true)](https://ci.appveyor.com/project/richardo2016/fib-pool)
 
 ## Install
 
@@ -13,7 +11,8 @@ npm install fib-pool [--save]
 ## Test
 
 ```sh
-npm run ci
+npm test        # fibjs test
+npm run typecheck   # fibjs --check, including test/types.ts
 ```
 
 ## Creating a pool
@@ -103,6 +102,60 @@ var res = p("test", (conn) => {
 
 ```
 
+## Options
+
+| option | type | default | notes |
+|---|---|---|---|
+| `create` | `(name) => item` | — | required; throwing is a failure, retried up to `retry` times |
+| `destroy` | `(item) => void` | close/destroy/dispose | defaults to calling whichever of those three the item provides |
+| `maxsize` | positive integer | `10` | caps both concurrency and the number of idle items |
+| `timeout` | positive number (ms) | `60000` | how long an idle item is kept |
+| `retry` | positive integer | `1` | how many times `create` is attempted before giving up |
+| `strict` | boolean | `true` | see below |
+
+The pooled item is unconstrained: `create` may return an object, a class
+instance, a function, or a primitive. The default `destroy` calls whichever of
+`close` / `destroy` / `dispose` the item provides and ignores items that have
+none of them.
+
+```js
+var p = Pool(() => 10);                // a primitive item
+p((v) => v + 1);
+
+var q = Pool(() => ({ value: 1 }));    // a plain object, nothing to destroy
+q((o) => o.value);
+```
+
+Invalid `maxsize`, `timeout` and `retry` values throw a `TypeError` when the
+pool is created rather than being silently coerced:
+
+```js
+Pool({ create: () => ({}), maxsize: 0 });      // TypeError: maxsize must be a positive integer, received 0
+Pool({ create: () => ({}), timeout: -5 });     // TypeError: timeout must be a positive number, received -5
+Pool({ create: () => ({}), retry: true });     // TypeError: retry must be a positive integer, received true
+```
+
+The idle list is capped by `maxsize` as well: a pool used with more names than
+that evicts the least recently used item (and destroys it) instead of keeping
+one idle item per name.
+
+## Reentrancy
+
+A pool cannot be acquired twice from the same fiber. The inner call would wait
+for a permit that the outer call is holding, which never arrives, so it is
+rejected instead of deadlocking:
+
+```js
+var p = Pool({ create: () => ({}), maxsize: 1 });
+
+p(() => {
+    p(() => {}); // Error: Cannot pool again from the same fiber
+});
+```
+
+Nesting different pools, or acquiring the same pool from another fiber, works as
+expected.
+
 ## Strict mode (default: enabled)
 
 By default, the pool uses strict mode to prevent accessing pooled objects outside of the callback function. This helps prevent resource leaks and ensures proper resource management.
@@ -127,9 +180,13 @@ p((obj) => {
 leaked.getValue(); // Error!
 ```
 
-When strict mode is enabled, it also prevents:
+The guarded object behaves like the item for reading and inspection —
+`key in obj`, `Object.keys(obj)`, `for...in`, `JSON.stringify(obj)` and
+`util.inspect(obj)` all report the item's own members — while the guards remain:
+
 - Setting properties on pooled objects
 - Calling `close()`, `destroy()`, or `dispose()` methods directly
+- Extracting a method and calling it after the callback returned
 
 To disable strict mode:
 

package/package.json

@@ -1,18 +1,24 @@
 {
     "name": "fib-pool",
-    "version": "1.6.2",
+    "version": "1.7.1",
     "description": "Generic resource pooling for fibjs",
-    "main": "./src",
-    "types": "typings/index.d.ts",
+    "main": "./src/index.cts",
+    "types": "./src/index.ts",
     "type": "module",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./src/index.ts",
+                "default": "./src/index.ts"
+            },
+            "require": {
+                "types": "./src/index.d.cts",
+                "default": "./src/index.cts"
+            }
+        }
+    },
     "repository": "git://github.com/fibjs/fib-pool.git",
     "author": "Liu Hu <lion@9465.net>",
-    "contributors": [
-        {
-            "name": "Richard",
-            "email": "richardo2016@gmail.com"
-        }
-    ],
     "homepage": "https://github.com/fibjs/fib-pool",
     "license": "MIT",
     "keywords": [
@@ -22,29 +28,6 @@
     ],
     "scripts": {
         "test": "fibjs test",
-        "typecheck": "tsc --noEmit",
-        "ci": "npm run typecheck && npm run test"
-    },
-    "devDependencies": {
-        "@fibjs/ci": "^2.3.0",
-        "@fibjs/types": "^0.27.1",
-        "fib-typify": "^0.8.4",
-        "typescript": "^5.9.3"
-    },
-    "ci": {
-        "type": "travis, appveyor",
-        "version": [
-            "0.21.0",
-            "0.22.0",
-            "0.23.0",
-            "0.24.0",
-            "0.25.0",
-            "0.26.0",
-            "0.26.1",
-            "0.27.0",
-            "0.28.0",
-            "0.29.0",
-            "0.30.0"
-        ]
+        "typecheck": "fibjs --check"
     }
 }

package/src/index.cts

@@ -0,0 +1,18 @@
+/**
+ * CommonJS entry point.
+ *
+ * The pool is implemented in `index.ts` as an ES module, so requiring that
+ * file yields the module namespace object (`{ default, __esModule }`) rather
+ * than the factory. Callers of `require('fib-pool')` expect the export to *be*
+ * the factory function, so this bridge unwraps the default export.
+ *
+ * A static `import` is not an option here: this file is CommonJS, so it must
+ * load the implementation through `require` to get the namespace object.
+ *
+ * `module.exports =` is used instead of `export =` because fibjs runs
+ * TypeScript in strip-only mode, which rejects export assignments. The type of
+ * this file is described by the sibling `index.d.cts`.
+ */
+const impl = require('./index.ts');
+
+module.exports = impl.default;

package/src/index.d.cts

@@ -0,0 +1,3 @@
+import Pool from './index.ts';
+
+export = Pool;

package/src/index.ts

@@ -2,29 +2,36 @@ import * as coroutine from 'coroutine';
 import * as util from 'util';
 
 declare namespace FibPoolNS {
-    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never; 
-
+    /**
+     * The shape the default destroy looks for. All three members are optional:
+     * it calls whichever of them the item actually provides, and a non-function
+     * value (a plain property) is ignored.
+     *
+     * This is deliberately *not* a constraint on the pooled item. Every member
+     * is optional, which makes it a weak type, and TypeScript rejects any type
+     * without a property in common with a weak type. Constraining the item to
+     * it would reject the perfectly valid `Pool(() => 10)` and
+     * `Pool(() => ({ value: 1 }))`, so the constraint is absent and the cast to
+     * this shape happens only inside the default destroy, where a primitive
+     * simply has no such member to call.
+     */
     interface DippedItemStruct {
-        close?: FibPoolOptionResult['destroy'];
-        destroy?: FibPoolOptionResult['destroy'];
-        dispose?: FibPoolOptionResult['destroy'];
+        close?: unknown;
+        destroy?: unknown;
+        dispose?: unknown;
     }
 
-    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
-        create: (name: string) => T
+    /**
+     * `T` is the pooled item and may be anything `create` returns, including a
+     * primitive. It is only inferred, never constrained.
+     */
+    interface FibPoolOptionArgs<T = any> {
+        create: (name: string) => T;
         destroy?: (item?: T) => any;
-        maxsize?: number
-        timeout?: number
-        retry?: number | boolean
-        strict?: 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']
-        strict: FibPoolOptionArgs<T>['strict']
+        maxsize?: number;
+        timeout?: number;
+        retry?: number;
+        strict?: boolean;
     }
 
     interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
@@ -35,62 +42,171 @@ declare namespace FibPoolNS {
         <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?(): {
+        connections(): number;
+        info(): {
             maxsize: number;
             count: number;
             running: number;
             wait: number;
             timeout: number;
-        }; 
-        clear?(): void;
+        };
+        clear(): void;
     }
 }
 
-function ensureError (e: string | Error) {
+/**
+ * Calls the value when it is a function and ignores it otherwise: a pooled item
+ * may expose a plain property named close/destroy/dispose.
+ */
+function callIfFunction(v: unknown) {
+    if (util.isFunction(v))
+        (v as (...args: any[]) => any)();
+}
+
+/**
+ * `maxsize` and `retry` are counts, `timeout` is a duration. Both are rejected
+ * up front instead of being silently coerced into a default or handed to the
+ * semaphore, which would fail far from the option that is wrong.
+ */
+function toPositiveInteger(value: unknown, name: string): number {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0 || Math.floor(value) !== value)
+        throw new TypeError(`${name} must be a positive integer, received ${String(value)}`);
+
+    return value;
+}
+
+function toPositiveNumber(value: unknown, name: string): number {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        throw new TypeError(`${name} must be a positive number, received ${String(value)}`);
+
+    return value;
+}
+
+/**
+ * The pool always hands out an Error: `create` or the callback may throw a
+ * string, a number, or nothing at all, and the caller expects to be able to
+ * read `.message`. A thrown falsy value (0, '', false, null, undefined) is still
+ * a failure and must not be mistaken for a successful create, so this returns an
+ * Error for every input.
+ */
+function toError(e: unknown): Error {
+    if (e instanceof Error)
+        return e;
+
     if (typeof e === 'string')
-        e = new Error(e)
-   
-   return e
+        return new Error(e);
+
+    return new Error(String(e));
+}
+
+/**
+ * Guards a pooled item while the callback runs. The item is read through a
+ * getter rather than captured by value: once it goes back to the pool the
+ * handle must stop working, which is what the "outside of pool scope" error
+ * reports.
+ *
+ * The reflection traps matter as much as the getter: without them `key in obj`,
+ * `Object.keys`, `for...in` and `JSON.stringify` all see the empty proxy target
+ * instead of the item.
+ */
+function wrapStrict<T extends object>(item: () => T | undefined): T {
+    const current = () => {
+        const o = item();
+        if (o === undefined)
+            throw new Error("access object outside of pool scope");
+
+        return o;
+    };
+
+    return new Proxy({}, {
+        get(target, prop) {
+            if (prop === 'close' || prop === 'destroy' || prop === 'dispose')
+                throw new Error("Cannot close/destroy/dispose");
+
+            const o = current();
+            const value = (o as any)[prop];
+            if (typeof value === 'function') {
+                /* the item is resolved again when the method runs: a method
+                   extracted inside the callback and called after it returned
+                   must not keep the item alive outside its scope */
+                return function () {
+                    const self = current();
+                    return (self as any)[prop].apply(self, arguments);
+                }
+            }
+            return value;
+        },
+        has(target, prop) {
+            /* no close/destroy/dispose refusal here: the key is reported like
+               any other (ownKeys lists it too), only reading or calling those
+               members is refused, in `get` */
+            return Reflect.has(current() as object, prop);
+        },
+        ownKeys() {
+            return Reflect.ownKeys(current() as object);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            const d = Reflect.getOwnPropertyDescriptor(current() as object, prop);
+
+            /* every key of the proxy target is configurable: a descriptor that
+               claims otherwise would break the proxy invariants */
+            return d && Object.assign(d, { configurable: true });
+        },
+        set() {
+            throw new Error("Cannot set property");
+        }
+    }) as T;
 }
 
 export default function GetPool<
-    T_CREATED_ITEM extends FibPoolNS.DippedItemStruct,
-    T_POOL_FUNC_RETURN
+    T_CREATED_ITEM,
+    T_POOL_FUNC_RETURN = any
 > (
     _opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>['create'],
     maxsize?: number,
     timeout?: number
 ): FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN> {
     /* clean input arguments :start */
-    let opt = <FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>>_opt;
+    let opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>;
+
     if (util.isFunction(_opt)) {
-        opt = <FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>>{
-            create: _opt,
+        opt = {
+            create: _opt as (name: string) => T_CREATED_ITEM,
             maxsize: maxsize,
             timeout: timeout
         };
+    } else {
+        opt = _opt as FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>;
     }
 
     const create = opt.create;
-    const destroy = opt.destroy || ((o: {
-        close?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
-        destroy?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
-        dispose?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
-    }) => {
-        if (util.isFunction(o.close)) o.close();
-        if (util.isFunction(o.destroy)) o.destroy();
-        if (util.isFunction(o.dispose)) o.dispose();
+    const destroy = opt.destroy || ((o: unknown) => {
+        /* create may return null/undefined or any primitive: there is nothing
+           to destroy then. Functions are kept, since they can carry members. */
+        if (o === null || o === undefined)
+            return;
+
+        if (typeof o !== 'object' && typeof o !== 'function')
+            return;
+
+        const item = o as FibPoolNS.DippedItemStruct;
+
+        callIfFunction(item.close);
+        callIfFunction(item.destroy);
+        callIfFunction(item.dispose);
     });
 
-    maxsize = opt.maxsize || 10;
-    timeout = opt.timeout || 60000;
-    let tm = timeout / 10;
+    const maxsizeValue = opt.maxsize === undefined ? 10 : toPositiveInteger(opt.maxsize, 'maxsize');
+    let timeoutValue = opt.timeout === undefined ? 60000 : toPositiveNumber(opt.timeout, 'timeout');
+
+    /* the idle scan runs at a tenth of the timeout, but never more often than
+       every 10ms */
+    let tm = timeoutValue / 10;
     if (tm < 10)
         tm = 10;
 
-    const retry = opt.retry || 1;
-    const _strict = opt.strict === undefined ? true : opt.strict;
+    const retry = opt.retry === undefined ? 1 : toPositiveInteger(opt.retry, 'retry');
+    const strictMode = opt.strict === undefined ? true : opt.strict;
     /* clean input arguments :end */
 
     let pools = <{
@@ -109,17 +225,16 @@ export default function GetPool<
     let count = 0;
     let running = 0;
 
-    const sem = new coroutine.Semaphore(maxsize);
-    let clearTimer: Class_Timer;
+    const sem = new coroutine.Semaphore(maxsizeValue);
+    let clearTimer: Class_Timer | null = null;
 
     function clearPool() {
-        let c: typeof pools[any];
         const d = new Date().getTime();
 
         while (count) {
-            c = pools[0];
+            const c = pools[0];
 
-            if (d - c.time.getTime() > timeout) {
+            if (d - c.time.getTime() > timeoutValue) {
                 pools = pools.slice(1);
                 count--;
 
@@ -135,18 +250,22 @@ export default function GetPool<
                 clearTimer = null;
             }
         } else if (!clearTimer) {
-            clearTimer = setInterval(clearPool, tm);
-            if (clearTimer && typeof clearTimer.unref === 'function')
-                clearTimer.unref();
+            /* the timer must not hold the process alive: the pool is idle
+               between uses */
+            clearTimer = setInterval(clearPool, tm).unref();
         }
     }
 
+    /**
+     * Hand the item back: wake the first waiter bound to `name`, or park the
+     * item in the idle list. An errored item is never parked, but a successful
+     * create may legitimately produce `undefined` and is parked as is.
+     */
     function putback(
-        name: typeof jobs[any]['name'],
-        o: T_CREATED_ITEM,
+        name: string,
+        o: T_CREATED_ITEM | undefined,
         e?: Error
     ) {
-        e = ensureError(e);
         for (let i = 0; i < jobs.length; i++) {
             const job = jobs[i];
             if (job.name === name) {
@@ -158,26 +277,38 @@ export default function GetPool<
             }
         }
 
-        if (e === undefined)
+        if (e === undefined) {
+            /* The idle list is capped by maxsize: a pool used with more names
+               than that would otherwise keep one idle item per name and grow
+               without bound. The oldest idle item gives way to the one just
+               returned, so the most recently used names stay cached. */
+            if (count >= maxsizeValue && count) {
+                const evicted = pools[0];
+                pools = pools.slice(1);
+                count--;
+                coroutine.start(destroy, evicted.o);
+            }
+
             pools[count++] = {
-                o: o,
+                o: o as T_CREATED_ITEM,
                 name: name,
                 time: new Date()
             };
+        }
     }
 
     function connect(name: string) {
-        let o: T_CREATED_ITEM;
-        let cn = 0;
-        let err: Error;
+        let o: T_CREATED_ITEM | undefined;
+        let err: Error | undefined;
 
-        while (true) {
+        for (let cn = 1; ; cn++) {
             try {
                 o = create(name);
                 break;
             } catch (e) {
-                if (++cn >= (retry as number)) {
-                    err = e;
+                /* any thrown value is a failure, including 0 or '' */
+                if (cn >= retry) {
+                    err = toError(e);
                     break;
                 }
             }
@@ -186,100 +317,115 @@ export default function GetPool<
         putback(name, o, err);
     }
 
-    const pool: FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN> = (
+    /* The fiber is used as fiber-local storage: it is the only place a marker
+       can live without leaking between fibers. A fiber that already holds an
+       item from this pool would wait on itself when it asks again, which the
+       semaphore can never satisfy once every permit is out. */
+    const fiberDepth = Symbol('fib-pool depth');
+
+    type FiberState = Class_Fiber & { [fiberDepth]?: true };
+
+    function enterFiber(): FiberState {
+        const fiber = coroutine.current() as FiberState;
+
+        if (fiber[fiberDepth])
+            throw new Error("Cannot pool again from the same fiber: the pool is already held by this callback");
+
+        fiber[fiberDepth] = true;
+
+        return fiber;
+    }
+
+    function leaveFiber(fiber: FiberState) {
+        delete fiber[fiberDepth];
+    }
+
+    const pool = ((
         name: string | FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>,
         func?: FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>
     ) => {
         if (typeof name === 'function') {
-            func = name as any;
+            func = name;
             name = "";
-        }  
+        }
+
+        const dip = func as FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
 
         let r: T_POOL_FUNC_RETURN;
-        let o: typeof jobs[any]['o'];
-        let p = false;
+        let o: T_CREATED_ITEM | undefined;
+        let reused = false;
+        const fiber = enterFiber();
 
-        clearPool();
-        sem.acquire();
-
-        if (count) {
-            for (let i = count - 1; i >= 0; i--)
-                if (pools[i].name === name) {
-                    p = true
-                    o = pools[i].o;
-                    pools.splice(i, 1);
-                    count--;
-                    break;
-                }
-        }
+        try {
+            clearPool();
+            sem.acquire();
+
+            if (count) {
+                for (let i = count - 1; i >= 0; i--)
+                    if (pools[i].name === name) {
+                        reused = true
+                        o = pools[i].o;
+                        pools.splice(i, 1);
+                        count--;
+                        break;
+                    }
+            }
 
-        if (!p) {
-            coroutine.start(connect, name);
+            if (!reused) {
+                coroutine.start(connect, name);
 
-            const job = <typeof jobs[any]>{
-                name: name,
-                ev: new coroutine.Event()
-            };
-            jobs.push(job);
+                const job: typeof jobs[any] = {
+                    name: name,
+                    ev: new coroutine.Event()
+                };
+                jobs.push(job);
+
+                job.ev.wait();
+                if (job.e) {
+                    sem.post();
+                    throw job.e;
+                }
+                o = job.o;
+            }
+
+            running++;
+            try {
+                const po = (strictMode && o !== null && typeof o === 'object')
+                    ? wrapStrict<T_CREATED_ITEM & object>(() => o as T_CREATED_ITEM & object)
+                    : o as T_CREATED_ITEM;
 
-            job.ev.wait();
-            if (job.e) {
+                r = dip(po);
+                putback(name, o);
+                o = undefined;
+            } catch (e) {
+                if (o !== undefined)
+                    coroutine.start(destroy, o);
+                o = undefined;
+                throw toError(e);
+            } finally {
+                running--;
                 sem.post();
-                throw ensureError(job.e);
+                clearPool();
             }
-            o = job.o;
-        }
 
-        running++;
-        try {
-            const po = (_strict && typeof o === 'object') ? new Proxy({}, {
-                get: function (target, prop) {
-                    if (prop === 'close' || prop === 'destroy' || prop === 'dispose')
-                        throw new Error("Cannot close/destroy/dispose");
-                    if (o === undefined)
-                        throw new Error("access object outside of pool scope");
-                    const value = o[prop];
-                    if (typeof value === 'function') {
-                        return function () {
-                            return value.apply(o, arguments);
-                        }
-                    }
-                    return value;
-                },
-                set: function (target, prop, value) {
-                    throw new Error("Cannot set property");
-                }
-            }) as any : o;
-
-            r = func(po as T_CREATED_ITEM);
-            putback(name, o);
-            o = undefined;
-        } catch (e) {
-            if (o !== undefined)
-                coroutine.start(destroy, o);
-            o = undefined;
-            throw ensureError(e);
+            return r;
         } finally {
-            running--;
-            sem.post();
-            clearPool();
+            leaveFiber(fiber);
         }
-
-        return r;
-    };
+    }) as FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
 
     pool.connections = () => count
 
     pool.info = () => ({
-        maxsize: maxsize,
+        maxsize: maxsizeValue,
         count: count,
         running: running,
         wait: sem.count(),
-        timeout: timeout
+        timeout: timeoutValue
     })
 
     pool.clear = () => {
-        timeout = -1;
+        timeoutValue = -1;
         clearPool();
     }
 

package/tsconfig.json

@@ -1,17 +1,13 @@
 {
     "compilerOptions": {
-        "target": "es6",
+        // `fibjs --check` derives its default lib from the target: with es6
+        // that is lib.dom, which collides with the fibjs built-in types.
+        // es2020 is the lowest target whose default lib stays es-only.
+        "target": "es2020",
         "module": "commonjs",
-        "alwaysStrict": false,
-        "removeComments": true,
-        "noEmit": true,
-        "types": [
-            "@fibjs/types"
-        ]
+        "noEmit": true
     },
     "exclude": [
-        "test",
-        "typings",
         "node_modules"
     ]
-}
+}

package/.travis.yml

@@ -1,99 +0,0 @@
-language: node_js
-node_js: '6'
-matrix:
-  include:
-    - os: linux
-      env:
-        - VERSION=0.21.0
-    - os: linux
-      env:
-        - VERSION=0.22.0
-    - os: linux
-      env:
-        - VERSION=0.23.0
-    - os: linux
-      env:
-        - VERSION=0.24.0
-    - os: linux
-      env:
-        - VERSION=0.25.0
-    - os: linux
-      env:
-        - VERSION=0.26.0
-    - os: linux
-      env:
-        - VERSION=0.26.1
-    - 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:
-        - VERSION=0.21.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.22.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.23.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.24.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.25.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.26.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.26.1
-    - os: osx
-      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
-      rvm install ruby-2.4.0;
-      rvm --default use 2.4.0;
-      ruby -v;
-      brew update;
-      brew install xz;
-      OS=darwin;
-    fi
-script:
-  - npm i
-  - mkdir -p ./node_modules/.bin
-  - rm -rf ./node_modules/.bin/fibjs
-  - curl -SL "https://github.com/fibjs/fibjs/releases/download/v${VERSION}/fibjs-v${VERSION}-${OS}-x64.xz" -o ./node_modules/.bin/fibjs.xz
-  - xz -d ./node_modules/.bin/fibjs.xz
-  - chmod a+x ./node_modules/.bin/fibjs
-  - npm run ci

package/appveyor.yml

@@ -1,26 +0,0 @@
-environment:
-  nodejs_version: '6'
-  matrix:
-    - VERSION: 0.21.0
-    - VERSION: 0.22.0
-    - VERSION: 0.23.0
-    - VERSION: 0.24.0
-    - VERSION: 0.25.0
-    - 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
-  - npm i
-  - If Not Exist "node_modules\.bin" (mkdir node_modules\.bin)
-  - curl -fsSL -o node_modules\.bin\fibjs.cab "https://github.com/fibjs/fibjs/releases/download/v%VERSION%/fibjs-v%VERSION%-windows-x64.cab"
-  - expand node_modules\.bin\fibjs.cab node_modules\.bin\fibjs.exe
-
-test_script:
-  - npm run ci
-
-build: off

package/lib/index.js

@@ -1,163 +0,0 @@
-"use strict";
-const coroutine = require("coroutine");
-const util = require("util");
-function ensureError(e) {
-    if (typeof e === 'string')
-        e = new Error(e);
-    return e;
-}
-module.exports = function GetPool(_opt, maxsize, timeout) {
-    let opt = _opt;
-    if (util.isFunction(_opt)) {
-        opt = {
-            create: _opt,
-            maxsize: maxsize,
-            timeout: timeout
-        };
-    }
-    const create = opt.create;
-    const destroy = opt.destroy || ((o) => {
-        if (util.isFunction(o.close))
-            o.close();
-        if (util.isFunction(o.destroy))
-            o.destroy();
-        if (util.isFunction(o.dispose))
-            o.dispose();
-    });
-    maxsize = opt.maxsize || 10;
-    timeout = opt.timeout || 60000;
-    let tm = timeout / 10;
-    if (tm < 10)
-        tm = 10;
-    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() {
-        let c;
-        const d = new Date().getTime();
-        while (count) {
-            c = pools[0];
-            if (d - c.time.getTime() > timeout) {
-                pools = pools.slice(1);
-                count--;
-                if (c.o !== undefined)
-                    coroutine.start(destroy, c.o);
-            }
-            else
-                break;
-        }
-        if (!count) {
-            if (clearTimer) {
-                clearTimer.clear();
-                clearTimer = null;
-            }
-        }
-        else if (!clearTimer)
-            clearTimer = setInterval(clearPool, tm);
-    }
-    function putback(name, o, e) {
-        e = ensureError(e);
-        for (let i = 0; i < jobs.length; i++) {
-            const job = jobs[i];
-            if (job.name === name) {
-                jobs.splice(i, 1);
-                job.o = o;
-                job.e = e;
-                job.ev.set();
-                return;
-            }
-        }
-        if (e === undefined)
-            pools[count++] = {
-                o: o,
-                name: name,
-                time: new Date()
-            };
-    }
-    function connect(name) {
-        let o;
-        let cn = 0;
-        let err;
-        while (true) {
-            try {
-                o = create(name);
-                break;
-            }
-            catch (e) {
-                if (++cn >= retry) {
-                    err = e;
-                    break;
-                }
-            }
-        }
-        putback(name, o, err);
-    }
-    const pool = (name, func) => {
-        if (typeof name === 'function') {
-            func = name;
-            name = "";
-        }
-        let r;
-        let o;
-        let p = false;
-        clearPool();
-        sem.acquire();
-        if (count) {
-            for (let i = count - 1; i >= 0; i--)
-                if (pools[i].name === name) {
-                    p = true;
-                    o = pools[i].o;
-                    pools.splice(i, 1);
-                    count--;
-                    break;
-                }
-        }
-        if (!p) {
-            coroutine.start(connect, name);
-            const job = {
-                name: name,
-                ev: new coroutine.Event()
-            };
-            jobs.push(job);
-            job.ev.wait();
-            if (job.e) {
-                sem.post();
-                throw ensureError(job.e);
-            }
-            o = job.o;
-        }
-        running++;
-        try {
-            r = func(o);
-            putback(name, o);
-        }
-        catch (e) {
-            if (o !== undefined)
-                coroutine.start(destroy, o);
-            throw ensureError(e);
-        }
-        finally {
-            running--;
-            sem.post();
-            clearPool();
-        }
-        return r;
-    };
-    pool.connections = () => count;
-    pool.info = () => ({
-        maxsize: maxsize,
-        count: count,
-        running: running,
-        wait: sem.count(),
-        timeout: timeout
-    });
-    pool.clear = () => {
-        timeout = -1;
-        clearPool();
-    };
-    return pool;
-};

package/typings/index.d.ts

@@ -1,43 +0,0 @@
-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;
-        strict?: 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'];
-        strict: FibPoolOptionArgs<T>['strict'];
-    }
-    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;