openhim-core/lib/autoRetry.js

The OpenHIM core application that provides logging and routing of http requests

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.setupAgenda = undefined;
exports.reachedMaxAttempts = reachedMaxAttempts;
exports.queueForRetry = queueForRetry;

var _winston = require('winston');

var _winston2 = _interopRequireDefault(_winston);

var _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

var _autoRetry = require('./model/autoRetry');

var _tasks = require('./model/tasks');

var _channels = require('./model/channels');

var Channels = _interopRequireWildcard(_channels);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const { ChannelModel } = Channels;

function reachedMaxAttempts(tx, channel) {
  return channel.autoRetryMaxAttempts != null && channel.autoRetryMaxAttempts > 0 && tx.autoRetryAttempt >= channel.autoRetryMaxAttempts;
}

async function queueForRetry(tx) {
  const retry = new _autoRetry.AutoRetryModel({
    transactionID: tx._id,
    channelID: tx.channelID,
    requestTimestamp: tx.request.timestamp
  });

  try {
    await retry.save();
  } catch (err) {
    _winston2.default.error(`Failed to queue transaction ${tx._id} for auto retry: ${err}`);
  }
}

const getChannels = callback => ChannelModel.find({ autoRetryEnabled: true, status: 'enabled' }, callback);

function popTransactions(channel, callback) {
  const to = (0, _moment2.default)().subtract(channel.autoRetryPeriodMinutes - 1, 'minutes');

  const query = {
    $and: [{ channelID: channel._id }, {
      requestTimestamp: {
        $lte: to.toDate()
      }
    }]
  };

  _winston2.default.debug(`Executing query autoRetry.findAndRemove(${JSON.stringify(query)})`);
  _autoRetry.AutoRetryModel.find(query, (err, transactions) => {
    if (err) {
      return callback(err);
    }
    if (transactions.length === 0) {
      return callback(null, []);
    }
    _autoRetry.AutoRetryModel.remove({ _id: { $in: transactions.map(t => t._id) } }, err => {
      if (err) {
        return callback(err);
      }
      return callback(null, transactions);
    });
  });
}

function createRerunTask(transactionIDs, callback) {
  _winston2.default.info(`Rerunning failed transactions: ${transactionIDs}`);
  const task = new _tasks.TaskModel({
    transactions: transactionIDs.map(t => ({ tid: t })),
    totalTransactions: transactionIDs.length,
    remainingTransactions: transactionIDs.length,
    user: 'internal'
  });

  task.save(err => {
    if (err) {
      _winston2.default.error(err);
    }
    return callback();
  });
}

function autoRetryTask(job, done) {
  const _taskStart = new Date();
  const transactionsToRerun = [];

  getChannels((err, channels) => {
    if (err) {
      return done(err);
    }
    const promises = channels.map(channel => {
      return new Promise((resolve, reject) => {
        popTransactions(channel, (err, transactions) => {
          if (err) {
            _winston2.default.error(err);
            return reject(err);
          } else if (transactions != null) {
            const tranIDs = transactions.map(r => r.transactionID);
            transactionsToRerun.push(...tranIDs);
          }
          return resolve();
        });
      });
    });

    Promise.all(promises).then(() => {
      function end() {
        _winston2.default.debug(`Auto retry task total time: ${new Date() - _taskStart} ms`);
        return done();
      }

      if (transactionsToRerun.length > 0) {
        return createRerunTask(transactionsToRerun, end);
      } else {
        end();
      }
    }).catch(done);
  });
}

function setupAgenda(agenda) {
  agenda.define('auto retry failed transactions', (job, done) => autoRetryTask(job, done));
  return agenda.every('1 minutes', 'auto retry failed transactions');
}

exports.setupAgenda = setupAgenda;


if (process.env.NODE_ENV === 'test') {
  exports.getChannels = getChannels;
  exports.popTransactions = popTransactions;
  exports.createRerunTask = createRerunTask;
  exports.autoRetryTask = autoRetryTask;
}
//# sourceMappingURL=autoRetry.js.map