Wait for an event to happen before sending HTTP response in NodeJS?

Question

I'm looking for a solution to waiting for an event to happen before sending a HTTP response.

Use Case

1. The idea is I call a function in one of my routes: zwave.connect("/dev/ttyACM5"); This function return immediately.
2. But there exists 2 events that notice about if it succeed or fail to connect the device:

zwave.on('driver ready', function(){...});
zwave.on('driver failed', function(){...});

3. In my route, I would like to know if the device succeed or fail to connect before sending the HTTP response.

My "solution"

1. When an event happen, I save the event in a database:

zwave.on('driver ready', function(){
    //In the database, save the fact the event happened, here it's event "CONNECTED"
});

2. In my route, execute the connect function and wait for the event to appear in the database:

router.get('/', function(request, response, next) {     
    zwave.connect("/dev/ttyACM5");
    waitForEvent("CONNECTED", 5, null, function(){
        response.redirect(/connected);
    });
});

// The function use to wait for the event
waitForEvent: function(eventType, nbCallMax, nbCall, callback){
    if(nbCall == null) nbCall = 1;
    if(nbCallMax == null) nbCallMax = 1;

    // Looking for event to happen (return true if event happened, false otherwise
    event = findEventInDataBase(eventType);

    if(event){
        waitForEvent(eventType, nbCallMax, nbCall, callback);
    }else{
        setTimeout(waitForEvent(eventType, callback, nbCallMax, (nbCall+1)), 1500);
    }
}

I don't think it is a good practice because it iterates calls over the database. So what are your opinions/suggestions about it?

Inefficiency

Answer 1

I've gone ahead and added the asynchronous and control-flow tags to your question because at the core of it, that is what you're asking about. (As an aside, if you're not using ES6 you should be able to translate the code below back to ES5.)

TL;DR

There are a lot of ways to handle async control flow in JavaScript (see also: What is the best control flow module for node.js?). You are looking for a structured way to handle it—likely Promises or the Reactive Extensions for JavaScript (a.k.a RxJS).

Example using a Promise

From MDN:

The Promise object is used for asynchronous computations. A Promise represents a value which may be available now, or in the future, or never.

The async computation in your case is the computation of a boolean value describing the success or failure to connect to the device. To do so, you can wrap the call to connect in a Promise object like so:

const p = new Promise((resolve) => {
    // This assumes that the events are mutually exclusive
    zwave.connect('/dev/ttyACM5');
    zwave.on('driver ready', () => resolve(true));
    zwave.on('driver failed', () => resolve(false));
});

Once you have a Promise representing the state of the connection, you can attach functions to its "future" value:

// Inside your route file
const p = /* ... */;
router.get('/', function(request, response, next) {
    p.then(successful => {
        if (successful) {
            response.redirect('/connected');
        }
        else {
            response.redirect('/failure');
        }
    });
});

You can learn more about Promises on MDN, or by reading one of many other resources on the topic (e.g. You're Missing the Point of Promises).

Ultraism

Work as I expected ! Thanks for your helpful reply ;) – Inefficiency

This solution is great, but I have a problem. What if I want the block then is executed each time a event is executed? – Termor

Answer 2

Have you tried this? From the look of it, your zwave probably have already implemented an EventEmmiter, you just need to attach a listener to it

router.get('/', function(request, response, next) {     
    zwave.connect("/dev/ttyACM5");
    zwave.once('driver ready', function(){
        response.redirect(/connected);
    });
});

Bullfight

This works provide your zwave.connect is asynchronous. Otherwise, add the once listener before you connect. – Bullfight

Answer 3

There is a npm sync module also. which is used for synchronize the process of executing the query.

When you want to run parallel queries in synchronous way then node restrict to do that because it never wait for response. and sync module is much perfect for that kind of solution.

Sample code

   /*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

reference link: https://www.npmjs.com/package/sync

Adela