@stinkycomputing/cachearoo 1.0.24

package/dist/libs/cro.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cachearoo = exports.RequestOptionsInternal = exports.RequestOptions = exports.CachearooSettings = exports.generateUUID = exports.AlreadyExistsError = exports.TimeoutError = void 0;
+const fetch = global.fetch;
+const cro_connection_1 = require("./cro.connection");
+const CACHEAROO_DEFAULT_PORT = 4300;
+const HTTP_RESPONSE_OK = 200;
+const HTTP_RESPONSE_NOT_FOUND = 404;
+const HTTP_RESPONSE_CREATED = 201;
+const HTTP_RESPONSE_NOT_MODIFIED = 304;
+const MAX_CONCURRENT = 50;
+class TimeoutError extends Error {
+    progressTimeout;
+    constructor(message, progressTimeout) {
+        super(message);
+        Error.captureStackTrace(this, this.constructor);
+        this.progressTimeout = progressTimeout;
+    }
+}
+exports.TimeoutError = TimeoutError;
+class AlreadyExistsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AlreadyExistsError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.AlreadyExistsError = AlreadyExistsError;
+function generateUUID() {
+    function s4() {
+        return Math.floor((1 + Math.random()) * 0x10000)
+            .toString(16)
+            .substring(1);
+    }
+    return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
+        s4() + '-' + s4() + s4() + s4();
+}
+exports.generateUUID = generateUUID;
+class CachearooSettings {
+    bucket = undefined;
+    host = undefined;
+    port = undefined;
+    path = '';
+    apiKey = undefined;
+    secure = false;
+    enablePing = false;
+    pingInterval = 5000;
+    clientId = undefined;
+    wsSubDomain = undefined;
+}
+exports.CachearooSettings = CachearooSettings;
+;
+class RequestOptions {
+    bucket = undefined;
+    data = undefined;
+    failIfExists = false;
+    expire = undefined;
+    async = true;
+    forceHttp = false;
+    keysOnly = false;
+    filter = undefined;
+    removeDataFromReply = false;
+    constructor(options) {
+        if (options) {
+            this.bucket = options.bucket;
+            this.data = options.data;
+            this.failIfExists = options.failIfExists;
+            this.expire = options.expire;
+            this.async = options.async;
+            this.forceHttp = options.forceHttp;
+            this.keysOnly = options.keysOnly;
+            this.filter = options.filter;
+            this.removeDataFromReply = options.removeDataFromReply;
+        }
+    }
+}
+exports.RequestOptions = RequestOptions;
+class RequestOptionsInternal extends RequestOptions {
+    url = undefined;
+    method = undefined;
+    key = undefined;
+    forceHttp = false;
+    keysOnly = false;
+    filter = undefined;
+    removeDataFromReply = false;
+    isList = false;
+}
+exports.RequestOptionsInternal = RequestOptionsInternal;
+class Cachearoo {
+    connection;
+    settings;
+    requestQueue;
+    pendingRequests = 0;
+    internalizeRequestOptions(key, options, isList = false) {
+        var bucket = options.bucket || this.settings.bucket || '';
+        if (options.async == null)
+            options.async = true;
+        var opt = new RequestOptionsInternal(null);
+        if (options.keysOnly !== undefined)
+            opt.keysOnly = options.keysOnly;
+        if (options.filter !== undefined)
+            opt.filter = options.filter;
+        opt.url = this.getUrl(key, bucket, opt.keysOnly, opt.filter, isList);
+        opt.bucket = bucket;
+        opt.key = key;
+        opt.async = options.async;
+        opt.failIfExists = options.failIfExists;
+        opt.forceHttp = options.forceHttp;
+        opt.expire = options.expire;
+        opt.isList = isList;
+        opt.removeDataFromReply = options.removeDataFromReply;
+        return opt;
+    }
+    checkOptions(options) {
+        if (options instanceof RequestOptions === false) {
+            options = new RequestOptions(options);
+        }
+        return options;
+    }
+    async read(key, options) {
+        let opt = this.internalizeRequestOptions(key, this.checkOptions(options));
+        opt.method = 'GET';
+        return this.request(opt);
+    }
+    async list(options) {
+        let optWithKeysOnly = { ...options };
+        if (optWithKeysOnly.keysOnly === undefined)
+            optWithKeysOnly.keysOnly = true;
+        let opt = this.internalizeRequestOptions('', this.checkOptions(optWithKeysOnly), true);
+        opt.method = 'GET';
+        return (await this.request(opt));
+    }
+    async write(key, value, options) {
+        let opt = this.internalizeRequestOptions(key, this.checkOptions(options));
+        opt.method = opt.key ? 'PUT' : 'POST';
+        opt.data = value;
+        return this.request(opt);
+    }
+    async patch(key, patch, options) {
+        let opt = this.internalizeRequestOptions(key, this.checkOptions(options));
+        opt.method = 'PATCH';
+        opt.data = patch;
+        return this.request(opt);
+    }
+    async remove(key, options) {
+        let opt = this.internalizeRequestOptions(key, this.checkOptions(options));
+        opt.method = 'DELETE';
+        return this.request(opt);
+    }
+    async repair(bucket) {
+        var protocol = this.settings.secure ? 'https://' : 'http://';
+        var url = protocol + this.settings.host + ':' + this.settings.port + this.settings.path + '_repair/' + bucket;
+        const opt = {
+            url,
+            method: 'GET',
+        };
+        return await this.requestHttp(opt);
+    }
+    getUrl(key, bucket, keysOnly, filter, isList = false) {
+        if (!key)
+            key = '';
+        var suffix = 'd=' + new Date().getTime();
+        suffix = ((key.indexOf('?') > -1) ? '&' : '?') + suffix;
+        if (keysOnly)
+            suffix = suffix + '&keysOnly=true';
+        if ((filter != null) && (filter !== ''))
+            suffix = suffix + '&filter=' + filter;
+        var protocol = this.settings.secure ? 'https://' : 'http://';
+        if (isList) {
+            return protocol + this.settings.host + ':' + this.settings.port + this.settings.path + '_data/' + encodeURIComponent(bucket) + suffix;
+        }
+        return protocol + this.settings.host + ':' + this.settings.port + this.settings.path + '_data/' + encodeURIComponent(bucket) + '/' + encodeURIComponent(key) + suffix;
+    }
+    async requestHttp(options) {
+        const method = options.method || 'GET';
+        let request = {
+            method,
+            headers: {},
+            body: undefined,
+        };
+        if (this.settings.apiKey) {
+            request.headers['API-Key'] = this.settings.apiKey;
+            request.headers['x-api-key'] = this.settings.apiKey;
+        }
+        if ((method == 'PUT') || (method == 'POST') || (method == 'PATCH')) {
+            request.body = JSON.stringify(options.data);
+            request.headers['Content-Type'] = 'application/json';
+            if (options.failIfExists) {
+                request.headers['failIfExists'] = options.failIfExists;
+            }
+            ;
+            if (options.removeDataFromReply) {
+                request.headers['RemoveDataFromReply'] = options.removeDataFromReply;
+            }
+            ;
+            if (options.expire) {
+                request.headers['expire'] = options.expire;
+            }
+        }
+        const response = await fetch(options.url, request);
+        if (((method === 'GET') || (method === 'PATCH')) && ([HTTP_RESPONSE_OK, HTTP_RESPONSE_NOT_MODIFIED].indexOf(response.status) > -1)) {
+            return await response.json();
+        }
+        else if ((['POST', 'PUT'].indexOf(method) > -1) && ([HTTP_RESPONSE_OK, HTTP_RESPONSE_CREATED].indexOf(response.status) > -1)) {
+            let key = options.key;
+            if (response.status === HTTP_RESPONSE_CREATED) {
+                key = response.headers['location'];
+            }
+            return key;
+        }
+        else if ((method === 'DELETE') && ([HTTP_RESPONSE_OK, HTTP_RESPONSE_NOT_FOUND].indexOf(response.status) > -1)) {
+            return;
+        }
+        else if (response.status == HTTP_RESPONSE_OK) {
+            return;
+        }
+        else {
+            throw new Error(`${response.status}`);
+        }
+    }
+    async request(options) {
+        var _resolve;
+        var _reject;
+        var promise = new Promise(function (resolve, reject) {
+            _resolve = resolve;
+            _reject = reject;
+        });
+        if (options.async === undefined)
+            options.async = true;
+        var queueItem = { resolve: _resolve, reject: _reject, options: options };
+        setTimeout(() => {
+            this.requestQueue.unshift(queueItem);
+            this.processRequestQueue();
+        });
+        return promise;
+    }
+    processRequestQueue() {
+        if ((this.pendingRequests >= MAX_CONCURRENT) || (this.requestQueue.length === 0)) {
+            return;
+        }
+        const item = this.requestQueue.pop();
+        this.pendingRequests++;
+        var promise;
+        if ((this.connection) && (item.options.async) && (this.connection.connected) && (!item.options.forceHttp)) {
+            promise = this.connection.request(item.options);
+        }
+        else {
+            promise = this.requestHttp(item.options);
+        }
+        promise
+            .then(obj => {
+            this.pendingRequests--;
+            item.resolve(obj);
+            setTimeout(this.processRequestQueue.bind(this));
+        })
+            .catch(err => {
+            this.pendingRequests--;
+            item.reject(err);
+            setTimeout(this.processRequestQueue.bind(this));
+        });
+    }
+    close() {
+        this.connection.close();
+    }
+    constructor(settings) {
+        if (settings == null)
+            settings = new CachearooSettings();
+        settings.host = settings.host || '127.0.0.1';
+        settings.port = settings.port || CACHEAROO_DEFAULT_PORT;
+        if (typeof settings.path !== 'string')
+            settings.path = '';
+        if ((settings.path !== '') && (settings.path.charAt(0) !== '/')) {
+            settings.path = '/' + settings.path;
+        }
+        if (settings.path.charAt(settings.path.length - 1) !== '/') {
+            settings.path = settings.path + '/';
+        }
+        this.settings = settings;
+        this.connection = new cro_connection_1.PersistentConnection(settings);
+        this.requestQueue = [];
+    }
+}
+exports.Cachearoo = Cachearoo;

package/dist/libs/cro.msg.competing-consumers.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { Cachearoo } from './cro';
+import { EventEmitter } from 'events';
+export declare const JOB_NOT_SUPPORTED = 100;
+export declare const NO_WORKER_AVAILABLE = 200;
+export interface WorkCallback {
+    (job: any, callback: (err: any, obj?: any) => any, progressCallback: (obj?: any) => any): any;
+}
+export declare class Worker {
+    id: string;
+    available: boolean;
+    constructor(id: any);
+    work?: WorkCallback;
+    release(): void;
+}
+export interface JobQueryResponseCallback {
+    (errno: number, worker?: Worker): void;
+}
+export interface JobQueryCallback {
+    (job: any, responseCallback: JobQueryResponseCallback): void;
+}
+export declare class Producer {
+    private statusQueue;
+    private jobQueue;
+    private timeout;
+    private progressTimeout;
+    private pendingJobs;
+    private de;
+    private jobStatusQueueListener;
+    constructor(de: Cachearoo, channel: string, timeout?: number, progressTimeout?: number);
+    destroy(): void;
+    addJob(job: any, progressCallback: any, timeout?: number, progressTimeout?: number): Promise<any>;
+}
+export declare class CompetingConsumer extends EventEmitter {
+    onJobQuery?: JobQueryCallback;
+    private statusQueue;
+    private jobQueue;
+    private de;
+    private jobQueueListener;
+    private clientId;
+    jobCount: number;
+    constructor(de: Cachearoo, channel: string, clientId: string);
+    destroy(): void;
+    private jobHandler;
+    private waitForWorker;
+}

package/dist/libs/cro.msg.competing-consumers.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompetingConsumer = exports.Producer = exports.Worker = exports.NO_WORKER_AVAILABLE = exports.JOB_NOT_SUPPORTED = void 0;
+const cro_1 = require("./cro");
+const events_1 = require("events");
+const CHANNEL_PREFIX = 'messaging.compcon';
+const DEFAULT_TIMEOUT = 10000;
+const DEFAULT_PROGRESS_TIMEOUT = 10000;
+const CONSUMER_WAIT_RANGE_MS = 20;
+exports.JOB_NOT_SUPPORTED = 100;
+exports.NO_WORKER_AVAILABLE = 200;
+class Worker {
+    id;
+    available = true;
+    constructor(id) {
+        this.id = id;
+    }
+    work = undefined;
+    release() {
+        this.available = true;
+    }
+}
+exports.Worker = Worker;
+class PendingJob {
+    callback;
+    progressCallback;
+    lastProgress;
+    publishTime;
+    constructor(callback) {
+        const now = new Date().valueOf();
+        this.lastProgress = undefined;
+        this.publishTime = now;
+        this.callback = callback;
+    }
+}
+async function wait(ms) {
+    if (ms === 0)
+        return;
+    await new Promise((resolve) => {
+        setTimeout(() => resolve(null), ms);
+    });
+}
+class Producer {
+    statusQueue;
+    jobQueue;
+    timeout;
+    progressTimeout;
+    pendingJobs = new Map();
+    de;
+    jobStatusQueueListener;
+    constructor(de, channel, timeout, progressTimeout) {
+        this.jobQueue = CHANNEL_PREFIX + '.' + channel + '.jobs';
+        this.statusQueue = CHANNEL_PREFIX + '.' + channel + '.status';
+        this.timeout = timeout || DEFAULT_TIMEOUT;
+        this.progressTimeout = progressTimeout || DEFAULT_PROGRESS_TIMEOUT;
+        this.de = de;
+        this.jobStatusQueueListener = (ev) => {
+            if (this.pendingJobs.has(ev.key)) {
+                const job = this.pendingJobs.get(ev.key);
+                job.lastProgress = new Date().valueOf();
+                job.callback(ev.value.err, ev);
+                if (ev.value.done) {
+                    this.pendingJobs.delete(ev.key);
+                }
+            }
+        };
+        de.connection.addListener(this.statusQueue, '*', true, this.jobStatusQueueListener);
+    }
+    destroy() {
+        if (this.de.connection) {
+            this.de.connection.removeListener(this.jobStatusQueueListener);
+        }
+    }
+    async addJob(job, progressCallback, timeout, progressTimeout) {
+        timeout = timeout || this.timeout;
+        progressTimeout = progressTimeout || this.progressTimeout;
+        const id = cro_1.generateUUID();
+        await this.de.connection.write(this.jobQueue, id, job);
+        return new Promise((resolve, reject) => {
+            const intervalRef = setInterval(() => {
+                const now = new Date().valueOf();
+                let isProgressTimeout = false;
+                if (this.pendingJobs[id].lastProgress != null) {
+                    isProgressTimeout = (now > this.pendingJobs[id].lastProgress + progressTimeout);
+                }
+                const isTimeout = (now > this.pendingJobs[id].publishTime + timeout);
+                if (isProgressTimeout || isTimeout) {
+                    this.pendingJobs[id] = null;
+                    clearInterval(intervalRef);
+                    reject(new cro_1.TimeoutError(`Timeout for job id ${id}`, isProgressTimeout));
+                }
+            }, 500);
+            this.pendingJobs[id] = new PendingJob((err, ev) => {
+                if (err) {
+                    clearInterval(intervalRef);
+                    reject(new Error(err));
+                }
+                else {
+                    if (ev.value.done) {
+                        clearInterval(intervalRef);
+                        resolve(ev.value);
+                        this.de.connection.delete(this.statusQueue, ev.key);
+                    }
+                    else {
+                        if (typeof progressCallback === 'function')
+                            progressCallback(ev.value);
+                    }
+                }
+            });
+        });
+    }
+}
+exports.Producer = Producer;
+class CompetingConsumer extends events_1.EventEmitter {
+    onJobQuery;
+    statusQueue;
+    jobQueue;
+    de;
+    jobQueueListener;
+    clientId;
+    jobCount = 0;
+    constructor(de, channel, clientId) {
+        super();
+        this.statusQueue = CHANNEL_PREFIX + '.' + channel + '.status';
+        this.jobQueue = CHANNEL_PREFIX + '.' + channel + '.jobs';
+        this.de = de;
+        this.clientId = clientId;
+        this.jobQueueListener = (ev) => {
+            if ((ev.isDeleted) || (ev.value == null))
+                return;
+            this.jobHandler(ev.key, ev.value).catch(() => this.emit('job', { id: ev.value.id, status: 'No worker' }));
+        };
+        de.connection.addListener(this.jobQueue, '*', true, this.jobQueueListener);
+    }
+    destroy() {
+        this.de.connection.removeListener(this.jobQueueListener);
+        this.removeAllListeners();
+    }
+    async jobHandler(key, job) {
+        this.emit('job', { id: job.id, status: 'Job received' });
+        await wait(Math.floor(Math.random() * CONSUMER_WAIT_RANGE_MS));
+        const worker = await this.waitForWorker(job);
+        try {
+            const obj = {
+                claim: { id: this.clientId },
+                done: false,
+                err: null,
+                data: null,
+                progress: null
+            };
+            await this.de.connection.write(this.statusQueue, key, obj, true);
+            await this.de.connection.delete(this.jobQueue, key);
+            this.jobCount += 1;
+            if (worker.work) {
+                await worker.work(job, async (err, data) => {
+                    this.jobCount -= 1;
+                    if (err instanceof Error)
+                        err = err.message;
+                    this.emit('job', { id: job.id, done: true, data });
+                    await this.de.connection.write(this.statusQueue, key, { ...obj, err, data, done: true });
+                }, (progress) => {
+                    this.emit('job', { id: job.id, done: false, progress });
+                    this.de.connection.write(this.statusQueue, key, { ...obj, progress });
+                });
+            }
+        }
+        catch (err) {
+            worker.release();
+            if (!(err instanceof cro_1.AlreadyExistsError)) {
+                throw err;
+            }
+        }
+    }
+    async waitForWorker(job) {
+        return new Promise((resolve, reject) => {
+            var interval = setInterval(() => {
+                if (this.onJobQuery == null) {
+                    return;
+                }
+                this.onJobQuery(job, (errno, worker) => {
+                    if (errno == null) {
+                        clearInterval(interval);
+                        this.emit('job', { id: job.id, status: 'Worker assigned' });
+                        resolve(worker);
+                        return;
+                    }
+                    else if (errno == exports.JOB_NOT_SUPPORTED) {
+                        clearInterval(interval);
+                        this.emit('job', { id: job.id, error: 'Not supported' });
+                        reject(new Error('Job not supported'));
+                    }
+                    else if (errno == exports.NO_WORKER_AVAILABLE) {
+                    }
+                    else {
+                        clearInterval(interval);
+                        this.emit('job', { id: job.id, errno });
+                        reject(new Error(`Error no : ${errno}`));
+                    }
+                });
+            }, 100);
+        });
+    }
+}
+exports.CompetingConsumer = CompetingConsumer;

package/dist/libs/cro.msg.request-reply.d.ts

@@ -0,0 +1,32 @@
+import { Cachearoo } from './cro';
+export interface MessageResponseCallback {
+    (err: any, data?: any): void;
+}
+export interface ProgressCallback {
+    (obj: any): void;
+}
+export interface MessageCallback {
+    (msg: any, responseCallback: MessageResponseCallback, progressCallback: ProgressCallback): void;
+}
+export declare class Requestor {
+    private pendingRequests;
+    private timeout;
+    private progressTimeout;
+    private de;
+    private channel;
+    private progressChannel;
+    private progressListener;
+    private replyListener;
+    constructor(de: any, channel: any, timeout: any, progressTimeout: any);
+    destroy(): void;
+    request(msg: any, progressCallback: ProgressCallback, timeout?: number, progressTimeout?: number): Promise<any>;
+}
+export declare class Replier {
+    onMessage?: MessageCallback;
+    private channel;
+    private progressChannel;
+    private de;
+    private requestListener;
+    constructor(de: Cachearoo, channel: any);
+    destroy(): void;
+}

package/dist/libs/cro.msg.request-reply.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Replier = exports.Requestor = void 0;
+const cro_1 = require("./cro");
+const REQUESTREPLY_PREFIX = '#reqrep/';
+const PROGRESS_PREFIX = `#reqrep-progress/`;
+class Request {
+    lastProgress;
+    requestTime;
+    reply;
+    progress;
+    constructor(reply, progress) {
+        const now = new Date().valueOf();
+        this.lastProgress = now;
+        this.requestTime = now;
+        this.reply = reply;
+        this.progress = progress;
+    }
+}
+class Requestor {
+    pendingRequests = new Map();
+    timeout;
+    progressTimeout;
+    de;
+    channel;
+    progressChannel;
+    progressListener;
+    replyListener;
+    constructor(de, channel, timeout, progressTimeout) {
+        this.timeout = timeout || 5000;
+        this.progressTimeout = progressTimeout || 5000;
+        this.channel = REQUESTREPLY_PREFIX + channel;
+        this.progressChannel = PROGRESS_PREFIX + channel;
+        this.de = de;
+        this.progressListener = (ev) => {
+            const req = this.pendingRequests[ev.key];
+            if (req) {
+                req.lastProgress = new Date().valueOf();
+                if (typeof req.progress === 'function') {
+                    req.progress(ev.value.data);
+                }
+            }
+        };
+        this.replyListener = (ev) => {
+            if (this.pendingRequests[ev.key]) {
+                this.pendingRequests[ev.key].reply(ev.value.err, ev.value.data);
+                this.pendingRequests[ev.key] = null;
+            }
+        };
+        de.connection.addListener(this.channel, '*', true, this.replyListener);
+        de.connection.addListener(this.progressChannel, '*', true, this.progressListener);
+    }
+    destroy() {
+        this.de.connection.removeListener(this.progressListener);
+        this.de.connection.removeListener(this.replyListener);
+    }
+    async request(msg, progressCallback, timeout, progressTimeout) {
+        timeout = timeout || this.timeout;
+        progressTimeout = progressTimeout || this.progressTimeout;
+        return new Promise((resolve, reject) => {
+            var id = cro_1.generateUUID();
+            this.de.connection.signalEvent(this.channel, id, msg);
+            const intervalRef = setInterval(() => {
+                const now = new Date().valueOf();
+                const isProgressTimeout = (now > this.pendingRequests[id].lastProgress + progressTimeout);
+                const isTimeout = (now > this.pendingRequests[id].requestTime + timeout);
+                if (isProgressTimeout || isTimeout) {
+                    this.pendingRequests[id] = null;
+                    clearInterval(intervalRef);
+                    reject(new cro_1.TimeoutError(`Timeout in request id ${id}`, isProgressTimeout));
+                }
+            }, 500);
+            this.pendingRequests[id] = new Request((err, data) => {
+                clearInterval(intervalRef);
+                if (err) {
+                    reject(new Error(err));
+                }
+                else {
+                    resolve(data);
+                }
+            }, progressCallback);
+        });
+    }
+}
+exports.Requestor = Requestor;
+class Replier {
+    onMessage;
+    channel;
+    progressChannel;
+    de;
+    requestListener;
+    constructor(de, channel) {
+        this.channel = REQUESTREPLY_PREFIX + channel;
+        this.progressChannel = PROGRESS_PREFIX + channel;
+        this.de = de;
+        this.requestListener = (ev) => {
+            if (this.onMessage === undefined) {
+                return;
+            }
+            this.onMessage(ev.value, (err, data) => {
+                if (this.de.connection.connected) {
+                    const errmsg = (err instanceof Error) ? err.message : err;
+                    this.de.connection.signalEvent(this.channel, ev.key, { err: errmsg, data: data });
+                }
+            }, (data) => {
+                if (this.de.connection.connected) {
+                    this.de.connection.signalEvent(this.progressChannel, ev.key, { data });
+                }
+            });
+        };
+        de.connection.addListener(this.channel, '*', true, this.requestListener);
+    }
+    destroy() {
+        this.de.connection.removeListener(this.requestListener);
+    }
+}
+exports.Replier = Replier;