src/bgtask.js

   1 /*
   2     bgtask.js
   3
   4     Registers background jobs to run periodically while the server is
   5     running.
   6 */
   7
   8 var Config = require("./config");
   9 var db = require("./database");
  10 var Promise = require("bluebird");
  11
  12 const LOGGER = require('@calzoneman/jsli')('bgtask');
  13
  14 var init = null;
  15
  16 /* Alias cleanup */
  17 function initAliasCleanup() {
  18     var CLEAN_INTERVAL = parseInt(Config.get("aliases.purge-interval"));
  19     var CLEAN_EXPIRE = parseInt(Config.get("aliases.max-age"));
  20
  21     setInterval(function () {
  22         db.cleanOldAliases(CLEAN_EXPIRE, function (err) {
  23             LOGGER.info("Cleaned old aliases");
  24             if (err)
  25                 LOGGER.error(err);
  26         });
  27     }, CLEAN_INTERVAL);
  28 }
  29
  30 /* Password reset cleanup */
  31 function initPasswordResetCleanup() {
  32     var CLEAN_INTERVAL = 8*60*60*1000;
  33
  34     setInterval(function () {
  35         db.cleanOldPasswordResets(function (err) {
  36             if (err)
  37                 LOGGER.error(err);
  38         });
  39     }, CLEAN_INTERVAL);
  40 }
  41
  42 function initChannelDumper(Server) {
  43     const chanPath = Config.get('channel-path');
  44     var CHANNEL_SAVE_INTERVAL = parseInt(Config.get("channel-save-interval"))
  45                                 * 60000;
  46     setInterval(function () {
  47         if (Server.channels.length === 0) {
  48             return;
  49         }
  50
  51         var wait = CHANNEL_SAVE_INTERVAL / Server.channels.length;
  52         LOGGER.info(`Saving channels with delay ${wait}`);
  53         Promise.reduce(Server.channels, (_, chan) => {
  54             return Promise.delay(wait).then(async () => {
  55                 if (!chan.dead && chan.users && chan.users.length > 0) {
  56                     try {
  57                         await chan.saveState();
  58                         LOGGER.info(`Saved /${chanPath}/${chan.name}`);
  59                     } catch (error) {
  60                         LOGGER.error(
  61                             'Failed to save /%s/%s: %s',
  62                             chanPath,
  63                             chan ? chan.name : '<undefined>',
  64                             error.stack
  65                         );
  66                     }
  67                 }
  68             }).catch(error => {
  69                 LOGGER.error(`Failed to save channel: ${error.stack}`);
  70             });
  71         }, 0).catch(error => {
  72             LOGGER.error(`Failed to save channels: ${error.stack}`);
  73         });
  74     }, CHANNEL_SAVE_INTERVAL);
  75 }
  76
  77 function initAccountCleanup() {
  78     setInterval(() => {
  79         (async () => {
  80             let rows = await db.users.findAccountsPendingDeletion();
  81             for (let row of rows) {
  82                 try {
  83                     await db.users.purgeAccount(row.id);
  84                     LOGGER.info('Purged account from request %j', row);
  85                 } catch (error) {
  86                     LOGGER.error('Error purging account %j: %s', row, error.stack);
  87                 }
  88             }
  89         })().catch(error => {
  90             LOGGER.error('Error purging deleted accounts: %s', error.stack);
  91         });
  92     }, 3600 * 1000);
  93 }
  94
  95 module.exports = function (Server) {
  96     if (init === Server) {
  97         LOGGER.warn("Attempted to re-init background tasks");
  98         return;
  99     }
 100
 101     init = Server;
 102     initAliasCleanup();
 103     initChannelDumper(Server);
 104     initPasswordResetCleanup();
 105     initAccountCleanup();
 106 };