Optional enable log(trace)

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -0,0 +1,45 @@
+# node-jsonrpc2
+
+This is a JSON-RPC server and client library for node.js <http://nodejs.org/>,
+the V8 based evented IO framework.
+
+## Install
+
+To install node-jsonrpc2 in the current directory, run:
+
+    npm install jsonrpc2
+
+## Usage
+
+Firing up an efficient JSON-RPC server becomes extremely simple:
+
+``` javascript
+var rpc = require('jsonrpc2');
+
+var server = new rpc.Server();
+
+function add(args, opt, callback) {
+  callback(null, args[0] + args[1]);
+}
+server.expose('add', add);
+
+server.listen(8000, 'localhost');
+```
+
+And creating a client to speak to that server is easy too:
+
+``` javascript
+var rpc = require('jsonrpc2');
+var util = require('util');
+
+var client = new rpc.Client(8000, 'localhost');
+
+client.call('add', [1, 2], function(err, result) {
+    util.puts('1 + 2 = ' + result);
+});
+```
+
+To learn more, see the examples directory, peruse test/jsonrpc-test.js, or
+simply "Use The Source, Luke".
+
+More documentation and development is on its way.

examples/client.js

@@ -1,32 +1,93 @@
-var sys = require('sys');
+var util = require('util');
 var rpc = require('../src/jsonrpc');
 
-var client = rpc.getClient(8000, 'localhost');
+rpc.Endpoint.trace = function () {};
 
-client.call('add', [1, 2], function(result) {
-    sys.puts('  1 + 2 = ' + result);
+var client = new rpc.Client(8088, 'localhost', "myuser", "secret123");
+
+client.call('add', [1, 2], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log('  1 + 2 = ' + result);
 });
 
-client.call('multiply', [199, 2], function(result) {
-    sys.puts('199 * 2 = ' + result);
+client.call('multiply', [199, 2], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log('199 * 2 = ' + result);
 });
 
 // Accessing modules is as simple as dot-prefixing.
-client.call('math.power', [3, 3], function(result) {
-    sys.puts('  3 ^ 3 = ' + result);
+client.call('math.power', [3, 3], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log('  3 ^ 3 = ' + result);
+});
+
+// We can handle errors the same way as anywhere else in Node
+client.call('add', [1, 1], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log('  1 + 1 = ' + result + ', dummy!');
+});
+
+// These calls should each take 1.5 seconds to complete
+client.call('delayed.add', [1, 1, 1500], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log(result);
 });
 
-// Call simply returns a promise, so we can add callbacks or errbacks at will.
-var promise = client.call('add', [1, 1]);
-promise.addCallback(function(result) {
-    sys.puts('  1 + 1 = ' + result + ', dummy!');
+client.call('delayed.echo', ['Echo.', 1500], function (err, result) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  console.log(result);
 });
 
-/* These calls should each take 1.5 seconds to complete. */
-client.call('delayed.add', [1, 1, 1500], function(result) {
-    sys.puts(result);
+client.stream('listen', [], function (err, connection) {
+  if (err) {
+    console.error('RPC Error: '+ err.toString());
+    return;
+  }
+  var counter = 0;
+  connection.expose('event', function (params) {
+    console.log('Streaming #'+counter+': '+params[0]);
+    counter++;
+    if (counter > 4) {
+      connection.end();
+    }
+  });
+  console.log('start listening');
 });
 
-client.call('delayed.echo', ['Echo.', 1500], function(result) {
-    sys.puts(result);
-});
+var socketClient = new rpc.Client(8089, 'localhost', "myuser", "secret123");
+
+socketClient.connectSocket(function (err, conn) {
+  var counter = 0;
+  socketClient.expose('event', function (params) {
+    console.log('Streaming (socket) #'+counter+': '+params[0]);
+    counter++;
+    if (counter > 4) {
+      conn.end();
+    }
+  });
+
+  conn.call('listen', [], function (err) {
+    if (err) {
+      console.error('RPC Error: '+ err.toString());
+      return;
+    }
+  });
+});

examples/server.js

@@ -1,46 +1,80 @@
 var rpc = require('../src/jsonrpc');
+var events = require('events');
+
+var server = new rpc.Server();
+
+server.enableAuth("myuser", "secret123");
 
 /* Create two simple functions */
-function add(first, second) {
-    return first + second;
+function add(args, opts, callback) {
+  callback(null, args[0]+args[1]);
 }
 
-function multiply(first, second) {
-    return first * second;
+function multiply(args, opts, callback) {
+  callback(null, args[0]*args[1]);
 }
 
 /* Expose those methods */
-rpc.expose('add', add);
-rpc.expose('multiply', multiply);
+server.expose('add', add);
+server.expose('multiply', multiply);
 
 /* We can expose entire modules easily */
 var math = {
-    power: function(first, second) { return Math.pow(first, second); },
-    sqrt: function(num) { return Math.sqrt(num); }
-}
-rpc.exposeModule('math', math);
+  power: function(args, opts, callback) {
+    callback(null, Math.pow(args[0], args[1]));
+  },
+  sqrt: function(args, opts, callback) {
+    callback(null, Math.sqrt(args[0]));
+  }
+};
+server.exposeModule('math', math);
 
-/* Listen on port 8000 */
-rpc.listen(8000, 'localhost');
-
-/* By returning a promise, we can delay our response indefinitely, leaving the
-   request hanging until the promise emits success. */
+/* By using a callback, we can delay our response indefinitely, leaving the
+ request hanging until the callback emits success. */
 var delayed = {
-    echo: function(data, delay) {
-        var promise = new process.Promise();
-        setTimeout(function() {
-            promise.emitSuccess(data);
-        }, delay);
-        return promise;
-    },
-
-    add: function(first, second, delay) {
-        var promise = new process.Promise();
-        setTimeout(function() {
-            promise.emitSuccess(first + second);
-        }, delay);
-        return promise;
-    }
+  echo: function(args, opts, callback) {
+    var data = args[0];
+    var delay = args[1];
+    setTimeout(function() {
+      callback(null, data);
+    }, delay);
+  },
+
+  add: function(args, opts, callback) {
+    var first = args[0];
+    var second = args[1];
+    var delay = args[2];
+    setTimeout(function() {
+      callback(null, first + second);
+    }, delay);
+  }
 }
 
-rpc.exposeModule('delayed', delayed);
+server.exposeModule('delayed', delayed);
+
+// Create a message bus with random events on it
+var firehose = new events.EventEmitter();
+(function emitFirehoseEvent() {
+  firehose.emit('foobar', {data: 'random '+Math.random()});
+  setTimeout(arguments.callee, 200+Math.random()*3000);
+})();
+
+var listen = function (args, opts, callback) {
+  function handleFirehoseEvent(event) {
+    opts.call('event', event.data);
+  };
+  firehose.on('foobar', handleFirehoseEvent);
+  opts.stream(function () {
+    console.log('connection ended');
+    firehose.removeListener('foobar', handleFirehoseEvent);
+  });
+  callback(null);
+};
+
+server.expose('listen', listen);
+
+/* HTTP server on port 8088 */
+server.listen(8088, 'localhost');
+
+/* Raw socket server on port 8089 */
+server.listenRaw(8089, 'localhost');

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "jsonrpc2",
+  "version": "0.1.1",
+  "description": "JSON-RPC server and client library",
+  "main": "./src/jsonrpc",
+  "keywords": [
+    "json",
+    "rpc",
+    "server",
+    "client"
+  ],
+
+  "author": "Eric Florenzano <[email protected]> (eflorenzano.com)",
+
+  "dependencies": {
+    "jsonparse": ">=0.0.1"
+  },
+
+  "contributors": [
+    "Bill Casarin <[email protected]> (jb55.com)",
+    "Stefan Thomas <[email protected]> (justmoon.net)"
+  ],
+
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bitcoinjs/node-jsonrpc2.git"
+  }
+}