@mittwald/kubernetes/cache/store.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
class ObservableStoreDecorator {
    constructor(inner) {
        this.inner = inner;
        this.onStoreHandlers = [];
        this.onRemoveHandlers = [];
        this.onSyncedHandlers = [];
    }
    onStoredOrUpdated(fn) {
        this.onStoreHandlers.push(fn);
    }
    onRemoved(fn) {
        this.onRemoveHandlers.push(fn);
    }
    onSynced(fn) {
        this.onSyncedHandlers.push(fn);
    }
    get(namespace, name) {
        return this.inner.get(namespace, name);
    }
    pull(obj) {
        this.inner.pull(obj);
        this.onRemoveHandlers.forEach(fn => fn(obj));
    }
    store(obj) {
        this.inner.store(obj);
        this.onStoreHandlers.forEach(fn => fn(obj));
    }
    sync(objs) {
        this.inner.sync(objs);
        this.onSyncedHandlers.forEach(fn => fn(objs));
    }
}
exports.ObservableStoreDecorator = ObservableStoreDecorator;
class InMemoryStore {
    constructor() {
        this.objects = new Map();
    }
    store(obj) {
        this.objects.set(`${obj.metadata.namespace}/${obj.metadata.name}`, obj);
    }
    pull(obj) {
        this.objects.delete(`${obj.metadata.namespace}/${obj.metadata.name}`);
    }
    sync(objs) {
        this.objects = new Map();
        objs.forEach(o => this.store(o));
    }
    get(namespace, name) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.objects.get(`${namespace}/${name}`);
        });
    }
}
exports.InMemoryStore = InMemoryStore;
class CachingLookupStore {
    constructor(api) {
        this.api = api;
        this.cache = new Map();
    }
    store(obj) {
        // no-op
    }
    sync(objs) {
        // no-op
    }
    get(namespace, name) {
        return __awaiter(this, void 0, void 0, function* () {
            const key = `${namespace}/${name}`;
            if (this.cache.has(key)) {
                const entry = this.cache.get(key);
                if (entry.until > new Date()) {
                    return entry.entry;
                }
            }
            const result = yield this.api.namespace(namespace).get(name);
            if (result) {
                const exp = new Date();
                exp.setSeconds(exp.getSeconds() + 3600);
                this.cache.set(key, {
                    entry: result,
                    until: exp,
                });
            }
            return result;
        });
    }
    pull(obj) {
        // no-op
    }
}
exports.CachingLookupStore = CachingLookupStore;
//# sourceMappingURL=store.js.map