@jesec/flood 0.0.0-master.8daf3f8 → 0.0.0-master.8dbd865

package/dist/server/models/HistoryEra.js

@@ -1,168 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const nedb_1 = __importDefault(require("nedb"));
-const path_1 = __importDefault(require("path"));
-const config_1 = __importDefault(require("../../config"));
-const MAX_NEXT_ERA_UPDATE_INTERVAL = 1000 * 60 * 60 * 12; // 12 hours
-const CUMULATIVE_DATA_BUFFER_DIFF = 500; // 500 miliseconds
-const REQUIRED_FIELDS = ['interval', 'maxTime', 'name'];
-const hasRequiredFields = (opts) => {
-    let requirementsMet = true;
-    REQUIRED_FIELDS.forEach((field) => {
-        if (opts[field] == null) {
-            console.error(`HistoryEra requires ${field}`);
-            requirementsMet = false;
-        }
-    });
-    return requirementsMet;
-};
-class HistoryEra {
-    constructor(user, opts) {
-        opts = opts || {};
-        if (!hasRequiredFields(opts)) {
-            return;
-        }
-        this.data = [];
-        this.opts = opts;
-        this.ready = false;
-        this.user = user;
-        this.startedAt = Date.now();
-        this.db = this.loadDatabase(this.opts.name);
-        this.setLastUpdate(this.db);
-        this.removeOutdatedData(this.db);
-        let cleanupInterval = this.opts.maxTime;
-        let { nextEraUpdateInterval } = this.opts;
-        if (cleanupInterval === 0 || cleanupInterval > config_1.default.dbCleanInterval) {
-            cleanupInterval = config_1.default.dbCleanInterval;
-        }
-        if (nextEraUpdateInterval && nextEraUpdateInterval > MAX_NEXT_ERA_UPDATE_INTERVAL) {
-            nextEraUpdateInterval = MAX_NEXT_ERA_UPDATE_INTERVAL;
-        }
-        if (nextEraUpdateInterval) {
-            this.startNextEraUpdate(nextEraUpdateInterval, this.db);
-        }
-        this.startAutoCleanup(cleanupInterval, this.db);
-    }
-    loadDatabase(dbName) {
-        const db = new nedb_1.default({
-            autoload: true,
-            filename: path_1.default.join(config_1.default.dbPath, this.user._id, 'history', `${dbName}.db`),
-        });
-        this.ready = true;
-        return db;
-    }
-    addData(data) {
-        if (!this.ready) {
-            console.error('database is not ready');
-            return;
-        }
-        const currentTime = Date.now();
-        if (currentTime - this.lastUpdate >= this.opts.interval - CUMULATIVE_DATA_BUFFER_DIFF) {
-            this.lastUpdate = currentTime;
-            this.db.insert({
-                ts: currentTime,
-                up: Number(data.upload),
-                dn: Number(data.download),
-            });
-        }
-        else {
-            this.db.find({ ts: this.lastUpdate }, (err, docs) => {
-                if (docs.length !== 0) {
-                    const doc = docs[0];
-                    const numUpdates = Number(doc.num || 1);
-                    const currentDownAvg = Number(doc.dn);
-                    const currentUpAvg = Number(doc.up);
-                    const downAvg = ((currentDownAvg * numUpdates + Number(data.download)) / (numUpdates + 1)).toFixed(1);
-                    const upAvg = ((currentUpAvg * numUpdates + Number(data.upload)) / (numUpdates + 1)).toFixed(1);
-                    // TODO: Remove this nonsense, I think this bug is resolved.
-                    if (downAvg == null || upAvg == null) {
-                        console.error('\n\n');
-                        console.error('Warning: null values set in database!');
-                        console.error(`DB: ${this.opts.name}`);
-                        console.error(`numUpdates: ${numUpdates}
-currentDownAvg: ${currentDownAvg}
-currentUpAvg: ${currentUpAvg}
-downAvg: ${downAvg}
-upAvg: ${upAvg}`);
-                        console.error('\n\n');
-                    }
-                    this.db.update({
-                        ts: this.lastUpdate,
-                    }, {
-                        ts: this.lastUpdate,
-                        up: Number(upAvg),
-                        dn: Number(downAvg),
-                        num: numUpdates + 1,
-                    });
-                }
-            });
-        }
-    }
-    cleanup(db) {
-        this.removeOutdatedData(db);
-        db.persistence.compactDatafile();
-    }
-    getData(opts, callback) {
-        const minTimestamp = Date.now() - this.opts.maxTime;
-        this.db
-            .find({ ts: { $gte: minTimestamp } })
-            .sort({ ts: 1 })
-            .exec((err, docs) => {
-            if (err) {
-                callback(null, err);
-                return;
-            }
-            callback(docs);
-        });
-    }
-    removeOutdatedData(db) {
-        if (this.opts.maxTime > 0) {
-            const minTimestamp = Date.now() - this.opts.maxTime;
-            db.remove({ ts: { $lt: minTimestamp } }, { multi: true });
-        }
-    }
-    setLastUpdate(db) {
-        let lastUpdate = 0;
-        db.find({}, (err, docs) => {
-            docs.forEach((doc) => {
-                if (doc.ts > lastUpdate) {
-                    lastUpdate = doc.ts;
-                }
-            });
-            this.lastUpdate = lastUpdate;
-        });
-    }
-    startAutoCleanup(interval, db) {
-        this.autoCleanupInterval = setInterval(this.cleanup.bind(this, db), interval);
-    }
-    startNextEraUpdate(interval, currentDB, nextDB) {
-        this.nextEraUpdateInterval = setInterval(this.updateNextEra.bind(this, currentDB, nextDB), interval);
-    }
-    stopAutoCleanup() {
-        clearInterval(this.autoCleanupInterval);
-        this.autoCleanupInterval = null;
-    }
-    stopNextEraUpdate() {
-        clearInterval(this.nextEraUpdateInterval);
-        this.nextEraUpdateInterval = null;
-    }
-    updateNextEra(currentDB) {
-        const minTimestamp = Date.now() - this.opts.nextEraUpdateInterval;
-        currentDB.find({ ts: { $gte: minTimestamp } }, (err, docs) => {
-            let downTotal = 0;
-            let upTotal = 0;
-            docs.forEach((doc) => {
-                downTotal += Number(doc.dn);
-                upTotal += Number(doc.up);
-            });
-            this.opts.nextEra.addData({
-                download: Number(downTotal / docs.length).toFixed(1),
-                upload: Number(upTotal / docs.length).toFixed(1),
-            });
-        });
-    }
-}
-exports.default = HistoryEra;

package/dist/server/models/ServerEvent.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class ServerEvent {
-    constructor(res) {
-        this.data = '';
-        this.res = res;
-        // Add 2kb padding for IE.
-        const padding = new Array(2049);
-        res.write(`:${padding.join(' ')}\n`);
-    }
-    addData(data) {
-        const lines = JSON.stringify(data).split(/\n/);
-        this.data = lines.reduce((accumulator, datum) => `${this.data}data:${datum}\n`, this.data);
-    }
-    emit() {
-        this.res.write(`${this.data}\n`);
-        this.res.flush();
-        this.data = '';
-    }
-    setID(id) {
-        this.res.write(`id:${id}\n`);
-    }
-    setType(eventType) {
-        this.res.write(`event:${eventType}\n`);
-    }
-}
-exports.default = ServerEvent;

package/dist/server/models/TemporaryStorage.js

@@ -1,20 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const config_1 = require("../../config");
-class TemporaryStorage {
-    constructor() {
-        fs_1.default.mkdirSync(config_1.tempPath, { recursive: true });
-    }
-    static deleteFile(filename) {
-        fs_1.default.unlinkSync(TemporaryStorage.getTempPath(filename));
-    }
-    static getTempPath(filename) {
-        return path_1.default.join(config_1.tempPath, filename);
-    }
-}
-exports.default = new TemporaryStorage();

package/dist/server/models/Users.js

@@ -1,171 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const argon2_browser_1 = __importDefault(require("argon2-browser"));
-const crypto_1 = __importDefault(require("crypto"));
-const nedb_1 = __importDefault(require("nedb"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const config_1 = __importDefault(require("../../config"));
-const services_1 = __importDefault(require("../services"));
-class Users {
-    constructor() {
-        this.db = Users.loadDatabase();
-        this.configUser = {
-            _id: '_config',
-            username: '_config',
-            host: config_1.default.configUser.socket ? null : config_1.default.configUser.host,
-            port: config_1.default.configUser.socket ? null : config_1.default.configUser.port,
-            socketPath: config_1.default.configUser.socket ? config_1.default.configUser.socketPath : null,
-            password: '',
-            isAdmin: true,
-        };
-    }
-    static loadDatabase() {
-        const db = new nedb_1.default({
-            autoload: true,
-            filename: path_1.default.join(config_1.default.dbPath, 'users.db'),
-        });
-        db.ensureIndex({ fieldName: 'username', unique: true });
-        return db;
-    }
-    getConfigUser() {
-        return this.configUser;
-    }
-    bootstrapServicesForAllUsers() {
-        this.listUsers((users, err) => {
-            if (err)
-                throw err;
-            if (users && users.length) {
-                users.forEach(services_1.default.bootstrapServicesForUser);
-            }
-        });
-    }
-    comparePassword(credentials, callback) {
-        this.db.findOne({ username: credentials.username }, (err, user) => {
-            if (err) {
-                return callback(false, false, err);
-            }
-            // Wrong data provided
-            if (credentials == null || credentials.password == null) {
-                return callback(false, false, new Error());
-            }
-            // Username not found.
-            if (user == null) {
-                return callback(false, false, user);
-            }
-            argon2_browser_1.default
-                .verify({ pass: credentials.password, encoded: user.password })
-                .then(() => callback(true, user.isAdmin))
-                .catch((e) => callback(false, false, e));
-            return undefined;
-        });
-    }
-    createUser(credentials, callback) {
-        const { password, username, host, port, socketPath, isAdmin } = credentials;
-        if (this.db == null) {
-            return callback(null, new Error('Users database is not ready.'));
-        }
-        if (username === '' || username == null) {
-            return callback(null, new Error('Username cannot be empty.'));
-        }
-        if (password == null) {
-            return callback(null, new Error('Password cannot be empty'));
-        }
-        if ((host == null || Number(port) == null) && socketPath == null) {
-            return callback(null, new Error('Connection settings cannot be empty'));
-        }
-        argon2_browser_1.default
-            .hash({ pass: password, salt: crypto_1.default.randomBytes(16).toString('hex') })
-            .then((hash) => {
-            const userEntry = {
-                username,
-                password: hash.encoded,
-                host: host || null,
-                port: Number(port) || null,
-                socketPath: socketPath || null,
-                isAdmin: isAdmin || false,
-            };
-            this.db.insert(userEntry, (error, user) => {
-                if (error) {
-                    if (error.message.includes('violates the unique constraint')) {
-                        return callback(null, new Error('Username already exists.'));
-                    }
-                    return callback(null, error);
-                }
-                services_1.default.bootstrapServicesForUser(user);
-                return callback({ username });
-            });
-        })
-            .catch((error) => {
-            callback(null, error);
-        });
-        return undefined;
-    }
-    removeUser(username, callback) {
-        this.db.findOne({ username }, (findError, user) => {
-            if (findError) {
-                return callback(null, findError);
-            }
-            // Username not found.
-            if (user == null || user._id == null) {
-                return callback(null, new Error('User not found.'));
-            }
-            this.db.remove({ username }, {}, (removeError) => {
-                if (removeError) {
-                    return callback(null, removeError);
-                }
-                fs_1.default.rmdirSync(path_1.default.join(config_1.default.dbPath, user._id), { recursive: true });
-                return callback({ username });
-            });
-            return undefined;
-        });
-    }
-    updateUser(username, userRecordPatch, callback) {
-        this.db.update({ username }, { $set: userRecordPatch }, undefined, (err, numUsersUpdated, updatedUser) => {
-            if (err) {
-                return callback(null, err);
-            }
-            // Username not found.
-            if (numUsersUpdated === 0) {
-                return callback(null, err);
-            }
-            return callback(updatedUser);
-        });
-    }
-    initialUserGate(handlers) {
-        this.db.find({}, (_err, users) => {
-            if (users && users.length > 0) {
-                return handlers.handleSubsequentUser();
-            }
-            return handlers.handleInitialUser();
-        });
-    }
-    lookupUser(credentials, callback) {
-        if (config_1.default.disableUsersAndAuth) {
-            return callback(null, this.getConfigUser());
-        }
-        this.db.findOne({ username: credentials.username }, (err, user) => {
-            if (err) {
-                return callback(err);
-            }
-            return callback(null, user);
-        });
-        return undefined;
-    }
-    listUsers(callback) {
-        if (config_1.default.disableUsersAndAuth) {
-            return callback([this.getConfigUser()]);
-        }
-        this.db.find({}, (err, users) => {
-            if (err) {
-                return callback(null, err);
-            }
-            return callback(users);
-        });
-        return undefined;
-    }
-}
-exports.default = new Users();