json-rpc 0.1.0

data/README.md

@@ -0,0 +1,69 @@
+Json Rpc
+========
+
+Implementation of [JSON RPC 2.0](http://groups.google.com/group/json-rpc/web/json-rpc-2-0) protocol.
+It allows you to create easily json rpc server.
+
+Usage
+-----
+
+Simple Rack example:
+
+~~~~~~ {ruby}
+require 'json-rpc'
+
+class SyncApp
+  include JsonRpc
+  def call env
+    result = dispatch(env) { |e|
+      logger.info "#{e}"
+    }
+    result
+  end
+
+  def rpc_sum a, b
+    a + b
+  end
+end
+run SyncApp.new
+~~~~~~
+
+Asynchronous Event Machine example:
+
+~~~~~~ {ruby}
+require 'json-rpc'
+
+class AsyncApp
+  include JsonRpc
+  AsyncResponse = [-1, {}, []].freeze
+  def call env
+    result = dispatch(env)
+    env['async.callback'].call result
+    AsyncResponse
+  end
+
+  def rpc_sum a, b
+    result = Rpc::AsyncResult.new
+    EventMachine::next_tick do
+      result.reply a + b
+      result.succeed
+    end
+    result
+  end
+end
+~~~~~~
+
+### License
+Copyright 2011 [Helios Technologies Ltd.](http://www.heliostech.hk)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/example/async_app.ru

@@ -0,0 +1,28 @@
+# -*- RUBY -*-
+$: << File::join(File::dirname(__FILE__), "..", "lib")
+require 'json-rpc'
+
+class AsyncApp
+  include JsonRpc
+
+  AsyncResponse = [-1, {}, []].freeze
+
+  def call env
+    result = dispatch(env) { |e|
+      puts "#{e} backtrace: #{e.backtrace.join "\n"}"
+    }
+    env['async.callback'].call result
+    AsyncResponse
+  end
+
+  def rpc_sum a, b
+    result = Rpc::AsyncResult.new
+    EventMachine::next_tick do
+      result.reply a + b
+      result.succeed
+    end
+    result
+  end
+end
+
+run AsyncApp.new

data/example/rack_app.ru

@@ -0,0 +1,20 @@
+# -*- RUBY -*-
+$: << File::join(File::dirname(__FILE__), "..", "lib")
+require 'json-rpc'
+
+class SyncApp
+  include JsonRpc
+
+  def call env
+    result = dispatch(env) { |e|
+      logger.info "#{e} backtrace: #{e.backtrace.join "\n"}"
+    }
+    result
+  end
+
+  def rpc_sum a, b
+    a + b
+  end
+end
+
+run SyncApp.new

data/lib/json-rpc.rb

@@ -0,0 +1,127 @@
+require 'json'
+require 'eventmachine'
+require 'uri'
+
+module JsonRpc
+
+  # Call the correct method for each query
+  # The method should be prefixed by rpc_
+  # If the method doesn't exists, an error will be return in JSON
+  # More details in http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+  def rpc_call env, &ecb
+    begin
+      request = Rpc::parse env
+      status = Rpc::validate request
+      result = Rpc::route request, self
+
+    rescue Rpc::Error => e
+      status = e.status
+      result = e.result
+      ecb.call(e) if ecb
+    end
+
+    [status, {'Content-Type' => Rpc::ContentType}, result]
+  end
+
+  module Rpc
+    Version = "2.0".freeze
+    Prefix = "rpc_".freeze
+    ContentType = "application/json".freeze
+
+    ErrorProtocol = {
+      :parse_error      => [500, -32700, "Parse error"],
+      :invalid_request  => [400, -32600, "Invalid Request"],
+      :method_not_found => [404, -32601, "Method not found"],
+      :invalid_params   => [500, -32602, "Invalid params"],
+      :internal_error   => [500, -32603, "Internal error"],
+    }
+
+    class Error < RuntimeError
+      attr_reader :status, :code, :msg
+      attr_accessor :id
+      def initialize status, code, msg
+        @status, @code, @msg = status, code, msg
+      end
+      def result
+        res = {"jsonrpc" => "2.0", "id" => id,
+          "error" => {"code" => code, "message" => msg}
+        }
+        res.delete_if { |k, v| v == nil}
+        res.to_json
+      end
+    end
+
+    def self.error index, id = nil
+      id = nil unless id.is_a? Fixnum
+      ex = Rpc::Error.new *ErrorProtocol[index]
+      ex.id = id
+      ex
+    end
+
+    def self.validate request
+      return 200 if request["jsonrpc"] == Version and
+        request["method"].kind_of?(String) and
+        request["method"] != ""
+      raise error :invalid_request, request["id"]
+    end
+
+    def self.parse env
+      begin
+        case env["REQUEST_METHOD"]
+        when "POST"
+          JSON.parse(env["rack.input"].read)
+        when "GET"
+          req = Rack::Request.new(env)
+          obj = req.params
+          obj["id"] = obj["id"] ? obj["id"].to_i : nil
+          obj["params"] = JSON::parse(obj["params"])
+          obj
+        else
+          raise error :invalid_request
+        end
+
+      rescue JSON::ParserError, Exception
+        raise error :parse_error
+      end
+    end
+
+    def self.route request, ctrl
+      method, params = Prefix + request["method"], request["params"]
+
+      unless ctrl.respond_to? method
+        raise error :method_not_found, request["id"]
+      end
+
+      result = ctrl.send(method, *params)
+      if result.is_a? AsyncResult
+        result.id = request["id"]
+        return result
+      end
+      forge_response result, request["id"]
+    end
+
+    def self.forge_response result, id = nil
+      return nil if id == nil
+      {"jsonrpc" => "2.0", "id" => id, "result" => result}.to_json
+    end
+
+    # The class RpcDeferrable is useful helps you to build a Json Rpc server
+    # into an asynchronous way
+    class AsyncResult
+      include EventMachine::Deferrable
+
+      attr_reader :response
+      attr_accessor :id
+
+      def reply obj
+        @callback.call(Rpc::forge_response(obj, @id))
+      end
+
+      #FIXME thin specific
+      def each &blk
+        @callback = blk
+      end
+    end
+
+  end
+end

data/test/test_rpc_module.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'rack/mock'
+require 'json-rpc'
+require 'uri'
+
+class All < Test::Unit::TestCase
+  include JsonRpc
+
+  ReqSubtract = {"jsonrpc"=>"2.0", "method"=>"subtract", "params"=>[42, 23], "id"=>1}
+  ReqSubtractString = JSON::dump(ReqSubtract)
+
+  def test_post_parse
+    opts = {
+      :input => ReqSubtractString,
+      :method => 'POST'
+    }
+    rs = Rpc::parse Rack::MockRequest.env_for("", opts)
+    assert_equal ReqSubtract, rs
+  end
+
+  def test_get_parse
+    opts = {:method => 'GET'}
+    rs = Rpc::parse Rack::MockRequest.env_for("/?method=subtract&params=[42,23]&id=1&jsonrpc=2.0")
+    assert_equal ReqSubtract, rs
+  end
+
+  def test_invalid_json_post_parse
+    req_string = '{"jsonrpc": "2.0", "method": "subtract", "params": [42, 2'
+
+    # POST REQUEST
+    opts = {:input => req_string,
+      :method => 'POST'
+    }
+    assert_raise(Rpc::Error) {
+      rs = Rpc::parse Rack::MockRequest.env_for("", opts)
+    }
+  end
+
+  def test_validate
+    req_hash = { "jsonrpc" => "2.0", "method" => "s", "params" => 1, "id" => 22 }
+    assert_nothing_raised {
+      Rpc::validate req_hash
+    }
+    req_hash = { "method" => "s", "params" => 1, "id" => 22 }
+    assert_raise(Rpc::Error) {
+      Rpc::validate req_hash
+    }
+    req_hash = { "jsonrpc" => "2.0", "method" => "s", "params" => 1, "id" => "22" }
+    assert_raise(Rpc::Error) {
+      Rpc::validate req_hash
+    }
+  end
+
+  def test_response_forging
+    assert_equal({"jsonrpc" => "2.0", "result" => 12, "id" => 7},
+                 JSON.parse(Rpc::forge_response(12, 7)))
+    assert_equal(nil, Rpc::forge_response(12))
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: json-rpc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Helios Technologies Ltd.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-15 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Implementation of JSON RPC 2.0 protocol. It allows you to create easily a json rpc server in pure Rack, in Rails, or asynchronous using Thin and EventMachine.
+email: contact@heliostech.hk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/json-rpc.rb
+- test/test_rpc_module.rb
+- example/async_app.ru
+- example/rack_app.ru
+- README.md
+has_rdoc: true
+homepage: https://github.com/helios-technologies/json-rpc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: JSON RPC 2.0 library for rack applications
+test_files: []
+