@maiyunnet/kebab 2.0.0

package/lib/kv.js

@@ -0,0 +1,1004 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = exports.Pool = void 0;
+exports.get = get;
+exports.getConnectionList = getConnectionList;
+const redis = __importStar(require("@litert/redis"));
+const time = __importStar(require("~/lib/time"));
+const text = __importStar(require("~/lib/text"));
+const connections = [];
+async function checkConnection() {
+    const now = time.stamp();
+    for (let i = 0; i < connections.length; ++i) {
+        const connection = connections[i];
+        if (connection.isLost()) {
+            await connection.end();
+            connections.splice(i, 1);
+            --i;
+            continue;
+        }
+        if (connection.isUsing()) {
+            if (connection.getLast() <= now - 180) {
+                console.log(`[kv] [error] There is a transactional connection[${i}] that is not closed.`);
+                await connection.end();
+                connections.splice(i, 1);
+                --i;
+            }
+            continue;
+        }
+        if (connection.getLast() > now - 180) {
+            continue;
+        }
+        await connection.end();
+        connections.splice(i, 1);
+        --i;
+        continue;
+    }
+    setTimeout(function () {
+        checkConnection().catch(e => { console.log('[KV]', e); });
+    }, 30000);
+}
+setTimeout(function () {
+    checkConnection().catch(e => { console.log('[KV]', e); });
+}, 30000);
+class Pool {
+    constructor(ctr, etc) {
+        if (etc) {
+            this._etc = etc;
+        }
+        else {
+            this._etc = ctr.getPrototype('_config').kv;
+        }
+    }
+    async set(key, val, ttl = 0, mod = '') {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.set(key, val, ttl, mod, this._etc);
+        conn.used();
+        return r;
+    }
+    async add(key, val, ttl = 0) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.add(key, val, ttl, this._etc);
+        conn.used();
+        return r;
+    }
+    async replace(key, val, ttl = 0) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.replace(key, val, ttl, this._etc);
+        conn.used();
+        return r;
+    }
+    async append(key, val) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.append(key, val, this._etc);
+        conn.used();
+        return r;
+    }
+    async prepend(key, val) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.prepend(key, val, this._etc);
+        conn.used();
+        return r;
+    }
+    async exists(keys) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.exists(keys, this._etc);
+        conn.used();
+        return r;
+    }
+    async get(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.get(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async ttl(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.ttl(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async pttl(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.pttl(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async mSet(rows) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.mSet(rows, this._etc);
+        conn.used();
+        return r;
+    }
+    async mGet(keys) {
+        const conn = await this._getConnection();
+        if (conn) {
+            const r = await conn.mGet(keys, this._etc);
+            conn.used();
+            return r;
+        }
+        else {
+            const rtn = {};
+            for (const key of keys) {
+                rtn[key] = null;
+            }
+            return rtn;
+        }
+    }
+    async getJson(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.getJson(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async del(keys) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.del(keys, this._etc);
+        conn.used();
+        return r;
+    }
+    async incr(key, num = 1) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.incr(key, num, this._etc);
+        conn.used();
+        return r;
+    }
+    async decr(key, num = 1) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.decr(key, num, this._etc);
+        conn.used();
+        return r;
+    }
+    async expire(key, ttl) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.expire(key, ttl, this._etc);
+        conn.used();
+        return r;
+    }
+    async keys(pattern) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.keys(pattern, this._etc);
+        conn.used();
+        return r;
+    }
+    async scan(cursor = 0, pattern = '*', count = 10) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.scan(cursor, pattern, count, this._etc);
+        conn.used();
+        return r;
+    }
+    async flushDb() {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.flushDb();
+        conn.used();
+        return r;
+    }
+    async ping() {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.ping();
+        conn.used();
+        return r;
+    }
+    async hSet(key, field, val, mod = '') {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.hSet(key, field, val, mod, this._etc);
+        conn.used();
+        return r;
+    }
+    async hMSet(key, rows) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.hMSet(key, rows, this._etc);
+        conn.used();
+        return r;
+    }
+    async hGet(key, field) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.hGet(key, field, this._etc);
+        conn.used();
+        return r;
+    }
+    async hGetJson(key, field) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.hGetJson(key, field, this._etc);
+        conn.used();
+        return r;
+    }
+    async hMGet(key, fields) {
+        const conn = await this._getConnection();
+        if (conn) {
+            const r = await conn.hMGet(key, fields, this._etc);
+            conn.used();
+            return r;
+        }
+        else {
+            const rtn = {};
+            for (const field of fields) {
+                rtn[field] = null;
+            }
+            return rtn;
+        }
+    }
+    async hGetAll(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.hGetAll(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async hDel(key, fields) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.hDel(key, fields, this._etc);
+        conn.used();
+        return r;
+    }
+    async hExists(key, field) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return false;
+        }
+        const r = await conn.hExists(key, field, this._etc);
+        conn.used();
+        return r;
+    }
+    async hIncr(key, field, increment) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.hIncr(key, field, increment, this._etc);
+        conn.used();
+        return r;
+    }
+    async hKeys(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return [];
+        }
+        const r = await conn.hKeys(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async lPush(key, values) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.lPush(key, values, this._etc);
+        conn.used();
+        return r;
+    }
+    async rPush(key, values) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.rPush(key, values, this._etc);
+        conn.used();
+        return r;
+    }
+    async bLMove(sourceKey, destKey, soo, deo, timeout) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.bLMove(sourceKey, destKey, soo, deo, timeout, this._etc);
+        conn.used();
+        return r;
+    }
+    async lPop(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.lPop(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async rPop(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return null;
+        }
+        const r = await conn.rPop(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async bRPop(key, timeout) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return {};
+        }
+        const r = await conn.bRPop(key, timeout, this._etc);
+        conn.used();
+        return r;
+    }
+    async lRange(key, start, stop) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return [];
+        }
+        const r = await conn.lRange(key, start, stop, this._etc);
+        conn.used();
+        return r;
+    }
+    async lLen(key) {
+        const conn = await this._getConnection();
+        if (!conn) {
+            return 0;
+        }
+        const r = await conn.lLen(key, this._etc);
+        conn.used();
+        return r;
+    }
+    async _getConnection() {
+        let conn;
+        for (const connection of connections) {
+            const etc = connection.getEtc();
+            if (connection.isLost() ||
+                connection.isUsing() ||
+                (etc.host !== this._etc.host) ||
+                (etc.port !== this._etc.port) ||
+                (etc.index !== this._etc.index)) {
+                continue;
+            }
+            connection.refreshLast();
+            connection.setUsing();
+            conn = connection;
+            break;
+        }
+        if (!conn) {
+            const link = redis.createCommandClient({
+                'host': this._etc.host,
+                'port': this._etc.port
+            });
+            try {
+                await link.connect();
+            }
+            catch {
+                return null;
+            }
+            if (this._etc.user || this._etc.pwd) {
+                try {
+                    await link.auth(this._etc.user + this._etc.pwd);
+                }
+                catch {
+                    return null;
+                }
+            }
+            await link.select(this._etc.index);
+            conn = new Connection(this._etc, link);
+            conn.refreshLast();
+            conn.setUsing();
+            link.on('error', function (err) {
+                conn.setLost();
+                console.log('[KV] [ERROR]', err);
+            }).on('close', () => {
+                conn.setLost();
+            });
+            connections.push(conn);
+        }
+        return conn;
+    }
+}
+exports.Pool = Pool;
+class Connection {
+    constructor(etc, link) {
+        this._last = 0;
+        this._using = false;
+        this._lost = false;
+        this._etc = etc;
+        this._link = link;
+        this.refreshLast();
+    }
+    getEtc() {
+        return this._etc;
+    }
+    getLast() {
+        return this._last;
+    }
+    setLost() {
+        this._lost = true;
+    }
+    isLost() {
+        return this._lost;
+    }
+    setUsing() {
+        this._using = true;
+    }
+    isUsing() {
+        return this._using;
+    }
+    used() {
+        this._using = false;
+    }
+    refreshLast() {
+        this._last = time.stamp();
+    }
+    async end() {
+        try {
+            await this._link.close();
+        }
+        catch {
+            return;
+        }
+    }
+    async set(key, val, ttl, mod, etc) {
+        this.refreshLast();
+        if (typeof val !== 'string') {
+            val = text.stringifyJson(val);
+        }
+        try {
+            switch (mod) {
+                case '': {
+                    return await this._link.set(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                }
+                case 'nx': {
+                    return await this._link.setNX(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                }
+                case 'xx': {
+                    return await this._link.replace(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async add(key, val, ttl, etc) {
+        return this.set(key, val, ttl, 'nx', etc);
+    }
+    async replace(key, val, ttl, etc) {
+        return this.set(key, val, ttl, 'xx', etc);
+    }
+    async append(key, val, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.append(etc.pre + key, val) > 0 ? true : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async prepend(key, val, etc) {
+        this.refreshLast();
+        try {
+            const script = `local val = redis.call('GET', KEYS[1])
+if (val == false) then
+    return 0
+end
+local r = redis.call('SET', KEYS[1], ARGV[1]..val)
+if (r) then
+    return 1
+else
+    return 0
+end`;
+            let r = await this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [etc.pre + key], [val]);
+            r = parseInt(r);
+            if (r <= 0) {
+                await this._link.scriptLoad(script);
+                r = this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [etc.pre + key], [val]);
+                r = parseInt(r);
+            }
+            return r > 0 ? true : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async exists(keys, etc) {
+        this.refreshLast();
+        try {
+            if (typeof keys === 'string') {
+                keys = [keys];
+            }
+            for (let k = 0; k < keys.length; ++k) {
+                keys[k] = etc.pre + keys[k];
+            }
+            return await this._link.mExists(keys);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async get(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.get(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async ttl(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.ttl(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async pttl(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.pTTL(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async mGet(keys, etc) {
+        this.refreshLast();
+        for (let k = 0; k < keys.length; ++k) {
+            keys[k] = etc.pre + keys[k];
+        }
+        const rtn = {};
+        try {
+            const pl = etc.pre.length;
+            const r = await this._link.mGet(keys);
+            if (pl === 0) {
+                return r;
+            }
+            for (const k in r) {
+                rtn[k.slice(pl)] = r[k];
+            }
+        }
+        catch {
+            for (const key of keys) {
+                rtn[key] = null;
+            }
+        }
+        return rtn;
+    }
+    async mSet(rows, etc) {
+        this.refreshLast();
+        try {
+            const rtn = {};
+            for (const key in rows) {
+                rtn[etc.pre + key] = rows[key];
+            }
+            await this._link.mSet(rtn);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getJson(key, etc) {
+        const v = await this.get(key, etc);
+        if (v === null) {
+            return null;
+        }
+        const r = text.parseJson(v);
+        return r === false ? null : r;
+    }
+    async del(keys, etc) {
+        this.refreshLast();
+        if (typeof keys === 'string') {
+            keys = [keys];
+        }
+        for (let k = 0; k < keys.length; ++k) {
+            keys[k] = etc.pre + keys[k];
+        }
+        try {
+            return await this._link.del(keys) > 0 ? true : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async incr(key, num, etc) {
+        this.refreshLast();
+        try {
+            if (Number.isInteger(num)) {
+                if (num === 1) {
+                    return await this._link.incr(etc.pre + key);
+                }
+                else {
+                    return await this._link.incr(etc.pre + key, num);
+                }
+            }
+            else {
+                return await this._link.incrByFloat(etc.pre + key, num);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async decr(key, num, etc) {
+        this.refreshLast();
+        try {
+            if (Number.isInteger(num)) {
+                if (num === 1) {
+                    return await this._link.decr(etc.pre + key);
+                }
+                else {
+                    return await this._link.decr(etc.pre + key, num);
+                }
+            }
+            else {
+                return await this._link.incrByFloat(etc.pre + key, -num);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async expire(key, ttl, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.expire(etc.pre + key, ttl);
+        }
+        catch {
+            return false;
+        }
+    }
+    async keys(pattern, etc) {
+        this.refreshLast();
+        try {
+            const r = await this._link.keys(etc.pre + pattern);
+            const pl = etc.pre.length;
+            if (pl > 0) {
+                for (let k = 0; k < r.length; ++k) {
+                    r[k] = r[k].slice(pl);
+                }
+            }
+            return r;
+        }
+        catch {
+            return false;
+        }
+    }
+    async scan(cursor, pattern, count, etc) {
+        this.refreshLast();
+        try {
+            const r = await this._link.scan(cursor, etc.pre + pattern, count);
+            for (let i = 0; i < r.items.length; ++i) {
+                r.items[i] = r.items[i].slice(this._etc.pre.length);
+            }
+            return r;
+        }
+        catch {
+            return false;
+        }
+    }
+    async flushDb() {
+        this.refreshLast();
+        try {
+            await this._link.flushDb();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ping() {
+        this.refreshLast();
+        try {
+            return (await this._link.ping()) === 'PONG' ? 'PONG' : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async hSet(key, field, val, mod, etc) {
+        this.refreshLast();
+        try {
+            if (typeof val !== 'string') {
+                val = text.stringifyJson(val);
+            }
+            if (mod === 'nx') {
+                return await this._link.hSetNX(etc.pre + key, field, val);
+            }
+            else {
+                return await this._link.hSet(etc.pre + key, field, val);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async hMSet(key, rows, etc) {
+        this.refreshLast();
+        try {
+            for (const i in rows) {
+                const val = rows[i];
+                if (typeof val === 'object') {
+                    rows[i] = text.stringifyJson(val);
+                }
+            }
+            await this._link.hMSet(etc.pre + key, rows);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async hGet(key, field, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hGet(etc.pre + key, field);
+        }
+        catch {
+            return null;
+        }
+    }
+    async hGetJson(key, field, etc) {
+        const v = await this.hGet(key, field, etc);
+        if (v === null) {
+            return null;
+        }
+        const r = text.parseJson(v);
+        return r === false ? null : v;
+    }
+    async hMGet(key, fields, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hMGet(etc.pre + key, fields);
+        }
+        catch {
+            const rtn = {};
+            for (const field of fields) {
+                rtn[field] = null;
+            }
+            return rtn;
+        }
+    }
+    async hGetAll(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hGetAll(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async hDel(key, fields, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hDel(etc.pre + key, fields);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async hExists(key, field, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hExists(etc.pre + key, field);
+        }
+        catch {
+            return false;
+        }
+    }
+    async hIncr(key, field, increment, etc) {
+        this.refreshLast();
+        try {
+            if (Number.isInteger(increment)) {
+                return await this._link.hIncr(etc.pre + key, field, increment);
+            }
+            else {
+                return await this._link.hIncrByFloat(etc.pre + key, field, increment);
+            }
+        }
+        catch {
+            return 0;
+        }
+    }
+    async hKeys(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.hKeys(etc.pre + key);
+        }
+        catch {
+            return [];
+        }
+    }
+    async lPush(key, values, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.lPush(etc.pre + key, values);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async rPush(key, values, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.rPush(etc.pre + key, values);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async bLMove(sourceKey, destKey, soo, deo, timeout, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.bLMove(etc.pre + sourceKey, etc.pre + destKey, soo, deo, timeout);
+        }
+        catch {
+            return null;
+        }
+    }
+    async lPop(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.lPop(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async rPop(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.rPop(etc.pre + key);
+        }
+        catch {
+            return null;
+        }
+    }
+    async bRPop(key, timeout, etc) {
+        this.refreshLast();
+        try {
+            if (typeof key === 'string') {
+                key = [key];
+            }
+            return await this._link.bRPop(key.map(item => etc.pre + item), timeout);
+        }
+        catch {
+            return {};
+        }
+    }
+    async lRange(key, start, stop, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.lRange(etc.pre + key, start, stop);
+        }
+        catch {
+            return [];
+        }
+    }
+    async lLen(key, etc) {
+        this.refreshLast();
+        try {
+            return await this._link.lLen(etc.pre + key);
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+exports.Connection = Connection;
+function get(ctr, etc) {
+    if (!etc) {
+        etc = ctr.getPrototype('_config').kv;
+    }
+    return new Pool(ctr, etc);
+}
+function getConnectionList() {
+    const list = [];
+    for (let i = 0; i < connections.length; ++i) {
+        const connection = connections[i];
+        const etc = connection.getEtc();
+        list.push({
+            'id': i,
+            'last': connection.getLast(),
+            'host': etc.host,
+            'port': etc.port,
+            'index': etc.index,
+            'lost': connection.isLost(),
+            'using': connection.isUsing()
+        });
+    }
+    return list;
+}