Bump version to 0.4.0.

.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.6
+  - 0.7

CHANGELOG.txt

@@ -1,3 +1,20 @@
+=== 0.4.0 / 2012-02-13
+
+* Add ping() method to server-side WebSocket and EventSource
+* Buffer send() calls until the draft-76 handshake is complete
+* Fix HTTPS problems on Node 0.7
+
+
+=== 0.3.1 / 2012-01-16
+
+* Call setNoDelay(true) on net.Socket objects to reduce latency
+
+
+=== 0.3.0 / 2012-01-13
+
+* Add support for EventSource connections
+
+
 === 0.2.0 / 2011-12-21
 
 * Add support for Sec-WebSocket-Protocol negotiation

README.markdown

@@ -1,5 +1,8 @@
 # faye-websocket
 
+* Travis CI build: [<img src="https://secure.travis-ci.org/faye/faye-websocket-node.png" />](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/), [client](http://faye.jcoglan.com/autobahn/clients/)
+
 This is a robust, general-purpose WebSocket implementation extracted from the
 [Faye](http://faye.jcoglan.com) project. It provides classes for easily building
 WebSocket servers and clients in Node. It does not provide a server itself, but
@@ -49,6 +52,28 @@ server.addListener('upgrade', function(request, socket, head) {
 server.listen(8000);
 ```
 
+Note that under certain circumstances (notably a draft-76 client connecting
+through an HTTP proxy), the WebSocket handshake will not be complete after you
+call `new WebSocket()` because the server will not have received the entire
+handshake from the client yet. In this case, calls to `ws.send()` will buffer
+the message in memory until the handshake is complete, at which point any
+buffered messages will be sent to the client.
+
+If you need to detect when the WebSocket handshake is complete, you can use the
+`onopen` event.
+
+If the connection's protocol version supports it, you can call `ws.ping()` to
+send a ping message and wait for the client's response. This method takes a
+message string, and an optional callback that fires when a matching pong message
+is received. It returns `true` iff a ping message was sent. If the client does
+not support ping/pong, this method sends no data and returns `false`.
+
+```js
+ws.ping('Mic check, one, two', function() {
+  // fires when pong is received
+});
+```
+
 
 ## Using the WebSocket client
 
@@ -193,6 +218,10 @@ retryable every 10 seconds if the connection is broken:
 var es = new EventSource(request, response, {ping: 15, retry: 10});
 ```
 
+You can send a ping message at any time by calling `es.ping()`. Unlike WebSocket,
+the client does not send a response to this; it is merely to send some data over
+the wire to keep the connection alive.
+
 
 ## License
 

examples/server.js

@@ -7,7 +7,7 @@ var port   = process.argv[2] || 7000,
     secure = process.argv[3] === 'ssl';
 
 var upgradeHandler = function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp']);
+  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], {ping: 5});
   console.log('open', ws.url, ws.version, ws.protocol);
   
   ws.onmessage = function(event) {

lib/faye/eventsource.js

@@ -19,24 +19,18 @@ var EventSource = function(request, response, options) {
   this._ping     = options.ping  || this.DEFAULT_PING;
   this._retry    = options.retry || this.DEFAULT_RETRY;
   
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+  
   var scheme = isSecureConnection(request) ? 'https:' : 'http:';
   this.url = scheme + '//' + request.headers.host + request.url;
   
   this.lastEventId = request.headers['last-event-id'] || '';
-  this.readyState  = API.OPEN;
-  
-  var event = new Event('open');
-  event.initEvent('open', false, false);
-  this.dispatchEvent(event);
   
   var self = this;
-  this._pingLoop = setInterval(function() {
-    try { this._stream.write(':\r\n\r\n') } catch (e) {}
-  }, this._ping * 1000);
-  
-  ['close', 'end', 'error'].forEach(function(event) {
-    self._stream.addListener(event, function() { self.close() });
-  });
+  this.readyState = API.CONNECTING;
+  this._sendBuffer = [];
+  process.nextTick(function() { self._open() });
   
   var handshake = 'HTTP/1.1 200 OK\r\n' +
                   'Content-Type: text/event-stream\r\n' +
@@ -47,6 +41,15 @@ var EventSource = function(request, response, options) {
   try {
     this._stream.write(handshake, 'utf8');
   } catch (e) {}
+  
+  this.readyState = API.OPEN;
+  
+  if (this._ping)
+    this._pingLoop = setInterval(function() { self.ping() }, this._ping * 1000);
+  
+  ['close', 'end', 'error'].forEach(function(event) {
+    self._stream.addListener(event, function() { self.close() });
+  });
 };
 
 EventSource.isEventSource = function(request) {
@@ -72,6 +75,15 @@ var instance = {
     } catch (e) {}
   },
   
+  ping: function() {
+    try {
+      this._stream.write(':\r\n\r\n', 'utf8');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  },
+  
   close: function() {
     if (this.readyState === API.CLOSING || this.readyState === API.CLOSED)
       return;

lib/faye/websocket.js

@@ -31,9 +31,14 @@ var isSecureConnection = function(request) {
   }
 };
 
-var WebSocket = function(request, socket, head, supportedProtos) {
+var WebSocket = function(request, socket, head, supportedProtos, options) {
   this.request = request;
   this._stream = request.socket;
+  this._ping   = options && options.ping;
+  this._pingId = 0;
+  
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
   
   var scheme = isSecureConnection(request) ? 'wss:' : 'ws:';
   this.url = scheme + '//' + request.headers.host + request.url;
@@ -43,29 +48,40 @@ var WebSocket = function(request, socket, head, supportedProtos) {
   var Parser = getParser(request);
   this._parser = new Parser(this, {protocols: supportedProtos});
   
+  var self = this;
+  this._sendBuffer = [];
+  process.nextTick(function() { self._open() });
+  
   var handshake = this._parser.handshakeResponse(head);
   try { this._stream.write(handshake, 'binary') } catch (e) {}
   
+  if (this._parser.isOpen()) this.readyState = API.OPEN;
+  
+  if (this._ping)
+    this._pingLoop = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+  
   this.protocol = this._parser.protocol || '';
-  this.readyState = API.OPEN;
   this.version = this._parser.getVersion();
   
-  var event = new Event('open');
-  event.initEvent('open', false, false);
-  this.dispatchEvent(event);
-  
-  var self = this;
-  
   this._stream.addListener('data', function(data) {
     var response = self._parser.parse(data);
     if (!response) return;
     try { self._stream.write(response, 'binary') } catch (e) {}
+    self._open();
   });
   ['close', 'end', 'error'].forEach(function(event) {
     self._stream.addListener(event, function() { self.close(1006, '', false) });
   });
 };
 
+WebSocket.prototype.ping = function(message, callback, context) {
+  if (!this._parser.ping) return false;
+  return this._parser.ping(message, callback, context);
+};
+
 for (var key in API) WebSocket.prototype[key] = API[key];
 
 WebSocket.WebSocket   = WebSocket;

lib/faye/websocket/api.js

@@ -7,6 +7,21 @@ var API = {
   CLOSING:      2,
   CLOSED:       3,
   
+  _open: function() {
+    if (this._parser && !this._parser.isOpen()) return;
+    this.readyState = API.OPEN;
+    
+    var buffer = this._sendBuffer || [],
+        message;
+    
+    while (message = buffer.shift())
+      this.send.apply(this, message);
+    
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+  
   receive: function(data) {
     if (this.readyState !== API.OPEN) return false;
     var event = new Event('message');
@@ -16,7 +31,18 @@ var API = {
   },
   
   send: function(data, type, errorType) {
-    if (this.readyState === API.CLOSED) return false;
+    if (this.readyState === API.CONNECTING) {
+      if (this._sendBuffer) {
+        this._sendBuffer.push(arguments);
+        return true;
+      } else {
+        throw new Error('Cannot call send(), socket is not open yet');
+      }
+    }
+    
+    if (this.readyState === API.CLOSED)
+      return false;
+    
     var frame = this._parser.frame(data, type, errorType);
     try {
       this._stream.write(frame, 'binary');
@@ -34,6 +60,7 @@ var API = {
     
     var close = function() {
       this.readyState = API.CLOSED;
+      if (this._pingLoop) clearInterval(this._pingLoop);
       this._stream.end();
       var event = new Event('close', {code: code || 1000, reason: reason || ''});
       event.initEvent('close', false, false);

lib/faye/websocket/client.js

@@ -18,21 +18,23 @@ var Client = function(url, protocols) {
       onConnect  = function() { self._onConnect() },
       
       connection = secure
-                 ? tls.connect(this._uri.port || 443, this._uri.hostname, onConnect)
+                 ? tls.connect(this._uri.port || 443, this._uri.hostname, {}, onConnect)
                  : net.createConnection(this._uri.port || 80, this._uri.hostname);
   
   this._parser = new HybiParser(this, {masking: true, protocols: protocols});
   this._stream = connection;
   
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+  
   if (!secure) connection.addListener('connect', onConnect);
   
   connection.addListener('data', function(data) {
     self._onData(data);
   });
-  connection.addListener('close', function() {
-    self.close(1006, '', false);
+  ['close', 'end', 'error'].forEach(function(event) {
+    connection.addListener(event, function() { self.close(1006, '', false) });
   });
-  connection.addListener('error', function() {});
 };
   
 Client.prototype._onConnect = function() {

lib/faye/websocket/draft75_parser.js

@@ -17,6 +17,10 @@ var instance = {
                       'utf8');
   },
   
+  isOpen: function() {
+    return true;
+  },
+  
   parse: function(buffer) {
     var data, message, value;
     for (var i = 0, n = buffer.length; i < n; i++) {

lib/faye/websocket/draft76_parser.js

@@ -47,9 +47,12 @@ Draft76Parser.prototype.handshakeResponse = function(head) {
   return response;
 };
 
+Draft76Parser.prototype.isOpen = function() {
+  return !!this._handshakeComplete;
+};
+
 Draft76Parser.prototype.handshakeSignature = function(head) {
   if (head.length === 0) return null;
-  this._handshakeComplete = true;
   
   var request = this._socket.request,
       
@@ -65,6 +68,7 @@ Draft76Parser.prototype.handshakeSignature = function(head) {
   MD5.update(bigEndian(value2));
   MD5.update(head.toString('binary'));
   
+  this._handshakeComplete = true;
   return new Buffer(MD5.digest('binary'), 'binary');
 };
 

lib/faye/websocket/hybi_parser.js

@@ -10,6 +10,8 @@ var HybiParser = function(webSocket, options) {
   this._masking   = options && options.masking;
   this._protocols = options && options.protocols;
   
+  this._pingCallbacks = {};
+  
   if (typeof this._protocols === 'string')
     this._protocols = this._protocols.split(/\s*,\s*/);
 };
@@ -97,6 +99,10 @@ var instance = {
     return new Buffer(headers.concat('','').join('\r\n'), 'utf8');
   },
   
+  isOpen: function() {
+    return true;
+  },
+  
   createHandshake: function(uri) {
     return new Handshake(uri, this._protocols);
   },
@@ -239,6 +245,12 @@ var instance = {
     return frame;
   },
   
+  ping: function(message, callback, context) {
+    message = message || '';
+    if (callback) this._pingCallbacks[message] = [callback, context];
+    return this._socket.send(message, 'ping');
+  },
+  
   close: function(code, reason, callback, context) {
     if (this._closed) return;
     if (callback) this._closingCallback = [callback, context];
@@ -304,6 +316,14 @@ var instance = {
       if (payload.length > 125) return this._socket.close(this.ERRORS.protocol_error, null, false);
       this._socket.send(payload, 'pong');
     }
+    else if (opcode === this.OPCODES.pong) {
+      var callbacks = this._pingCallbacks,
+          message   = this._encode(payload),
+          callback  = callbacks[message];
+      
+      delete callbacks[message];
+      if (callback) callback[0].call(callback[1]);
+    }
   },
   
   _reset: function() {

package.json

@@ -2,13 +2,15 @@
 , "description"     : "Standards-compliant WebSocket server and client"
 , "homepage"        : "http://github.com/faye/faye-websocket-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
-, "keywords"        : ["websocket"]
+, "keywords"        : ["websocket", "eventsource"]
 
-, "version"         : "0.2.0"
+, "version"         : "0.4.0"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
 , "devDependencies" : {"jsclass": ""}
 
+, "scripts"         : {"test": "node spec/runner.js"}
+
 , "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
 
 , "licenses"        : [ { "type"    : "MIT"