shadowsocks-manager/plugins/flowSaver/index.js

A shadowsocks manager tool for multi user and traffic control.

const log4js = require('log4js');
const logger = log4js.getLogger('flowSaver');
const path = require('path');
appRequire('plugins/flowSaver/server');
appRequire('plugins/flowSaver/flow');
appRequire('plugins/flowSaver/generateFlow');
const cron = appRequire('init/cron');
const knex = appRequire('init/knex').knex;
const manager = appRequire('services/manager');
const moment = require('moment');
const minute = 1;
const time = minute * 60 * 1000;

let accountInfo = {};

const updateAccountInfo = async () => {
  const accounts = await knex('account_plugin').select().where({});
  accountInfo = {};
  accounts.forEach(account => {
    accountInfo[account.port] = account.id;
  });
  return;
};

const updateAccountFlow = async (serverId, accountId, flow) => {
  const exists = await knex('account_flow').where({
    serverId,
    accountId,
  }).then(success => success[0]);
  if(!exists) { return; }
  await knex('account_flow').update({
    flow: exists.flow + flow,
    updateTime: Date.now(),
  }).where({
    serverId,
    accountId,
  });
};

const saveFlow = async () => {
  try {
    const servers = await knex('server').select(['id', 'name', 'host', 'port', 'password', 'shift']);
    await updateAccountInfo();
    const saveServerFlow = async server => {
      const lastestFlow = await knex('saveFlow').select(['time']).where({
        id: server.id,
      }).orderBy('time', 'desc').limit(1);
      if(lastestFlow.length === 0 || Date.now() - lastestFlow[0].time >= time) {
        const options = {
          clear: true,
        };
        let flow = await manager.send({
          command: 'flow',
          options,
        }, {
          host: server.host,
          port: server.port,
          password: server.password,
        });
        flow = flow.map(f => {
          return {
            id: server.id,
            accountId: accountInfo[f.port - server.shift] || 0,
            port: f.port,
            flow: f.sumFlow,
            time: Date.now(),
          };
        }).filter(f => {
          return f.flow > 0;
        });
        if(flow.length === 0) {
          return;
        }
        flow.forEach(async f => {
          await updateAccountFlow(f.id, f.accountId, f.flow);
        });
        const insertPromises = [];
        for(let i = 0; i < Math.ceil(flow.length / 50); i++) {
          const insert = knex('saveFlow').insert(flow.slice(i * 50, i * 50 + 50));
          insertPromises.push(insert);
        }
        await Promise.all(insertPromises);
      }
    };
    for(const server of servers) {
      await saveServerFlow(server).catch();
    }
  } catch(err) {
    logger.error(err);
    return;
  }
};

cron.minute(() => {
  saveFlow();
}, 1);