Scaffolding a Node.js app properly without Express (the app doesn't receive requests)

Question

[This question is quite vague, I apologize for it. I'm trying to address my various troubles by answering the question myself]

I am building a Node.js app which has to perform various tasks at given intervals. Here is the global scaffold (involves bluebird promises and mongoose for DB interactions) :

var Promise = require("bluebird");
var mongoose = require('mongoose');
mongoose.Promise = require('bluebird');

// Personal modules
var bootApp = require(...);
var doStuffA = require(...);
var doStuffB = require(...);
var doStuffC = require(...);

// running locally, but meant to be deployed at some point
mongoose.connect('mongodb://localhost:27017/myDatabase');
var db = mongoose.connection;

db.on('error', () => {
  console.log("Error : lost connection !"));
  process.exit(1);
});

db.once('open', () => {
 
  bootApp()  // always start by booting
  .then( () => {  // then start the infinite loop of events

    setInterval(doStuffA, 1000*60*60); // 1x/1h
    setInterval(doStuffB, 1000*60*10); // 1x/10min
    setInterval(doStuffC, 1000*60*3); // 1x/3min

  }).catch((e) => {  // errors are handled by doStuffX(), so we should never catch anything here
    console.log(e.message);
    process.exit(1);
  });
});

Each module doStuffX is a function returning a Promise, handling its own errors, and should finish at some point.

Expected behaviour for the entire app :

• The app should be able to run forever
• The app should try to doStuffX() at the given interval, regardless of whether it succeeded or failed last time.
• [Optional :] The app should close smoothly without retrying any doStuff upon receiving a "shut down" signal.

My question : how to build a clean scaffold for such an app ? Can I get rid of setInterval and use promises instead ? One of my main concerns is to make sure the previous instance of doStuffX() is finished before starting the next one, even if it involves "killing" it in some way.

I am open to any link about scaffolding apps, but PLEASE DO NOT GIVE ME AN ANSWER/LINK INVOLVING EXPRESS : I don't need Express, since my app doesn't receive any request. (everything I found so far starts with Express :/)

Answer 1

If you don't want to start the next doStuffX() until the previous one is done, then you can replace your setInterval() with repeated setTimeout() calls.

function runA() {
    setTimeout(function() {
        doStuffA().then(runA).catch(function(err) {
            // decide what to do differently if doStuffA has an error
        });
    }, 1000*60*60);
}

runA();

You could also add a timeout to this so that if doStuffA() doesn't respond within a certain amount of time, then you take some other action. This would involve using another timer and a timeout flag.

Answer 2

[I answer my own question, trying to put here everything I changed afterwards, in case someone falls into this page someday...]

For the Mongoose part of the scaffold, here is what I got so far for a reliable long-term DB connection :

• The Mongoose documentation gives a fancy way to ensure the driver will never give up on trying to reconnect with reconnectTries
• I don't really understand socketOptions and keepalive which seem related to replicas, so I leave them out of my code for now
• Since Mongoose should autoreconnect whenever something goes wrong, I'll keep the db.once('open') as the access to the app code itself, even though I don't really understand yet the difference with db.on('connected')
• I recommend reading this.

var Promise = require("bluebird");
var mongoose = require('mongoose');
mongoose.Promise = require('bluebird');

// Personal modules
var bootApp = require(...);
var doStuffA = require(...);
var doStuffB = require(...);
var doStuffC = require(...);

// running locally, but meant to be deployed at some point
var uri = 'mongodb://localhost:27017/myDatabase';
// the added option makes sure the app will always try to reconnect...
mongoose.connect(uri, { server: { reconnectTries: Number.MAX_VALUE } });
var db = mongoose.connection;

db.on('error', () => {
  console.log("Error with Mongoose connection."));
});

db.once('open', () => {
 
  bootApp()  // always start by booting
  .then( () => {  // then start the infinite loop of events

    //////////////////////////////////
    /// Here goes the actual stuff ///
    //////////////////////////////////

  }).catch((e) => {  // errors are handled by doStuffX(), so we should never catch anything here
    console.log(e.message);
  });
});

Now, for the actual repetitive stuff, my objective is to make sure everything runs smoothly, and that no process gets stuck. About the changes I made :

• The methods used are not native ES6 but are specific to bluebird. You can read about .timeout() and .delay() which I find very useful for chaining timeouts and intervals in a clean code.
• In my mind, .then(runA, runA) should always launch ONE UNIQUE instance of runA but I'm concerned about whether I could actually end up launching two parallel instances...

// Instead of using setInterval in a bluebird promised environment...

setInterval(doStuffA, 1000*60*60); // 1x/1h

// I would have liked a full promise chain, but as jfriend00 stated,
// It will end up crashing because the initial promise is never resolved...

function runA() {
  return doStuffA() 
  .timeout(1000*60*30) // kill the running instance if it takes longer than 30min
  .delay(1000*60*60) // wait 60min
  .then(runA, runA); // whatever the outcome, restart the process
}
runA();

// Therefore, a solution like jfriend00's seems like the way to go :

function runA() {
    setTimeout(function() {
        doStuffA()
        .timeout(1000*60*30)
        .then(runA, runA)
    }, 1000*60*60);
}
runA();