jsonrpc-server 0.2.0 → 0.3.0

data/README

@@ -1,14 +1,23 @@
-== About
+About
+=====
 
-This is an implementation of {JSON RPC 2.0}[link:http://groups.google.com/group/json-rpc/web/json-rpc-2-0?pli=1] server
+This is an implementation of JSON RPC 2.0 server (http://groups.google.com/group/json-rpc/web/json-rpc-2-0?pli=1)
 
-== Using
+Using
+=====
 
-To make your rails controller JSON RPC 2.0 callable, make next include:
+To make your rails controller JSON RPC 2.0 callable, do next
 
     class TestController < ActionController::Base
-      include JSONServer
+      include JSONServer # adds json-rpc 2.0 functionality
 
+      def index
+          # next will redirect post contents to json-rpc dispatcher
+          # and output resut as string
+        render :text => dispatch_json_2(request.body.read)
+      end
+
+        # function which will become remotely callable
       def summ(left, right)
         return left+right
       end
@@ -19,17 +28,15 @@ In your config/routing.rb you will have to add
     post 'json'     => 'test#index'
 
 JSONServer will automaticaly check if  posted json is valid JSON-RPC 2.0 request
-and and fire called method. if method is not found - propper error will be sent.
+and fire called method. if method is not found - propper error will be sent.
 
 Batch request are handled.
+Notices are handled.
+Test taken from examples on http://groups.google.com/group/json-rpc/web/json-rpc-2-0?pli=1
 
 == Errors
 
-You can raise standart errors, or JSONServer::Error with parameters :code,
+You can raise standart errors, or JSONRPCError with parameters :code,
 :message, :data, which will be set for correspoding fields
 :code defaults to -30000 if JSONServer::Error and to -32000 otherwise
 :message defaults to "Runtime Error"
-
-== TODO list
-
-write tests

data/lib/jsonrpc-server.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'jsonrpc-server/defs'
+require 'jsonrpc-server/parser'
+
+# JSONRPCServer - container, and router for json-rpc 2.0 requests
+#
+# Procedure handler classe, module or object is stored inside the class
+#
+# Handler can specify own procedure prefix to create namespace of allowed
+# to call functions. say, one does not want someone to call to_s inside class
+# which encrypts user data with secret key.
+
+class JSONRPCServer
+
+  attr_accessor :handler, :prefix
+
+  def initialize in_handler, in_prefix = ""
+    self.handler = in_handler
+    self.prefix = in_prefix
+  end
+
+  def dispatch request
+    # here request specific errors are handled
+    begin
+      # no wraping, because single_request dispatcher does it
+      result = core_dispatch request
+    rescue JSON::ParserError
+      # called only on parsing error. all other errors
+      # have to be handled on per-request basis
+      result = wrap_error @@ParseError
+    end
+    return '' if result==nil || result.empty?
+    return result.to_json
+  end
+
+end

data/lib/jsonrpc-server/defs.rb

@@ -0,0 +1,48 @@
+# Different class difenitions
+# Standart errors
+# Constants
+
+class JSONRPCServer
+
+  @@Version = "2.0".freeze
+
+  class Error < StandardError
+
+    attr_reader :data
+
+    def initialize *args
+      @data = {:code => -30000, :message => "Runtime Error"}
+
+      return unless args.length > 0
+
+      # if initialized by object
+      if (args.length == 1) and (args[0].is_a? Hash) then
+        @data.update(args[0])
+        return self
+      end
+
+      # per argument: code, message, data
+      @data[:code] = args[0] if args[0].is_a? Fixnum
+      @data[:message] = args[1] if args[1].is_a? String
+      @data[:data] = args[2] if args[2].is_a? Hash
+    end
+
+    def Error.to_e err
+      return err if err.is_a? Error
+      Error.new -32000, $!.message, $!.to_s
+    end
+
+  end
+
+  class Result
+    attr_reader :data
+    def initialize obj = nil
+      @data = obj
+    end
+  end
+
+  # Errors
+  @@MethodNotFound = Error.new(-32601, "Method not found.").freeze
+  @@ParseError = Error.new(-32700, "Parse error.").freeze
+  @@InvalidRequest = Error.new(-32600, "Invalid Request.").freeze
+end

data/lib/jsonrpc-server/parser.rb

@@ -0,0 +1,69 @@
+require 'jsonrpc-server/defs'
+
+class JSONRPCServer
+
+private
+
+  def core_dispatch request
+    data = JSON.parse request
+    return parse_batch data if data.kind_of? Array
+    return parse_single data
+  end
+
+  def wrap data, id = nil
+    data.update({ :jsonrpc => @@Version, :id => id })
+  end
+
+  def wrap_error error, id = nil
+    wrap({ :error => error.data }, id)
+  end
+
+  def wrap_result result, id = nil
+    wrap({ :result => result }, id)
+  end
+
+  def parse_batch data
+    # batch can not be empty
+    return wrap_error @@InvalidRequest if data.length == 0
+    res = data.collect{ |single|
+      parse_single single
+    }
+    res.delete(nil)
+    res
+  end
+
+  def parse_single data
+    current_id = nil
+    result = catch :result do
+      begin
+        raise @@InvalidRequest unless data.kind_of?(Hash)
+        current_id = data["id"] unless data["id"] == nil
+        check_request data
+        method_name = self.prefix + data["method"]
+        raise @@MethodNotFound unless handler.respond_to? method_name
+        if data["params"].kind_of? Array
+          arr = data["params"]
+        elsif
+          arr = handler.method(method_name).parameters.collect { |pd|
+            data["params"][pd[1].to_s]
+          }
+        end
+        result = handler.send(method_name, *arr)
+        throw(:result,
+              wrap_result(result, current_id)) unless current_id == nil
+        throw(:result, nil)
+      rescue
+        throw :result, wrap_error(Error.to_e($!), current_id)
+      end
+    end
+    result
+  end
+
+  def check_request data
+    return if data["jsonrpc"] == @@Version &&
+      data["method"].kind_of?(String) &&
+      data["method"] != ""
+    raise @@InvalidRequest
+  end
+
+end

data/test/all.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'jsonrpc-server'
+
+require './test/no_namespace'
+require './test/rpc_class'
+
+class All < Test::Unit::TestCase
+
+  @@server = JSONRPCServer.new NoNamespace.new
+  @@prefixed_server = JSONRPCServer.new RPCClass.new, "rpc_"
+
+  def test_from_file
+    file = YAML.load(File.open("test/cases.yml"))
+    file["tests"].each { |test|
+      result = @@server.dispatch test["request"]
+      expected_res = test["response"]
+      assert_equal(JSON.parse(expected_res),
+                   JSON.parse(result), test["id"].to_s+" :: "+test["name"])
+    }
+  end
+
+  def test_notification
+    result = @@server.dispatch '{"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}'
+    assert_equal('', result, "update_method")
+    assert_equal([1,2,3,4,5], @@server.handler.arr, "update_method")
+
+    @@server.handler.foobar_called = false
+    result = @@server.dispatch '{"jsonrpc": "2.0", "method": "foobar"}'
+    assert_equal('', result, "foobar_method")
+    assert_equal(true, @@server.handler.foobar_called, "foobar_method")
+  end
+
+  def test_call_batch
+    result = @@server.dispatch '[
+        {"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
+        {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
+        {"jsonrpc": "2.0", "method": "subtract", "params": [42,23], "id": "2"},
+        {"foo": "boo"},
+        {"jsonrpc": "2.0", "method": "foo.get", "params": {"name": "myself"}, "id": "5"},
+        {"jsonrpc": "2.0", "method": "get_data", "id": "9"}
+    ]'
+    expected_res = '[
+        {"jsonrpc": "2.0", "result": 7, "id": "1"},
+        {"jsonrpc": "2.0", "result": 19, "id": "2"},
+        {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null},
+        {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found."}, "id": "5"},
+        {"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
+    ]'
+    assert_equal(JSON.parse(expected_res),
+                 JSON.parse(result))
+    assert_equal(@@server.handler.notify_hello_data, 7)
+  end
+
+  def test_call_batch_all_notifications
+    @@server.handler.notify_sum_data = nil
+    @@server.handler.notify_hello_data = nil
+    result = @@server.dispatch '[
+        {"jsonrpc": "2.0", "method": "notify_sum", "params": [1,2,4]},
+        {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]}
+    ]'
+    assert_equal("", result);
+    assert_equal([1,2,4], @@server.handler.notify_sum_data);
+    assert_equal(7, @@server.handler.notify_hello_data);
+  end
+
+  def test_simple_prefix_request
+    result = @@prefixed_server.dispatch '{"jsonrpc": "2.0", "method": "multiply", "params": [6, 8], "id": 1}'
+    expected_res = '{"jsonrpc": "2.0", "result": 48, "id": 1}'
+    assert_equal(JSON.parse(expected_res),
+                 JSON.parse(result))
+  end
+
+end

data/test/cases.yml

@@ -0,0 +1,64 @@
+tests:
+- id: 1
+  name: 'simple request'
+  request: '{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}'
+  response: '{"jsonrpc": "2.0", "result": 19, "id": 1}'
+
+- id: 2
+  name: 'simple request'
+  request: '{"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 1}'
+  response: '{"jsonrpc": "2.0", "result": -19, "id": 1}'
+
+- id: 3
+  name: 'named request'
+  request: '{"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 1}'
+  response: '{"jsonrpc": "2.0", "result": 19, "id": 1}'
+
+- id: 4
+  name: 'named request'
+  request: '{"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 23, "subtrahend": 42}, "id": 1}'
+  response: '{"jsonrpc": "2.0", "result": -19, "id": 1}'
+
+- id: 5
+  name: 'non_existing'
+  request: '{"jsonrpc": "2.0", "method": "foobar1", "id": "1"}'
+  response: '{"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found."}, "id": "1"}'
+
+- id: 6
+  name: 'parse_error'
+  request: '{"jsonrpc": "2.0", "method": "foobar, "params": "bar", "baz]'
+  response: '{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": null}'
+
+- id: 7
+  name: 'invalid_request_object'
+  request: '{"jsonrpc": "2.0", "method": 1, "params": "bar"}'
+  response: '{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null}'
+
+- id: 8
+  name: 'call_batch_invalid_json'
+  request: '[ {"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},{"jsonrpc": "2.0", "method" ]'
+  response: '{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": null}'
+
+- id: 9
+  name: 'empty_batch'
+  request: '[]'
+  response: '{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null}'
+
+- id: 10
+  name: 'invalid_batch_not_empty'
+  request: '[1]'
+  response: '[
+         {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null}
+         ]'
+
+- id: 11
+  name: 'invalid_batch'
+  request: '[1,2,3]'
+  response: '[
+         {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null},
+         {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null},
+         {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": null}
+     ]'
+
+
+  

data/test/no_namespace.rb

@@ -0,0 +1,35 @@
+# Example of RPC handler
+
+class NoNamespace
+
+  attr_accessor :notify_sum_data, :arr, :notify_hello_data, :foobar_called
+
+  def sum left, middle, right
+    return left + middle + right
+  end
+
+  def get_data
+    return ["hello", 5]
+  end
+
+  def subtract minuend, subtrahend
+    return minuend - subtrahend
+  end
+
+  def notify_sum *arr
+    @notify_sum_data = arr
+  end
+
+  def update *arr
+    @arr = arr
+  end
+
+  def notify_hello hello
+    @notify_hello_data = hello
+  end
+
+  def foobar
+    @foobar_called = true
+  end
+end
+

data/test/rpc_class.rb

@@ -0,0 +1,5 @@
+class RPCClass
+  def rpc_multiply left, right
+    return left * right
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Dima Levchenko
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-31 00:00:00 +03:00
+date: 2011-06-07 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -27,10 +27,16 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/json_server.rb
+- lib/jsonrpc-server.rb
+- lib/jsonrpc-server/parser.rb
+- lib/jsonrpc-server/defs.rb
+- test/cases.yml
+- test/rpc_class.rb
+- test/no_namespace.rb
+- test/all.rb
 - README
 has_rdoc: true
-homepage: http://rubygems.org/gems/jsonrpc-server
+homepage: https://github.com/dimalev/jsonrpc-server
 licenses: []
 
 post_install_message: 

data/lib/json_server.rb

@@ -1,135 +0,0 @@
-require 'json'
-
-module JSONServer
-
-  @@JSONRPCVersion = "2.0".freeze
-
-  class JSONRPCError < RuntimeError
-    attr_reader :code, :message, :data
-    def initialize obj = {}
-      @code    = obj[:code]    || -30000
-      @message = obj[:message] || "Runtime Error"
-      @data    = obj[:data]
-    end
-  end
-
-  def dispatch_json_2 request
-    # here request specific errors are handled
-    begin
-      # no wraping, because single_request dispatcher does it
-      result = core_dispatch request
-    rescue JSONRPCError
-      result = wrap_error({ :code => $!.code,
-                            :message => $!.message,
-                            :data => $!.data
-                          })
-    rescue RuntimeError
-      result = wrap_error({ :code => -32000,
-                            :message => $!.message,
-                            :data => $!.to_s
-                          })
-    end
-    if result != nil
-      return result.to_json
-    end
-    return ''
-  end
-
-  private
-
-  def core_dispatch request
-    begin
-      data = JSON.parse request
-    rescue JSON::ParserError
-      parse_error # converting error into json-rpc 2.0
-    end
-    if data.kind_of? Array
-      invalid_request if data.length == 0 # batch can not be empty
-      res = data.collect{ |single|
-        parse_single single
-      }
-      res.delete(nil)
-      return res unless res.length == 0
-      return nil
-    end
-    parse_single data
-  end
-
-  def wrap data, id = nil
-    data.update({ :jsonrpc => @@JSONRPCVersion, :id => id })
-  end
-
-  def wrap_error error, id = nil
-    wrap({ :error => error }, id)
-  end
-
-  def wrap_result result, id = nil
-    wrap({:result => result}, id)
-  end
-
-  def parse_single(data)
-    current_id = nil
-    begin
-      invalid_request unless data.kind_of?(Hash)
-      current_id = data["id"] unless data["id"] == nil
-      if data["jsonrpc"] != @@JSONRPCVersion ||
-          (not data["method"].kind_of?(String)) ||
-          data["method"] == ""
-        invalid_request
-      end
-      self.class.public_instance_methods.each { |method|
-        if method.to_s == data["method"]
-          if data["params"].kind_of? Array
-            arr = data["params"]
-          elsif
-            arr = self.method(data["method"]).parameters.collect { |pd|
-              data["params"][pd[1].to_s]
-            }
-          end
-          result = self.send(data["method"], *arr)
-          if current_id != nil
-            return wrap_result(result, current_id)
-          else
-            return
-          end
-        end
-      }
-      method_not_found
-    rescue JSONRPCError
-      result = wrap_error({ :code => $!.code,
-                            :message => $!.message,
-                            :data => $!.data
-                          }, current_id)
-    rescue RuntimeError
-      result = wrap_error({ :code => -32000,
-                            :message => $!.message,
-                            :data => $!.to_s
-                          }, current_id)
-    end
-  end
-
-  ##
-  #  Error handling section
-  ##
-
-  def method_not_found
-    raise(JSONRPCError, {
-            :code => -32601,
-            :message => "Method not found."
-          }, caller)
-  end
-
-  def parse_error
-    raise(JSONRPCError, {
-            :code => -32700,
-            :message => "Parse error."
-          }, caller)
-  end
-
-  def invalid_request
-    raise(JSONRPCError, {
-            :code => -32600,
-            :message => "Invalid Request."
-          }, caller)
-  end
-end