syslog-portal/dist/services/pouchArchiver.js

A portal for ingesting syslog data

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
import { injectable, inject, preDestroy, postConstruct } from 'inversify';
import { TYPES } from '../types.js';
import PouchDB from 'pouchdb';
import { randomUUID } from 'crypto';
import { mkdirSync } from 'fs';
import { rmdir } from 'fs/promises';
import { resolve, join } from 'node:path';
let PouchArchiver = class PouchArchiver {
    server;
    log;
    localDatabase;
    remoteDatabase;
    syncInterval;
    dataFolder;
    partitionKeyList;
    activeLocalDataFolder;
    constructor(server, config, log, db) {
        log.info('Creating pouchdb archiver');
        this.server = server;
        this.log = log;
        this.dataFolder = config.archiver.databaseFolder;
        this.partitionKeyList = config.archiver.partitionKeyPriorityList ?? [];
        this.localDatabase = this.createDatabase();
        this.remoteDatabase = db;
        this.syncInterval = setInterval(this.sync.bind(this), config.archiver.syncInterval);
    }
    createDatabase() {
        const folder = join(resolve(this.dataFolder), randomUUID());
        this.activeLocalDataFolder = folder;
        const db = join(folder, 'syslog');
        mkdirSync(db, {
            recursive: true,
        });
        return new PouchDB(db);
    }
    async sync() {
        this.log.info('syncing to remote');
        const oldDatabase = this.localDatabase;
        const oldFolder = this.activeLocalDataFolder;
        this.localDatabase = this.createDatabase();
        try {
            await oldDatabase.replicate.to(this.remoteDatabase);
            this.log.info('finished syncing to remote');
        }
        catch (err) {
            this.log.error(err, 'error while syncing to remote, syncing back to local copy');
            await oldDatabase.replicate.to(this.localDatabase);
        }
        this.log.info('destroying previous sync interval copy');
        await oldDatabase.destroy();
        if (oldFolder) {
            await rmdir(resolve(oldFolder));
        }
        this.log.info('finished destroying previous sync');
    }
    setup() {
        this.log.info('Registering archiver listener with server');
        this.server.onLogMessage(this);
    }
    async cleanUp() {
        this.log.info('Deregistering archiver listener from server');
        this.server.offLogMessage(this);
        clearInterval(this.syncInterval);
        await this.sync();
        await this.localDatabase.close();
    }
    getKey(message, id) {
        for (const key of this.partitionKeyList) {
            if (message[key] != null)
                return message[key];
        }
        return id;
    }
    getId(message) {
        const id = randomUUID();
        return `${this.getKey(message, id)}:${id}`;
    }
    async onLogMessage(message) {
        await this.localDatabase.put({
            _id: this.getId(message),
            app: message.app,
            timestamp: message.timestamp,
            message: message.message,
            modelVersion: message.modelVersion,
            hostname: message.hostname,
            procId: message.procId,
            severity: message.severity,
            facility: message.facility,
        });
    }
};
__decorate([
    postConstruct(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], PouchArchiver.prototype, "setup", null);
__decorate([
    preDestroy(),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", Promise)
], PouchArchiver.prototype, "cleanUp", null);
PouchArchiver = __decorate([
    injectable(),
    __param(0, inject(TYPES.Services.Server)),
    __param(1, inject(TYPES.Configurations.Main)),
    __param(2, inject(TYPES.Logger)),
    __param(3, inject(TYPES.Connections.Database)),
    __metadata("design:paramtypes", [Object, Object, Object, Object])
], PouchArchiver);
export { PouchArchiver };
//# sourceMappingURL=pouchArchiver.js.map