@jesec/flood 0.0.0-master.fc39f18 → 0.0.0-master.fcbe368

package/server/models/HistoryEra.js

@@ -1,205 +0,0 @@
-const Datastore = require('nedb');
-const path = require('path');
-
-const config = 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.dbCleanInterval) {
-      cleanupInterval = config.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 Datastore({
-      autoload: true,
-      filename: path.join(config.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),
-      });
-    });
-  }
-}
-
-module.exports = HistoryEra;

package/server/models/ServerEvent.js

@@ -1,32 +0,0 @@
-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`);
-  }
-}
-
-module.exports = ServerEvent;

package/server/models/TemporaryStorage.js

@@ -1,20 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const {tempPath} = require('../../config');
-
-class TemporaryStorage {
-  constructor() {
-    fs.mkdir(tempPath, {recursive: true});
-  }
-
-  deleteFile(filename) {
-    fs.unlink(this.getTempPath(filename));
-  }
-
-  getTempPath(filename) {
-    return path.join(tempPath, filename);
-  }
-}
-
-module.exports = new TemporaryStorage();

package/server/models/Users.js

@@ -1,188 +0,0 @@
-const argon2 = require('argon2');
-const Datastore = require('nedb');
-const fs = require('fs-extra');
-const path = require('path');
-
-const config = require('../../config');
-const services = require('../services');
-
-class Users {
-  constructor() {
-    this.ready = false;
-    this.db = this.loadDatabase();
-  }
-
-  getConfigUser() {
-    const {socket} = config.configUser;
-    return {
-      _id: '_config',
-      username: '_config',
-      host: socket ? null : config.configUser.host,
-      port: socket ? null : config.configUser.port,
-      socketPath: socket ? config.configUser.socketPath : null,
-      password: '',
-      isAdmin: true,
-    };
-  }
-
-  bootstrapServicesForAllUsers() {
-    this.listUsers((users, err) => {
-      if (err) throw err;
-      if (users && users.length) {
-        users.forEach(services.bootstrapServicesForUser);
-      }
-    });
-  }
-
-  comparePassword(credentials, callback) {
-    this.db.findOne({username: credentials.username}).exec((err, user) => {
-      if (err) {
-        return callback(null, err);
-      }
-
-      // Username not found.
-      if (user == null) {
-        return callback(null, user);
-      }
-
-      argon2
-        .verify(user.password, credentials.password)
-        .then((argon2Match) => {
-          if (argon2Match) {
-            return callback(argon2Match, user.isAdmin);
-          }
-
-          callback(null, argon2Match, false);
-        })
-        .catch((error) => callback(null, error));
-    });
-  }
-
-  createUser(credentials, callback) {
-    const {password, username, host, port, socketPath, isAdmin} = credentials;
-
-    if (!this.ready) {
-      return callback(null, 'Users database is not ready.');
-    }
-
-    if (username === '' || username == null) {
-      return callback(null, 'Username cannot be empty.');
-    }
-
-    argon2
-      .hash(password)
-      .then((hash) => {
-        this.db.insert(
-          {
-            username,
-            password: hash,
-            host,
-            port,
-            socketPath,
-            isAdmin,
-          },
-          (error, user) => {
-            if (error) {
-              if (error.errorType === 'uniqueViolated') {
-                error = 'Username already exists.';
-              }
-
-              return callback(null, error);
-            }
-
-            services.bootstrapServicesForUser(user);
-
-            return callback({username});
-          },
-        );
-      })
-      .catch((error) => {
-        callback(null, error);
-      });
-  }
-
-  removeUser(username, callback) {
-    this.db.findOne({username}).exec((findError, user) => {
-      if (findError) {
-        return callback(null, findError);
-      }
-
-      // Username not found.
-      if (user == null) {
-        return callback(null, user);
-      }
-
-      this.db.remove({username}, {}, (removeError) => {
-        if (removeError) {
-          return callback(null, removeError);
-        }
-
-        fs.removeSync(path.join(config.dbPath, user._id));
-
-        return callback({username});
-      });
-    });
-  }
-
-  updateUser(username, userRecordPatch, callback) {
-    this.db.update({username}, {$set: userRecordPatch}, (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();
-    });
-  }
-
-  loadDatabase() {
-    const db = new Datastore({
-      autoload: true,
-      filename: path.join(config.dbPath, 'users.db'),
-    });
-
-    db.ensureIndex({fieldName: 'username', unique: true});
-
-    this.ready = true;
-    return db;
-  }
-
-  lookupUser(credentials, callback) {
-    if (config.disableUsersAndAuth) {
-      return callback(null, this.getConfigUser());
-    }
-    this.db.findOne({username: credentials.username}, (err, user) => {
-      if (err) {
-        return callback(err);
-      }
-
-      return callback(null, user);
-    });
-  }
-
-  listUsers(callback) {
-    if (config.disableUsersAndAuth) {
-      return callback([this.getConfigUser()]);
-    }
-    this.db.find({}, (err, users) => {
-      if (err) {
-        return callback(null, err);
-      }
-
-      return callback(users);
-    });
-  }
-}
-
-module.exports = new Users();