NodeJS＆Socket.IO：发出请求事件并获取响应，何时/何处应该绑定侦听器？

Question

I'm currently wondering about what could be the best programming practice in this case:

Let's say I've got client connected to my server. And this client is asking the server for authentication with an auth event and his username.

socket = io();
socket.emit('auth', "John");

In this simple case, server is responding with an auth_succeed event with the users's id.

io.on('connection', function(socket) {
    socket.on('auth', function(username) {
        socket.emit('auth_succeed', id);
    }
}

So my question is, when or where should I bind the listener for the auth_succeed event in the client ? There's two ways for me :

Before emitting, which ensures, I guess, that the response event will always be properly handled, but leads to some spaghetti code. Ex:

socket = io();
socket.on('auth_succeed', function(id){
    //Do some post-auth stuff here
}); 
socket.emit('auth', "John");

Or after emitting, which leads to cleaner code, but could possibly, I guess again, miss the event if sended quick enough. Ex:

socket = io();
socket.emit('auth', "John");
socket.on('auth_succeed', function(id){
    //Do some post-auth stuff here
}); 

What's your thoughts about that problem ?

Answer 1

Since the response from the emit should be asynchronous, and the client-side JS is synchronous in nature, the socket.on('auth_succeed' binding will happen before the callback from the auth event.

---

The following flow will happen on the client...

// EXECUTION SCOPE BEGINS
...
// this will send a message to the server
// the message and/or response will be sent asynchronously
socket.emit('auth', 'John'); 
// so your code will continue before you get anything from the server

//which means the following binding will happen before any response to the above emit
socket.on('auth_succeed', function(id){
  //... handle message from server ...
});
...
// EXECUTION SCOPE ENDS

Sometime after the enclosing scope/function is done executing the event of 'auth_succeed' be raised.

---

You may also want to consider breaking out your event handlers...

socket.on('auth_succeed', onAuthSucceed.bind(null, socket));
socket.emit('auth', 'john');

// ... elsewhere ...

function onAuthSucceed(socket, id) {
  // handle message from server
}

This will reduce the noise with your binding, and your signal event, regardless of if you choose to bind or emit first.

By having the function require anything it needs, and using binding for the event, the method in question can be in a separate file/module, and more easily tested in isolation.

Answer 2

The socket.io docs , in Migrating from 0.9, do a great job of showing how to authenticate sockets in 1.0.

An example for you would be:

You should create an authentication middleware to handle this.

Create a controller called authorization.js:

/**
 * Socket.io middleware that that authorizes clients
 * @param {object} socket
 * @param {function} next
 */
module.exports = function(socket, next) {

    // do some custom auth here
    var handshakeData = socket.request;

    // make sure the handshake data looks good with some
    // custom logic
    // if doesn't you can do this:
    // next(new Error('not authorized');
    // else just call next

    next();
}

In index.js simply attach the middleware with io.use :

var authorizeSockets = require('./controllers/authorization');
io.use(authorizeSockets);

Using io.set has been depreciated for io.use() since socket.io 1.0.

You can then let the client know that they have successfully authorized and connected by emitting auth_suceed on the connection event because with the new middleware in place, a socket will not be able to connect unless they successfully authorize.

io.on('connection', function(socket){
    socket.emit('auth_succeed', yourPayloadHere);
});

Answer 3

socket.set('authorization',function(request,callback){
// check authorization for username
// set global variable flag for valid/invalid username.
if(valid_uname){
return(null,true)
}
else{
return(null,false);
}
)};
//Now on socket.on check global variable flag.
//emit when needed.