This might be kind of an anti pattern, but what would be the best way to simulate a a promise callback when emitting data from client to server using socket.io?

For some event I would very much like it to behave like a normal get request so the client send data to the server and the server could reply with a response and then resolve or reject the promise.

This might be kind of an anti pattern, but what would be the best way to simulate a a promise callback when emitting data from client to server using socket.io?

For some event I would very much like it to behave like a normal get request so the client send data to the server and the server could reply with a response and then resolve or reject the promise.

• javascript
• node.js
• socket.io

3 Answers 3

Here's what I did. I created a function that emits a socket mand, and then returns a promise. My one caveat is I haven't done a lot with this code yet, so it might need some tweaking. It also requires Q for its promises/deferreds.

Client function definition:

var EmitPromise = function( socket, mand, data ) {

    var deferred = Q.defer();

    socket.emit(mand, data, function( response ) {

        if( typeof response === "object" ) {

            if( response.success === true ) {

                deferred.resolve(response.data);

            } else {
                if( typeof response.message === "string" ) {
                    deferred.reject( response.message );
                } else {
                    deferred.reject( "The request was not successful." )
                }
            }
        } else {

            deferred.reject( "The response to your request could not be parsed." );
        }

    });

    return deferred.promise.timeout( 30000, "The request took too long to respond." );
}

Client side code to make the call:

EmitPromise( socket, "getValue", "username" )
.then(
    function( data ) {

        console.log(data);
        return EmitPromise( socket, "getValue", "anotherValue" );

    }, function( message ) {
        console.log(message);
    }
).then(
    //Chain your mands from here
);

Server side handler

The most important part of this handler is that the second parameter, here named setValueResult must be called with an object that contains a "success" key that holds a true or false value. This was a decision on my part to provide a way to reject the promise in case of some kind of error on the server side.

socket.on( 'getValue', function( valueName, setValueResult ) {

    var value = getValue(valueName) //Do something with value here

    if( value ) {
        setValueResult({
            success : success,
            data : value
        });
    } else {
        setValueResult({
            success : success
            message : "Unable to retrieve value"
        });
    }
}

Well, you have to keep track of requests. So I would start with a "global" counter (it does not have to be global, it's enough that it is visible for two functions defined bellow) which will be incremented on each request (and emitted together with it) and a "global" handler namespace. The code may look like that:

var COUNTER = 0,
    HANDLERS = {};

var custom_get = function(data, clb) {
    COUNTER++;
    var msg = {id: COUNTER, data: data};
    socket.emit("GET", JSON.stringify(msg));
    HANDLERS[COUNTER] = clb;    
};

socket.on("GET", function(data) {
    var res = JSON.parse(data);
    HANDLERS[res.id](res.data);
    delete HANDLERS[res.id];
});

Now you just have to make sure that the server will respond with the same format, i.e. JSON

{id:X, data:Y}

and will use the same ID for the same request. You can use this code like this:

custom_get("test", function(res) {
    console.log(res);
});

You can also play with that code adding for example timeouts.

Finally have a look at JSON-RPC. It's a proper protocol which is simple and you can easily implement it over WebSocket.

The current socket.io version 2.1.0 allows sending callback functions to the server:

Client

socket.emit('ferret', 'tobi', (data) => {
  console.log(data); // data will be 'woot'
});

Server

socket.on('ferret', (name, callback) => {
  callback('woot');
});

You can also create a promise before the emit and resolve it in the client callback function.