em-jsonrpc 0.0.2

data/lib/em-jsonrpc/client.rb

@@ -0,0 +1,207 @@
+require "eventmachine"
+require "yajl"
+require "securerandom"
+
+require "em-jsonrpc/version"
+require "em-jsonrpc/constants"
+
+
+module EventMachine::JsonRPC
+
+  class Client < EM::Connection
+    DEFAULT_REQUEST_TIMEOUT = 2
+
+    attr_reader :pending_requests
+
+    def initialize(host, port, request_timeout = nil, parser_options = {})
+      @host = host
+      @port = port
+      @request_timeout = request_timeout || DEFAULT_REQUEST_TIMEOUT
+      @parser_options = parser_options
+
+      if parser_options and parser_options[:symbolize_keys]
+        @key_jsonrpc = :jsonrpc
+        @key_id = :id
+        @key_result = :result
+        @key_error = :error
+        @key_code = :code
+        @key_message = :message
+      else
+        @key_jsonrpc = KEY_JSONRPC
+        @key_id = KEY_ID
+        @key_result = KEY_RESULT
+        @key_error = KEY_ERROR
+        @key_code = KEY_CODE
+        @key_message = KEY_MESSAGE
+      end
+
+      @pending_requests = {}
+      @connected = false
+    end
+
+    def post_init
+      @encoder = Yajl::Encoder.new
+    end
+
+    def connection_completed
+      @connected = true
+      @parser = Yajl::Parser.new  @parser_options
+      @parser.on_parse_complete = method(:obj_parsed)
+      @state = :data
+      ready
+    end
+
+    def unbind
+      @pending_requests.clear
+
+      if @connected
+        connection_terminated
+      else
+        connection_failed
+      end
+      @connected = false
+    end
+
+    def connected?
+      @connected
+    end
+
+    def ready
+    end
+
+    def connection_failed
+    end
+
+    def connection_terminated
+    end
+
+    def connect_again
+      reconnect @host, @port
+    end
+
+    def send_request(method, params=nil)
+      id = SecureRandom.hex 4
+      request = Request.new self, id
+      request.timeout @request_timeout
+      @pending_requests[id] = request
+
+      jsonrpc_request = {
+        KEY_JSONRPC => VALUE_VERSION,
+        KEY_ID => id,
+        KEY_METHOD => method
+      }
+      jsonrpc_request[KEY_PARAMS] = params if params
+      send_data @encoder.encode jsonrpc_request
+
+      return request
+    end
+
+    def receive_data(data)
+      case @state
+      when :data
+        parse_data(data)
+      when :ignore
+        nil
+      end
+    end
+
+    def parse_data(data)
+      begin
+        @parser << data
+      rescue Yajl::ParseError => e
+        close_connection
+        @connected = false
+        @state = :ignore
+        parsing_error
+        cancel_pending_requests "response parsing error"
+      end
+    end
+
+    def obj_parsed(obj)
+      case obj
+      when Hash
+        process(obj)
+      when Array
+        # Do nothing, just ignore.
+      end
+    end
+
+    def process(obj)
+      return unless (id = obj[@key_id]) and id.is_a? String
+      return unless request = @pending_requests[id]
+
+      request.delete
+
+      unless obj[@key_jsonrpc] == "2.0"
+        request.fail :invalid_response, "invalid response: doesn't include \"jsonrpc\": \"2.0\""
+        return
+      end
+
+      if obj.has_key? @key_result
+        request.succeed obj[@key_result]
+        return
+      elsif error = obj[@key_error]
+        if error.is_a? Hash and (code = error[@key_code]) and (message = error[@key_message])
+          request.fail :error, error
+          return
+        else
+          request.fail :invalid_response, "invalid response: \"error\" is not a valid object"
+          return
+        end
+      else
+        request.fail :invalid_response, "invalid response: not valid \"result\" or \"error\""
+        return
+      end
+    end
+
+    def parsing_error
+    end
+
+    def cancel_pending_requests description
+      @pending_requests.each_value do |request|
+        request.fail :canceled, "request canceled: #{description}"
+      end
+      @pending_requests.clear
+    end
+
+
+    class Request
+      include EM::Deferrable
+
+      def initialize(client, id)
+        @client = client
+        @id = id
+      end
+
+      def delete
+        @client.pending_requests.delete @id
+      end
+
+      # Override EM::Deferrable#timeout method so the errback is executed passing
+      # a :request_timeout single argument.
+      # Also, the request is removed from the list of pending requests.
+      def timeout seconds
+        cancel_timeout
+        me = self
+        @deferred_timeout = EM::Timer.new(seconds) do
+          me.delete
+          me.fail :request_timeout
+        end
+      end
+    end  # class Request
+
+  end  # class Client
+
+
+  class ConnectionError < StandardError ; end
+
+
+  def self.connect_tcp(host, port, handler, request_timeout=nil, parser_options={}, &block)
+    raise Error, "EventMachine is not running" unless EM.reactor_running?
+
+    EM.connect(host, port, handler, host, port, request_timeout, parser_options, &block)
+  end
+
+end
+
+

data/lib/em-jsonrpc/constants.rb

@@ -0,0 +1,39 @@
+module EventMachine::JsonRPC
+
+    CODE_INVALID_JSON       = -32700
+    MSG_INVALID_JSON        = "invalid JSON"
+
+    CODE_INVALID_REQUEST    = -32600
+    MSG_INVALID_REQ_JSONRPC = "invalid request: doesn't include \"jsonrpc\": \"2.0\""
+    MSG_INVALID_REQ_ID      = "invalid request: wrong id"
+    MSG_INVALID_REQ_METHOD  = "invalid request: wrong method"
+    MSG_INVALID_REQ_PARAMS  = "invalid request: wrong params"
+
+    CODE_METHOD_NOT_FOUND   = -32601
+    MSG_METHOD_NOT_FOUND    = "method not found"
+
+    CODE_INVALID_PARAMS     = -32602
+    MSG_INVALID_PARAMS      = "invalid parameter(s)"
+
+    CODE_INTERNAL_ERROR     = -32603
+    MSG_INTERNAL_ERROR      = "internal error"
+
+    PARSING_ERROR_RESPONSE  = "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{" \
+                              "\"code\":#{CODE_INVALID_JSON}," \
+                              "\"message\":\"#{MSG_INVALID_JSON}\"}}"
+
+    BATCH_NOT_SUPPORTED_RESPONSE  = "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{" \
+                                    "\"code\":-32099," \
+                                    "\"message\":\"batch mode not implemented\"}}"
+
+    KEY_JSONRPC   = "jsonrpc"
+    VALUE_VERSION = "2.0"
+    KEY_ID        = "id"
+    KEY_METHOD    = "method"
+    KEY_PARAMS    = "params"
+    KEY_RESULT    = "result"
+    KEY_ERROR     = "error"
+    KEY_CODE      = "code"
+    KEY_MESSAGE   = "message"
+
+end

data/lib/em-jsonrpc/server.rb

@@ -0,0 +1,215 @@
+require "eventmachine"
+require "yajl"
+
+require "em-jsonrpc/version"
+require "em-jsonrpc/constants"
+
+
+module EventMachine::JsonRPC
+
+  class Server < EM::Connection
+    attr_reader :encoder
+    
+    def initialize(*options)
+      parser_options = options.first || {}
+      
+      if parser_options[:symbolize_keys]
+        @key_jsonrpc = :jsonrpc
+        @key_id = :id
+        @key_method = :method
+        @key_params = :params
+      else
+        @key_jsonrpc = KEY_JSONRPC
+        @key_id = KEY_ID
+        @key_method = KEY_METHOD
+        @key_params = KEY_PARAMS
+      end
+      
+      @parser = Yajl::Parser.new parser_options
+      @parser.on_parse_complete = method(:obj_parsed)
+      
+      @state = :data
+    end
+
+    def receive_data(data)
+      case @state
+      when :data
+        parse_data(data)
+      when :ignore
+        nil
+      end
+    end
+
+    def parse_data(data)
+      begin
+        @parser << data
+      rescue Yajl::ParseError => e
+        send_data PARSING_ERROR_RESPONSE
+        close_connection_after_writing
+        @state = :ignore
+        parsing_error data, e
+      end
+    end
+
+    def obj_parsed(obj)
+      @encoder ||= Yajl::Encoder.new
+      
+      case obj
+      # Individual request/notification.
+      when Hash
+        process(obj)
+      # Batch: multiple requests/notifications in an array.
+      # NOTE: Not implemented as it doesn't make sense using JSON RPC over pure TCP / UnixSocket.
+      when Array
+        send_data BATCH_NOT_SUPPORTED_RESPONSE
+        close_connection_after_writing
+        @state = :ignore
+        batch_not_supported_error obj
+      end
+    end
+
+    def process(obj)
+      is_request = obj.has_key?(@key_id)
+      id = obj[@key_id]
+
+      if is_request
+        unless id.is_a? String or id.is_a? Fixnum or id.is_a? NilClass
+          invalid_request obj, CODE_INVALID_REQUEST, MSG_INVALID_REQ_ID
+          reply_error nil, CODE_INVALID_REQUEST, MSG_INVALID_REQ_ID
+          return false
+        end
+      end
+        
+      unless obj[@key_jsonrpc] == "2.0"
+        invalid_request obj, CODE_INVALID_REQUEST, MSG_INVALID_REQ_JSONRPC
+        reply_error id, CODE_INVALID_REQUEST, MSG_INVALID_REQ_JSONRPC
+        return false
+      end
+      
+      unless (method = obj[@key_method]).is_a? String
+        invalid_request obj, CODE_INVALID_REQUEST, MSG_INVALID_REQ_METHOD
+        reply_error id, CODE_INVALID_REQUEST, MSG_INVALID_REQ_METHOD
+        return false
+      end
+      
+      if (params = obj[@key_params])
+        unless params.is_a? Array or params.is_a? Hash
+          invalid_request obj, CODE_INVALID_REQUEST, MSG_INVALID_REQ_PARAMS
+          reply_error id, CODE_INVALID_REQUEST, MSG_INVALID_REQ_PARAMS
+          return false
+        end
+      end
+
+      if is_request
+        receive_request Request.new(self, id, method, params)
+      else
+        receive_notification method, params
+      end
+    end
+
+    # This method must be overriden in the user's inherited class.
+    def receive_request(request)
+      puts "request received:\n#{request.inspect}"
+    end
+
+    # This method must be overriden in the user's inherited class.
+    def receive_notification(method, params)
+      puts "notification received (method: #{method.inspect}, params: #{params.inspect})"
+    end
+
+    def reply_error(id, code, message)
+      send_data @encoder.encode({
+        KEY_JSONRPC => VALUE_VERSION,
+        KEY_ID => id,
+        KEY_ERROR => {
+          KEY_CODE => code,
+          KEY_MESSAGE => message
+        }
+      })
+    end
+
+    # This method could be overriden in the user's inherited class.
+    def parsing_error(data, exception)
+      $stderr.puts "parsing error:\n#{exception.message}"
+    end
+
+    # This method could be overriden in the user's inherited class.
+    def batch_not_supported_error(obj)
+      $stderr.puts "batch request received but not implemented"
+    end
+    
+    # This method could be overriden in the user's inherited class.
+    def invalid_request(obj, code, message=nil)
+      $stderr.puts "error #{code}: #{message}"
+    end
+
+
+    class Request
+      attr_reader :rpc_method, :params, :id
+
+      def initialize(conn, id, rpc_method, params)
+        @conn = conn
+        @id = id
+        @rpc_method = rpc_method
+        @params = params
+      end
+
+      def reply_result(result)
+        return nil if @conn.error?
+
+        response = {
+          KEY_JSONRPC => VALUE_VERSION,
+          KEY_ID => @id,
+          KEY_RESULT => result
+        }
+
+        # Send the response in chunks (good in case of a big response).
+        begin
+          @conn.encoder.encode(response) do |chunk|
+            @conn.send_data(chunk)
+          end
+          return true
+        rescue Yajl::EncodeError => e
+          reply_internal_error "response encode error: #{e.message}"
+          return false
+        end
+      end
+
+      def reply_internal_error(message=nil)
+        return nil if @conn.error?
+        @conn.reply_error(@id, CODE_INTERNAL_ERROR, message || MSG_INTERNAL_ERROR)
+      end
+
+      def reply_method_not_found(message=nil)
+        return nil if @conn.error?
+        @conn.reply_error(@id, CODE_METHOD_NOT_FOUND, message || MSG_METHOD_NOT_FOUND)
+      end
+
+      def reply_invalid_params(message=nil)
+        return nil if @conn.error?
+        @conn.reply_error(@id, CODE_INVALID_PARAMS, message || MSG_INVALID_PARAMS)
+      end
+
+      def reply_custom_error(code, message)
+        return nil if @conn.error?
+        unless code.is_a? Integer and (-32099..-32000).include? code
+          raise ArgumentError, "code must be an integer between -32099 and -32000"
+        end
+        @conn.reply_error(@id, code, message)
+      end
+    end  # class Request
+
+  end  # class Server
+
+
+  def self.start_tcp_server(addr, port, handler, options=nil, &block)
+    raise Error, "EventMachine is not running" unless EM.reactor_running?
+    EM.start_server addr, port, handler, options, &block
+  end
+
+  def self.start_unix_domain_server(filename, handler, options=nil, &block)
+    raise Error, "EventMachine is not running" unless EM.reactor_running?
+    EM.start_unix_domain_server filename, handler, options, &block
+  end
+
+end

data/lib/em-jsonrpc/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module JsonRPC
+    VERSION = "0.0.2"
+  end
+end

data/test/test-em-jsonrpc-client.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+require "test/unit"
+require "rubygems"
+require "yajl"
+require "socket"
+require "timeout"
+
+
+class TestJsonRPC < Test::Unit::TestCase
+
+  def initialize(*args)
+    super
+    @socket = TCPSocket.new "127.0.0.1", 8888
+    @parser = Yajl::Parser.new
+    @parser.on_parse_complete = method(:response_parsed)
+    @encoder = Yajl::Encoder.new
+  end
+
+  def send_request(request)
+    @response = nil
+    @socket.send request, 0
+
+    begin
+      Timeout.timeout(0.2) do
+        while true do
+          begin
+            data = @socket.recv_nonblock 1024
+            @parser << data
+            return @response if @response
+          rescue IO::WaitReadable #Errno::EAGAIN
+            IO.select([@socket])
+            retry
+          end
+        end
+      end
+    rescue Timeout::Error
+      return nil
+    end
+  end
+
+  def response_parsed(response)
+    @response = response
+  end
+
+  def test_01_rpc_call_with_positional_parameters
+    reply = send_request '{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}'
+    assert_equal( {"jsonrpc"=>"2.0", "result"=>19, "id"=>1}, reply )
+  end
+
+  def test_02_rpc_call_with_positional_parameters
+    reply = send_request '{"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}'
+    assert_equal( {"jsonrpc"=>"2.0", "result"=>-19, "id"=>2}, reply )
+  end
+
+  def test_03_rpc_call_with_named_parameters
+    reply = send_request '{"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}'
+    assert_equal( {"jsonrpc"=>"2.0", "result"=>19, "id"=>3}, reply )
+  end
+
+  def test_04_rpc_call_with_named_parameters
+    reply = send_request '{"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}'
+    assert_equal( {"jsonrpc"=>"2.0", "result"=>19, "id"=>4}, reply )
+  end
+
+  def test_05_a_notification
+    reply = send_request '{"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}'
+    assert_equal( nil, reply )
+  end
+
+  def test_06_rpc_call_of_non_existent_method
+    reply = send_request '{"jsonrpc": "2.0", "method": "foobar", "id": "1"}'
+    assert_equal( {"jsonrpc"=>"2.0", "error"=>{"code"=>-32601, "message"=>"method not found"}, "id"=>"1"}, reply )
+  end
+
+  def test_07_rpc_call_with_invalid_JSON
+    reply = send_request '{"jsonrpc": "2.0", "method": "foobar, "params": "bar", "baz]'
+    assert_equal( {"jsonrpc"=>"2.0", "error"=>{"code"=>-32700, "message"=>"invalid JSON"}, "id"=>nil}, reply )
+  end
+
+  def test_08_rpc_call_with_invalid_Request_object
+    reply = send_request '{"jsonrpc": "2.0", "method": 1, "params": "bar"}'
+    assert_equal( {"jsonrpc"=>"2.0", "error" =>{"code"=>-32600, "message"=>"invalid request: wrong method"}, "id"=>nil}, reply )
+  end
+
+  def test_09_rpc_call_Batch_invalid_JSON
+    reply = send_request '[ {"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},{"jsonrpc": "2.0", "method" ]'
+    assert_equal( {"jsonrpc"=>"2.0", "error"=>{"code"=>-32700, "message"=>"invalid JSON"}, "id"=>nil}, reply )
+  end
+
+# NOTE: Batch mode is not implemented so following tests don't make sense.
+#
+#   def test_10_rpc_call_with_an_empty_Array
+#     reply = send_request '[]'
+#     assert_equal( {"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"invalid JSON"}, "id"=>nil}, reply )
+#   end
+# 
+#   def test_11_rpc_call_with_an_invalid_Batch_but_not_empty
+#     reply = send_request '[1]'
+#     assert_equal( [{"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"Invalid Request."}, "id"=>nil}], reply )
+#   end
+# 
+#   def test_12_rpc_call_with_invalid_Batch
+#     reply = send_request '[1,2,3]'
+#     assert_equal( [
+#         {"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"invalid JSON"}, "id"=>nil},
+#         {"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"invalid JSON"}, "id"=>nil},
+#         {"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"invalid JSON"}, "id"=>nil}
+#     ], reply )
+#   end
+# 
+#   def test_13_rpc_call_Batch
+#     reply = send_request '[
+#       {"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"}
+#     ]'
+#     assert_equal( [
+#       {"jsonrpc"=>"2.0", "result"=>7, "id"=>"1"},
+#       {"jsonrpc"=>"2.0", "result"=>19, "id"=>"2"},
+#       {"jsonrpc"=>"2.0", "error"=>{"code"=>-32600, "message"=>"invalid JSON"}, "id"=>nil},
+#       {"jsonrpc"=>"2.0", "error"=>{"code"=>-32601, "message"=>"method not found."}, "id"=>"5"},
+#       {"jsonrpc"=>"2.0", "result"=>["hello", 5], "id"=>"9"}
+#     ], reply )
+#   end
+# 
+#   def test_14_rpc_call_Batch_all_notifications
+#     reply = send_request '[
+#       {"jsonrpc": "2.0", "method": "notify_sum", "params": [1,2,4]},
+#       {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]}
+#     ]'
+#     assert_equal( nil, reply )
+#   end
+
+end

data/test/test-em-jsonrpc-server.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+# coding: utf-8
+
+### TMP
+$LOAD_PATH.insert 0, File.expand_path(File.join(File.dirname(__FILE__), "../", "lib"))
+require "em-jsonrpc/server"
+
+
+class MyJsonRpcServer < EM::JsonRPC::Server
+
+  def receive_request(request)
+    puts "request received:"
+    puts "- id     : #{request.id.inspect}"
+    puts "- method : #{request.rpc_method.inspect}"
+    puts "- params : #{request.params.inspect}"
+
+    case request.rpc_method
+    
+    when /^(subtract|\-)$/
+      if request.params.is_a? Array
+        minued = request.params[0].to_i
+        subtrahend = request.params[1].to_i
+      elsif request.params.is_a? Hash
+        minued = request.params[:minuend].to_i
+        subtrahend = request.params[:subtrahend].to_i
+      end
+      result = minued - subtrahend
+      request.reply_result(result)
+
+    when /^(sum|\+)$/
+      if request.params.is_a? Array
+        sum1 = request.params[0].to_i
+        sum2 = request.params[1].to_i
+      elsif request.params.is_a? Hash
+        sum1 = request.params[:minuend].to_i
+        sum2 = request.params[:subtrahend].to_i
+      end
+      result = sum1 + sum2
+      request.reply_result(result)
+
+    else
+      request.reply_method_not_found
+    end
+  end
+
+end
+
+
+EM.run do
+  yajl_options = { :symbolize_keys => true }
+  
+  EM::JsonRPC.start_tcp_server("0.0.0.0", 8888, MyJsonRpcServer, yajl_options) do |conn|
+    puts "\nnew TCP connection"
+    conn.set_comm_inactivity_timeout 120
+  end
+
+  EM::JsonRPC.start_unix_domain_server("/tmp/borrame", MyJsonRpcServer, yajl_options) do |conn|
+    puts "\nnew UnixSocket connection"
+    conn.set_comm_inactivity_timeout 120
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: em-jsonrpc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- "I\xC3\xB1aki Baz Castillo"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id002
+description: em-jsonrpc provides a JSON RPC 2.0 TCP/UnixSocket client and server to be integrated within EventMachine reactor
+email: ibc@aliax.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/em-jsonrpc/version.rb
+- lib/em-jsonrpc/constants.rb
+- lib/em-jsonrpc/server.rb
+- lib/em-jsonrpc/client.rb
+- test/test-em-jsonrpc-client.rb
+- test/test-em-jsonrpc-server.rb
+has_rdoc: true
+homepage: https://github.com/ibc/em-jsonrpc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: JSON RCP 2.0 client and server for EventMachine over TCP or UnixSocket
+test_files: []
+