Node.js中的行为不可靠

Question

I have a Node.js application that, upon initialisation, reads two tables from an SQL database and reconstructs their relationship in memory. They're used for synchronously looking up data that changes (very) infrequently.

Problem : Sometimes I can't access the data, even though the application reports successfully loading it.

Code:

constants.js

module.exports = {
  ready: function () { return false; }
};

var log = sysLog('core', 'constants')
  , Geo = require('../models/geo.js');

var _ready     = false
  , _countries = []
  , _carriers  = [];

function reload() {
  _ready = false;

  var index = Object.create(null);

  return Geo.Country.find().map(function (country) {
      var obj = country.toPlainObject()
        , id  = obj.id;

      delete obj.id;
      index[id] = obj;

      return Object.freeze(obj);
    }).then(function (countries) {
      log.debug('Loaded ' + countries.length + ' countries');

      _countries = countries;

      return Geo.Carrier.Descriptor.find().map(function (carrier) {
          var obj = carrier.toPlainObject();

          if (obj.country) {
            obj.country = index[obj.country];
          }

          return Object.freeze(obj);
        }).then(function (carriers) {
          log.debug('Loaded ' + carriers.length + ' carriers');

          _carriers = carriers;
        });
    }).finally(function () {
      _ready = true;
    });
}

reload().catch(function (err) {
  log.crit({ message: 'Could not load constants', reason: err });
  process.exit(-42);
}).done();

module.exports = {
  reload    : reload,

  ready     : function () { return _ready; },

  countries : function () { return _countries; },
  carriers  : function () { return _carriers; }
};

utils.js

var log       = sysLog('core', 'utils')
  , constants = require('./constants');

module.exports = {
  getCountryByISO: function(iso) {
    if (!iso) {
      return;
    }

    if ('string' != typeof iso) {
      throw new Error('getCountryByISO requires a string');
    }

    if (!constants.ready()) {
      throw new UnavailableError('Try again in a few seconds');
    }

    switch (iso.length) {
      case 2:
        return _.findWhere(constants.countries(), { 'iso2' : iso.toUpperCase() });

      case 3:
        return _.findWhere(constants.countries(), { 'iso3' : iso.toUpperCase() });

      default:
        throw new Error('getCountryByISO requires a 2 or 3 letter ISO code');
    }
  },

  getCarrierByCode: function(code) {
    if (!code) {
      return;
    }

    if ('string' != typeof code) {
      throw new Error('getCarrierByCode requires a string');
    }

    if (!constants.ready()) {
      throw new UnavailableError('Try again in a few seconds');
    }

    return _.findWhere(constants.carriers(), { 'code' : code });
  },

  getCarrierByHandle: function(handle) {
    if (!handle) {
      return;
    }

    if ('string' != typeof handle) {
      throw new Error('getCarrierByHandle requires a string');
    }

    if (!constants.ready()) {
      throw new UnavailableError('Try again in a few seconds');
    }

    return _.findWhere(constants.carriers(), { 'handle' : handle });
  }
};

Use case

if (data.handle) {
  carrier = utils.getCarrierByHandle(data.handle);

  if (_.isEmpty(carrier)) {
    throw new InternalError('Unknown carrier', { handle: data.handle });
  }
}

What's going on: All errors are logged; as soon as I see an error (ie "Unknown carrier") in the logs, I check the SQL database to see if it should've been recognised. That has always been the case so far, so I check the debug log to see if data was loaded. I always see "Loaded X countries" and "Loaded Y carriers" with correct values and no sign of "Could not load constants" or any other kind of trouble.

This happens around 10% of the time I start the application and the problem persists (ie didn't seem to go away after 12+ hours) and seems to occur regardless of input, leading me to think that the data isn't referenced correctly.

Questions:

1. Is there something wrong in constants.js or am I doing something very obviously wrong? I've tried setting it up for cyclical loading (even though I am not aware of that happening in this case).

2. Why can't I (sometimes) access my data?

3. What can I do to figure out what's wrong?

4. Is there any way I can work around this? Is there anything else I could to achieve the desired behaviour? Hard-coding the data in constants.js is excluded.

Additional information:

• constants.reload() is never actually called from outside of constants.js .

• constants.js is require d only in utils.js .

• utils.js is require d in app.js (application entry); all files require d before it do not require it.

• SQL access is done through an in-house library built on top of knex.js and bluebird; so far it's been very stable.

Versions:

Node.js v0.10.33

underscore 1.7.0

bluebird 2.3.11

knex 0.6.22

Answer 1

constants.reload() is never actually called from outside of constants.js.

That's your issue. constants.reload() reads from a database, which is an aysnchronous process. Node's require() is a synchronous process. At the time constants.js is required in utils.js and the module.exports value is returned, your database query is still running. And at whatever point in time that app.js reaches the point where it calls a method from the utils module, that query could still be running, resulting in the error.

You could say that requiring utils.js has the side-effect of requiring constants.js, which has the side-effect of executing a database query, which has the side-effect of concurrently modifying the free variables _countries and _carriers .

Initialize _countries and _carriers as unresolved promises. Have reload() resolve them. Make the utils.js api async.

promises.js:

// ...

var Promise = require('bluebird');

var countriesResolve
  , carriersResolve;

var _ready     = false
  , _countries = new Promise(function (resolve) {
      countriesResolve = resolve;
  })
  , _carriers  = new Promise(function (resolve) {
      carriersResolve = resolve;
  });

function reload() {
  _ready = false;

  var index = Object.create(null);

  return Geo.Country.find().map(function (country) {
      // ...
    }).then(function (countries) {
      log.debug('Loaded ' + countries.length + ' countries');

      countriesResolve(countries);

      return Geo.Carrier.Descriptor.find().map(function (carrier) {
          // ...
        }).then(function (carriers) {
          log.debug('Loaded ' + carriers.length + ' carriers');

          carriersResolve(carriers);
        });
    }).finally(function () {
      _ready = true;
    });
}

reload().catch(function (err) {
  log.crit({ message: 'Could not load constants', reason: err });
  process.exit(-42);
}).done();

module.exports = {
  reload    : reload,

  ready     : function () { return _ready; },

  countries : function () { return _countries; },
  carriers  : function () { return _carriers; }
};

utils.js

getCarrierByHandle: function(handle) {
  // ...

  return constants.carriers().then(function (carriers) {
    return _.findWhere(carriers, { 'handle' : handle });
  });
}

Use case:

utils.getCarrierByHandle(data.handle).then(function (carrier) {
  if (_.isEmpty(carrier)) {
    throw new InternalError('Unknown carrier', { handle: data.handle });
  }
}).then(function () {
  // ... next step in application logic
});

This design will also eliminate the need for a ready method.

Alternatively, you could call constants.reload() on initialization and hang all possibly-dependent operations until it completes. This approach would also obsolete the ready method.

What can I do to figure out what's wrong?

You could have analyzed your logs and observed that "Loaded X countries" and "Loaded Y carriers" were sometimes written after "Unknown carrier", helping you realize that the success of utils.getCarrierByHandle() was a race condition.

Answer 2

}).finally(function () {
  _ready = true;
});

Code in a finally will always get called, regardless of if an error was thrown up the promise chain. Additionally, your reload().catch(/* ... */) clause will never be reached, because finally swallows the error.

Geo.Country.find() or Geo.Carrier.Descriptor.find() could throw an error, and _ready would still be set to true , and the problem of your countries and carriers not being set would persist.

This problem would not have occurred if you had designed your system without a ready call, as I described in my previous post. Hopefully this informs you that the issue here is really beyond finally swallowing a catch . The real issue is relying on side-effects ; the modification of free variables results in brittle systems, especially when asynchrony is involved. I highly recommend against it.

Answer 3

Try this

var log = sysLog('core', 'constants');
var Geo = require('../models/geo.js');
var index;
var _countries; 
var _carriers;

function reload() {
  index = Object.create(null);
  _countries = Geo.Country.find().map(function (country) {
    var obj = country.toPlainObject();
    var id  = obj.id;

    delete obj.id;
    index[id] = obj;

    return Object.freeze(obj);
  });

  _carriers = _countries.then(function(countries) {
    return Geo.Carrier.Descriptor.find().map(function (carrier) {
      var obj = carrier.toPlainObject();

      if (obj.country) {
        obj.country = index[obj.country];
      }

      return Object.freeze(obj);
    });
  });
  return _carriers;
}

reload().done();

module.exports = {
  reload    : reload,
  countries : function () { return _countries; },
  carriers  : function () { return _carriers; }
};