• View
• Edit
• History
• Print

WebSocketImplementationNotes

(redirected from VersionCurrent.WebSocketImplementationNotes)

Summary

This module is implemented in the Cape Code Host that uses Nashorn. It should be relatively easy to implement for the Node Host using Node.js because it is fashioned after the ws module in Node.js, with additional influence from the web socket submodule of the socket.io.

Node Host

Node Test Case

Our test case is invoked using Cape Code Host Cape Code:

   $PTII/bin/vergil -capecode $PTII/org/terraswarm/accessor/test/auto/WebSocketClientJS.xml

Running the code generator creates accessors/web/net/test/auto/WebSocketClient.js, which can be invoked with:

  cd $PTII/org/terraswarm/accessor/accessors/web/net/test/auto;
  node ../../../hosts/node/nodeHostInvoke.js -timeout 2000 net/test/auto/WebSocketClientJS

The WebSocketClient accessor is never fired

When the Cape Code model above is run, we get the following output:

When the node version is run, we get:

Comparing the two outputs:

• initialize() is fine:
  • Cape Code: WebSocketClient: WebSocketClient.js: initialize() (Thread[WebSocketClientJS,1,main])
  • Node: WebSocketClient.js: initialize()
• connect() is fine:
  • Cape Code: WebSocketClient: WebSocketClient.js: connect() (Thread[WebSocketClientJS,1,main])
  • Node: WebSocketClient.js: connect()
    • Hint: See Analysis below
• The client fails to connect!
  • Cape Code: WebSocketClient: Connection failed. Will try again: Connection refused: localhost/127.0.0.1:8087 (Thread[vert.x-eventloop-thread-1,6,main])
    • The above comes from HttpClientExceptionHandler in ptolemy/actor/lib/jjs/modules/webSocket/WebSocketHelper.java
    • The stack trace is:
      java.net.ConnectException: Connection refused: localhost/127.0.0.1:8087
              at sun.nio.ch.SocketChannelImpl.checkConnect(Native Method)
              at sun.nio.ch.SocketChannelImpl.finishConnect(SocketChannelImpl.java:717)
              at io.netty.channel.socket.nio.NioSocketChannel.doFinishConnect(NioSocketChannel.java:224)
              at io.netty.channel.nio.AbstractNioChannel$AbstractNioUnsafe.finishConnect(AbstractNioChannel.java\
      :289)
              at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:528)
              at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:468)
              at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:382)
              at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:354)
              at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:112)
              at java.lang.Thread.run(Thread.java:745)

      [$[Get Code]]
    • WebSocketHelper._connectWebsocket() is a private method that instantiates a HttpClientExceptionHandler.
      • WebSocketHelper.open() invokes _connectWebsocket as does HttpClientExceptionHandler.
  • Edward wrote:
  "Next problem is that the WebSocketServer is not issuing a connection event. This may be because WebSocketClient gets initialized before the servers is listening. I think the Nashorn implementation repeatedly retries to make the connection, but it looks like maybe the Node implementation in the ws module just silently fails (?)."
• Continuing:
  • Cape Code: WebSocketServer: Server: Listening for socket connection requests. (Thread[vert.x-eventloop-thread-8,6,main])
    • The above comes from accessor/accessors/web/net/WebSocketServer.js:
      exports.onListening = function() {
          console.log('Server: Listening for socket connection requests.');
          this.send('listening', this.getParameter('port'));
      };

      [$[Get Code]]
  • Node: webSocketServer.Server()
    • The above comes from accessors/web/hosts/hosts/node/node_modules/@accessors-modules//web-socket-server/web-socket-server.js:
      exports.Server = function (options) {
          console.log("webSocketServer.Server()");
          if (typeof options.port === 'undefined' || options.port === null) {
              this.port = 80;
          } else {
              this.port = options.port;
          }
          this.hostInterface = options.hostInterface || 'localhost';
          this.sslTls = options.sslTls || false;
          this.pfxKeyCertPassword = options.pfxKeyCertPassword || '';
          this.pfxKeyCertPath = options.pfxKeyCertPath || '';
          this.receiveType = options.receiveType || 'application/json';
          this.sendType = options.sendType || 'application/json';
          // this.helper = WebSocketServerHelper.createServer(                                                  
          //    this, this.hostInterface, this.sslTls, this.pfxKeyCertPassword, this.pfxKeyCertPath,            
          //    this.port, this.receiveType, this.sendType                                                      
          //);                                                                                                  
      };
      util.inherits(exports.Server, EventEmitter);

      [$[Get Code]]
  • Node: webSocketServer.start(): localhost 8087
    • The above comes from accessors/web/hosts/hosts/node/node_modules/@accessors-modules//web-socket-server/web-socket-server.js:
      exports.Server.prototype.start = function () {
          console.log("webSocketServer.start(): " + this.hostInterface + " " + this.port);
      
          // The ws module starts the server when you create an instance of ws.Server,                          
          // so this needs to be done here rather than in the constructor or we will                            
          // start the server prematurely.                                                                      
          this.helper = new ws.Server({ 'host': this.hostInterface,
                                        'port': this.port
                                      });
          // Register handlers. Note that in Node, this start function will be                                  
          // completed before any of these handlers is invoked, so there is no race                              
          // condition caused by the fact that we already issued the command above                              
          // to start the server.                                                                                
          this.helper.on('listening', function() {
              console.log("webSocketServer.start(): listening event");
          });

      [$[Get Code]]
  • Node: webSocketServer.start(): listening event
    • See above.

Analysis

From the above:

• connect() is fine:
  • Cape Code: WebSocketClient: WebSocketClient.js: connect() (Thread[WebSocketClientJS,1,main])
  • Node: WebSocketClient.js: connect()
    • Further analysis indicates that connect() in accessor/accessors/web/net/WebSocketClient.js is returning because this.get('port') is returning -1:
      exports.connect = function () {
          console.log("WebSocketClient.js: connect()");
          // Note that if 'server' and 'port' both receive new data in the same                                  
          // reaction, then this will be invoked twice. But we only want to open                                
          // the socket once.  This is fairly tricky.                                                            
      
          var portValue = this.get('port');
          if (portValue < 0) {
              // No port is specified. This could be a signal to close a previously                              
              // open socket.                                                                                    
              if (client) {
                  client.close();
              }
              previousPort = null;
              previousServer = null;
              console.log("WebSocketClient.js: connect(): portValue: " + portValue +
                          ", which is less than 0. This could be a signla to close a previously open socket." +
                          "  Returning.");
              return;
          }

      [$[Get Code]]

Solutions

• Edit connect() in accessor/accessors/web/net/WebSocketClient.js to print an message about exiting
• Update the code generator so that instead of generating
      WebSocketClient.setParameter('port', 8087);

  [$[Get Code]]
  Generate
      WebSocketClient.setDefault('port', 8087);

  [$[Get Code]]
• Update docs about setParameter() and get()

Continuing with Node

One possible solution is to wait a bit and then try to connect again.

However, that is not working.

accessors/web/hosts/hosts/node/node_modules/@accessors-modules//web-socket-client/web-socket-client.js was edited so that there is a new method called connectWebsocket:

When I run under node 6.2.0:

Using the debugger indicates that the issue is the stack size:

Adding the following method:

results in this from within ggdb after break exit:

Questions:

1. Why doesn't the setTimeout() call work inside this.helper.on('error', function(message) {. I should at least be seeing the console.log
2. How do I stop the errors after I've called setTimeout()?

Retry

Maybe instead, we should use a Node retry module

• How to do repeated requests until one succeeds without blocking in node? (Stackoverflow)
  • Suggests: https://github.com/caolan/async#retry
  • https://github.com/tim-kos/node-retry
• Searching for "node retry on error" is helpful

See Also

• WebSocket Implementation Notes (Version0)

Back to Optional JavaScript Modules