RPC WebSocket is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events. 

RPC WebSocket is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events. It is an alternative to ajax, socket.io, and JSON-RPC.

eriksank

rpc-websocket

RPC WebSocket is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events.

Open two terminals. In order to run example 1, in one terminal, start the server:

In the other terminal, you can execute the client:

As you can see, you can just resort to a naming convention to create something like a _test_ channel or namespace.

You can let the client make RPC calls to the server, but you can also let the server make RPC calls to the client. Server-to-client RPC calls are not possible with ajax. The fact that this is not possible, endlessly complicates the construction of particular types of applications such as real-time chat boxes.

For: _Handling before/after send/receive events_

You can use the `beforeSend` event to make changes to the message that is about to be sent. You can use the `afterSend` event to do some logging, for example, after successfully sending a message. You can also use the `beforeReceive` and `afterReceive` events. Here an example:

!INCLUDE "doc/examples/3-before-after-send-client.js"

You could easily run into very subtle bugs when you start looping over RPC calls. For example:

While the program is executing the reply logic, the value of the loop's counter `i` is not what you may think it is. Since the `reply` logic gets executed asynchronously, your socket could be waiting for a while before getting a response. In the meanwhile your loop counter will have moved on.

If you loop over an RPC call, you can generally not count of the fact that the variables that went into the request, are still the same as when you started the RPC call. Therefore, you must make sure to permanently fix their values in an enclosure:

                        /* do something with y */

When the enclosure function exits, the logic inside of the function will hang on to copies of `x1`, and `x2` inside its function closure, with values as they were at the moment that the program finished executed the function. The technique to create such enclosure function is called [IIFE](http://en.wikipedia.org/wiki/Immediately-invoked_function_expression) (Immediately-invoked function expression).

        "description" : "RPC WebSocket is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events.",

        "author" : "Erik Poupaert <erik@sankuru.biz>",

          "url": "git@github.com:eriksank/rpc-websocket.git"

          "url": "https://github.com/eriksank/rpc-websocket/issues"

                "underscore" : "jashkenas/underscore",

                "EventEmitter2" : "asyncly/EventEmitter2"

                "engine.io" : "Automattic/engine.io",

                "engine.io-client": "Automattic/engine.io-client"

2.1\.  [The short story](#theshortstory)  

4\.  [Browser support](#browsersupport)  

5.1\.  [Running the examples](#runningtheexamples)  

6\.  [Events supported](#eventssupported)  

7.1.2\.  [send(MessageType, UserData)](#sendmessagetypeuserdata)  

7.1.3\.  [rpc(MessageType, UserData, ReplyHandler)](#rpcmessagetypeuserdatareplyhandler)  

7.2.1\.  [RpcServer(server)](#rpcserverserver)  

8\.  [Development tools](#developmenttools)  

11.1\.  [What is wrong with ajax](#whatiswrongwithajax)  

11.2\.  [What is wrong with JSON-RPC](#whatiswrongwithjson-rpc)  

11.3\.  [What is wrong with socket.io](#whatiswrongwithsocket.io)  

13\.  [Other publications](#otherpublications)  

_RPC WebSocket_ is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events.

Distributed computing allows for distributed lambdas (=functions). If invoking a local function, looks like this:

In that case, the same function invocation, as function doing the computation on a remote server, that is, a Remote Procedure Call (RPC) looks like that:

_Rpc WebSocket_ allows you to make remote function calls over a websocket.

* *message types*: Each message is always assigned a type. This allows us to transparently route messages to different handler functions.

* *RPC*: This feature implements the ability to call functions on the server using websockets. It is an alternative to ajax and to JSON-RPC.

* *before/after send/receive events*: For the purposes of logging, encryption, and compression, we need the ability to intercept incoming and outgoing messages before they are delivered to their handler functions. Depending on the application, there may be other reasons to apply wholesale changes to each incoming or outgoing message. We could, for example, add validation logic before sending messages.

I have tested _Rpc WebSocket_ with the [engine.io](https://github.com/Automattic/engine.io) and [engine.io-client](https://github.com/Automattic/engine.io-client) transport mechanisms, but you should most likely be able to use alternative websocket implementations.

You can install _RPC-WebSocket_ with *npm*:

If you want to use *engine.io* on the server side as the transport layer, you can install it with *npm*:

var ChildProcess=require('child_process');

        it('should be able to send/receive rpc calls', function(){

                var child=ChildProcess.exec('./test/2-rpc-server.js');

                var ioSocket = require('engine.io-client')('ws://localhost:8082');

                var RpcSocket=require('rpc-websocket');

                var ws=new RpcSocket(ioSocket);

                var MAX_MESSAGES=3*MESSAGES_PER_TYPE;

                function attemptToTerminate() {

                        if(arrivedCount===MAX_MESSAGES) 

                                child.kill('SIGKILL');

                //client sending/receiving

                ws.on('open', function() {

                        for(var i=0; i<MESSAGES_PER_TYPE; i++) {

                                (function(i) {

                                        ws.rpc('test-type1',i,function(message){

                                                assert.equal(message,'TEST-BACK-1-'+i);

                                                attemptToTerminate();                                        

                                        });

                                        ws.rpc('test-type2',i,function(message){

                                                assert.equal(message,'TEST-BACK-2-'+i);

                                        ws.rpc('test-type3',i,function(message){

                                                assert.equal(message,'TEST-BACK-3-'+i);

By bubbling the events from the standard websocket transport layer:

* `error`: injects a standard javascript error object with `message`, `type`, and `description` fields 

		@@ -66,3 +66,3 @@ ##Examples

		For: `Looping over RPC calls`
		For: _Looping over RPC calls_

		@@ -69,0 +69,0 @@ You could easily run into very subtle bugs when you start looping over RPC calls. For example:

		{
		"name" : "rpc-websocket",
		"version": "0.6.8",
		"version": "0.6.9",
		"description" : "RPC WebSocket is a wrapper for standard websockets that adds support for message types, RPC, and for before/after send/receive events.",
		@@ -5,0 +5,0 @@ "author" : "Erik Poupaert <erik@sankuru.biz>",

		@@ -299,3 +299,3 @@ #RPC WebSocket

		For: `Looping over RPC calls`
		For: _Looping over RPC calls_

		@@ -302,0 +302,0 @@ You could easily run into very subtle bugs when you start looping over RPC calls. For example: