msgpack-rpc-over-http 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in msgpack-rpc-over-http.gemspec
+gemspec
+
+group :test do
+  gem 'test-unit', '~> 2.5.2'
+  gem 'thin'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Narihiro Nakamura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# MessagePack-RPC over HTTP (Ruby)
+
+This library provides [MessagePack-RPC](https://github.com/msgpack/msgpack-rpc) via HTTP as XML-RPC.
+The original MessagePack-RPC Server in Ruby is not good in some cases.
+It doesn't scale. It's incompatible with Thread. There is no decent termination...
+
+We alreadly have various high perfomance HTTP servers.
+We can use these in MessagePack-RPC over HTTP.
+
+**CAUTION**
+
+There is no compatibility with other implementation of normal MessagePack-RPC (not over HTTP).
+So you can not connect a normal RPC client to a RPC server over HTTP.
+
+## Usage
+
+**Server**
+
+confir.ru:
+```ruby
+require 'msgpack-rpc-over-http'
+class MyHandler
+  def add(x,y) return x+y end
+end
+
+run MessagePack::RPCOverHTTP::Server.app(MyHandler.new)
+```
+
+rackup:
+```zsh
+% rackup config.ru -s thin
+>> Thin web server (v1.5.0 codename Knife)
+>> Maximum connections set to 1024
+>> Listening on 0.0.0.0:9292, CTRL+C to stop
+```
+
+**Client**
+
+client.rb:
+```ruby
+require 'msgpack-rpc-over-http'
+c = MessagePack::RPCOverHTTP::Client.new("http://0.0.0.0:9292/")
+result = c.call(:add, 1, 2)  #=> 3
+```
+
+## Extended futures
+
+Support streaming response via Chunked Transfer-Encoding.
+
+```ruby
+# server side
+class Handler
+  include MessagePack::RPCOverHTTP::Server::Streamer
+  def log
+    return stream do
+      File.open('/var/log/syslog') do |f|
+        while line = f.gets.chomp
+          # write a chunked data
+          chunk(line)
+        end
+      end
+    end
+  end
+end
+
+# client
+client = MessagePack::RPCOverHTTP::Client.new("http://0.0.0.0:80/")
+client.stream do |line|
+  p line # => "Nov 3 ..."
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'msgpack-rpc-over-http'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install msgpack-rpc-over-http
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/msgpack/rpc_over_http/client.rb

@@ -0,0 +1,111 @@
+require 'celluloid'
+require 'httpclient'
+require 'forwardable'
+
+module MessagePack
+  module RPCOverHTTP
+
+    # Cliet for MessagePack-RPC over HTTP.
+    class Client
+      extend Forwardable
+
+      HEADER = {"Content-Type" => 'text/plain'}
+
+      def initialize(url, options={})
+        @url = url
+        @client = HTTPClient.new
+        @reqtable = {}
+        @seqid = 0
+      end
+
+      def_delegators(:@client,
+        :connect_timeout, :send_timeout, :receive_timeout)
+
+      # call-seq:
+      #   call(symbol, *args) -> result of remote method
+      #
+      # Calls remote method.
+      # This method is same as call_async(method, *args).value
+      def call(method, *args)
+        return send_request(method, args)
+      end
+
+      # call-seq:
+      #   call_async(symbol, *args) -> Celluloid::Future
+      #
+      # Calls remote method asynchronously.
+      # This method is non-blocking and returns Future.
+      def call_async(method, *args)
+        return Celluloid::Future.new{ send_request(method, args) }
+      end
+
+      # call-seq:
+      #   callback(symbol, *args) {|res, err| } -> Celluloid::Future
+      #
+      # Calls remote method asynchronously.
+      # The callback method is called with Future when the result is reached.
+      # `err' is assigned a instance of RemoteError or child if res is nil.
+      def callback(method, *args, &block)
+        return Celluloid::Future.new do
+          begin
+            block.call(send_request(method, args))
+          rescue RemoteError => ex
+            block.call(nil, ex)
+          end
+        end
+      end
+
+      # call-seq:
+      #   stream(symbol, *args) {|chunk| }
+      #
+      # Calls remote method with streaming.
+      # Remote method have to return a chunked response.
+      def stream(method, *args, &block)
+        data = create_request_body(method, args)
+        @client.post_content(@url, :body => data, :header => HEADER) do |chunk|
+          begin
+            block.call(get_result(chunk))
+          rescue RemoteError => ex
+            block.call(nil, ex)
+          end
+        end
+      end
+
+      # call-seq:
+      #   stream_async(symbol, *args) {|chunk| } -> Celluloid::Future
+      #
+      # Calls remote method asynchronously with streaming.
+      def stream_async(method, *args, &block)
+        return Celluloid::Future.new do
+          stream(method, *args, &block)
+        end
+      end
+
+      private
+      def send_request(method, param)
+        data = create_request_body(method, param)
+        body = @client.post_content(@url, :body => data, :header => HEADER)
+        return get_result(body)
+      end
+
+      def create_request_body(method, param)
+        method = method.to_s
+        msgid = @seqid
+        @seqid += 1
+        @seqid = 0 if @seqid >= (1 << 31)
+        data = [REQUEST, msgid, method, param].to_msgpack
+      end
+
+      def get_result(body)
+        type, msgid, err, res = MessagePack.unpack(body)
+        raise "Unknown message type #{type}" if type != RESPONSE
+
+        if err.nil?
+          return res
+        else
+          raise RemoteError.create(err, res)
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/error.rb

@@ -0,0 +1,44 @@
+module MessagePack
+
+  ##
+  ## MessagePack-RPCOverHTTP Exception
+  ##
+  #
+  #  RemoteError
+  #  |
+  #  +-- RuntimeError
+  #  |
+  #  +-- (user-defined errors)
+  #
+  module RPCOverHTTP
+    class RemoteError < StandardError
+      def initialize(code, *data)
+        @code = code.to_s
+        @data = data
+        super(@data.shift || @code)
+      end
+
+      attr_reader :code
+      attr_reader :data
+
+      def self.create(code, data)
+        error_class = constantize(code)
+        if error_class < RemoteError
+          error_class.new(code, *data)
+        else
+          self.new(code, *data)
+        end
+      end
+
+      private
+      def self.constantize(name)
+        return name.split("::").inject(Object) do |memo, i|
+          memo.const_get(i)
+        end
+      end
+    end
+
+    class RuntimeError < RemoteError
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/server/dispatcher.rb

@@ -0,0 +1,24 @@
+module MessagePack
+  module RPCOverHTTP
+    class Server
+
+      # Dispatcher of user-defined handler.
+      class Dispatcher
+        def initialize(handler, accept=handler.public_methods)
+          @handler = handler
+          @accept = accept
+        end
+
+        def call(env)
+          method = env['msgpack-rpc.method']
+          params = env['msgpack-rpc.params']
+          unless @accept.include?(method)
+            raise NoMethodError, "method `#{method}' is not accepted"
+          end
+
+          return @handler.send(method, *params)
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/server/request_unpacker.rb

@@ -0,0 +1,69 @@
+module MessagePack
+  module RPCOverHTTP
+    class Server
+
+      # Rack Middleware that unpacks a serialized string in a HTTP
+      # request.
+      class RequestUnpacker
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          req = Rack::Request.new(env)
+          if (error = check_request(req))
+            return error
+          end
+
+          unpack(env, req.body.read)
+          return @app.call(env)
+        end
+
+        private
+        def check_request(req)
+          if req.request_method != "POST"
+            return [
+              405, # Method Not Allowed
+              {'Content-Type' => 'text/plain'},
+              ["Only POST is allowed"]
+            ]
+          end
+
+          if req.media_type != "text/plain"
+            return [
+              400, # Bad Request
+              {'Content-Type' => 'text/plain'},
+              ["Only text/plain is allowed #{req.content_type}"]
+            ]
+          end
+
+          if req.content_length.to_i <= 0
+            return [
+              411, # Length Required
+              {'Content-Type' => 'text/plain'},
+              ["Missing Content-Length"]
+            ]
+          end
+
+          return nil
+        end
+
+        def unpack(env, body)
+          msg = MessagePack.unpack(body)
+          env['msgpack-rpc.type'] = msg[0]
+          case msg[0]
+          when REQUEST
+            env['msgpack-rpc.msgid'] = msg[1]
+            env['msgpack-rpc.method'] = msg[2].to_sym
+            env['msgpack-rpc.params'] = msg[3]
+          when NOTIFY
+            env['msgpack-rpc.method'] = msg[1].to_sym
+            env['msgpack-rpc.params'] = msg[2]
+          else
+            raise "unknown message type #{msg[0]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/server/response_packer.rb

@@ -0,0 +1,41 @@
+module MessagePack
+  module RPCOverHTTP
+    class Server
+
+      # Rack Middleware that packs a result of a handler method and
+      # create a HTTP Responce.
+      class ResponsePacker
+        def initialize(dispatcher)
+          @dispatcher = dispatcher
+        end
+
+        def call(env)
+          res = Rack::Response.new
+          res["Content-type"] = "text/plain"
+          msgid = env['msgpack-rpc.msgid']
+
+          body = @dispatcher.call(env)
+          if body.is_a?(Streamer::Body)
+            body.msgid = msgid
+            res.body = body
+            return [res.status.to_i, res.header, body]
+          else
+            res.write self.class.pack(msgid, nil, body)
+            return res.finish
+          end
+        rescue RPCOverHTTP::RemoteError => ex
+          res.write self.class.pack(msgid, ex.class.name, ex.message)
+          return res.finish
+        rescue ::RuntimeError => ex
+          res.write(self.class.pack(
+              msgid, RPCOverHTTP::RuntimeError.name, ex.message))
+          return res.finish
+        end
+
+        def self.pack(msgid, error, result)
+          return MessagePack.pack([RESPONSE, msgid, error, result])
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/server/streamer.rb

@@ -0,0 +1,67 @@
+require 'fiber'
+
+module MessagePack
+  module RPCOverHTTP
+    class Server
+
+      # Support streaming
+      module Streamer
+        class Body
+          attr_accessor :msgid
+
+          def initialize(&proc)
+            @proc = proc
+          end
+
+          def each(&block)
+            @proc.call(msgid, block)
+            return self
+          end
+        end
+
+        # call-seq:
+        #   stream(&writer) -> streamable body
+        #
+        # Returns a Body object that responds to each.
+        # Chunks of body are created with calling chunk() in given block.
+        #
+        #   def passwd
+        #     return stream do
+        #       File.open('/etc/passwd') do |file|
+        #         while line = file.gets
+        #           chunk(file.gets)
+        #         end
+        #       end
+        #     end
+        #   end
+        def stream(&writer)
+          fi = Fiber.new do
+            writer.call
+          end
+
+          Body.new do |msgid, sender|
+            begin
+              while true
+                chunk = fi.resume
+                break unless fi.alive?
+                sender.call(ResponsePacker.pack(msgid, nil, chunk))
+              end
+            rescue RemoteError => ex
+              sender.call(ResponsePacker.pack(msgid, ex.class.name, nil))
+            rescue ::RuntimeError => ex
+              sender.call(ResponsePacker.pack(msgid, RuntimeError.name, nil))
+            end
+          end
+        end
+
+        # call-seq:
+        #   chunk(obj)
+        #
+        # Send a object as chunked data in block of stream().
+        def chunk(obj)
+          Fiber.yield(obj)
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/server.rb

@@ -0,0 +1,25 @@
+require 'rack'
+require 'rack/builder'
+require_relative 'server/dispatcher'
+require_relative 'server/request_unpacker'
+require_relative 'server/response_packer'
+require_relative 'server/streamer'
+
+module MessagePack
+  module RPCOverHTTP
+    class Server
+
+      # Retruns the application for MessagePack-RPC.
+      # It's create with Rack::Builder
+      def self.app(handler)
+        return Rack::Builder.app do
+          use Rack::Chunked
+          use RequestUnpacker
+          use ResponsePacker
+          use Dispatcher
+          run handler
+        end
+      end
+    end
+  end
+end

data/lib/msgpack/rpc_over_http/version.rb

@@ -0,0 +1,5 @@
+module MessagePack
+  module RPCOverHTTP
+    VERSION = "0.0.1"
+  end
+end

data/lib/msgpack-rpc-over-http.rb

@@ -0,0 +1,16 @@
+require 'msgpack'
+require_relative "msgpack/rpc_over_http/version"
+require_relative "msgpack/rpc_over_http/error"
+require_relative "msgpack/rpc_over_http/server"
+require_relative "msgpack/rpc_over_http/client"
+
+module MessagePack
+  module RPCOverHTTP
+    REQUEST  = 0    # [0, msgid, method, param]
+    RESPONSE = 1    # [1, msgid, error, result]
+    NOTIFY   = 2    # [2, method, param]
+
+    NO_METHOD_ERROR = 0x01;
+    ARGUMENT_ERROR  = 0x02;
+  end
+end

data/msgpack-rpc-over-http.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/msgpack/rpc_over_http/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Narihiro Nakamura"]
+  gem.email         = ["authornari@gmail.com"]
+  gem.description   = %q{This library provides MessagePack-RPC via HTTP}
+  gem.summary       = %q{This library provides MessagePack-RPC via HTTP}
+  gem.homepage      = "https://github.com/authorNari/msgpack-rpc-over-http"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "msgpack-rpc-over-http"
+  gem.require_paths = ["lib"]
+  gem.version       = MessagePack::RPCOverHTTP::VERSION
+
+  gem.add_development_dependency "rack", "~> 1.4.1"
+  gem.add_development_dependency "msgpack", "~> 0.4.7"
+  gem.add_development_dependency "celluloid", "~> 0.12.3"
+  gem.add_development_dependency "httpclient", "~> 2.3.0.1"
+end

data/test/helper.rb

@@ -0,0 +1,49 @@
+require 'net/http'
+require 'timeout'
+
+class MockHandler
+  include MessagePack::RPCOverHTTP::Server::Streamer
+
+  class Error < MessagePack::RPCOverHTTP::RemoteError
+  end
+
+  def test(*args)
+    return args
+  end
+
+  def stream_normal(*args)
+    return stream { args.each{|arg| chunk(arg) } }
+  end
+
+  def stream_error(*args)
+    return stream do
+      args.each{|arg| chunk(arg) }
+      raise "Error"
+    end
+  end
+
+  def error
+    raise "Something Error"
+  end
+
+  def user_defined_error
+    raise Error, "Something Error"
+  end
+end
+
+def sleep_until_http_server_is_started(host, port)
+  timeout(30) do 
+    while stopped_test_app_server?(host, port)
+      sleep 1
+    end
+  end
+end
+
+def stopped_test_app_server?(host, port)
+  begin
+    Net::HTTP.get(host, '/', port)
+    return false
+  rescue => ex
+    return true
+  end
+end

data/test/mock_server.ru

@@ -0,0 +1,8 @@
+#\ -s thin
+$LOAD_PATH.unshift(File.expand_path("./../lib", File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'msgpack-rpc-over-http'
+require 'helper'
+
+run MessagePack::RPCOverHTTP::Server.app(MockHandler.new)

data/test/run-test.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+base_dir = File.expand_path(File.dirname(__FILE__))
+top_dir = File.expand_path("..", base_dir)
+$LOAD_PATH.unshift(File.join(top_dir, "lib"))
+$LOAD_PATH.unshift(File.join(top_dir, "test"))
+
+require "bundler"
+Bundler.require(:default, :test)
+require "test/unit"
+
+require "msgpack-rpc-over-http"
+require "helper"
+
+test_file = "./test/test_*.rb"
+Dir.glob(test_file) do |file|
+  require file
+end
+

data/test/test_client.rb

@@ -0,0 +1,83 @@
+module MessagePack::RPCOverHTTP
+  class TestClient < Test::Unit::TestCase
+    def self.unused_port
+      s = TCPServer.open(0)
+      port = s.addr[1]
+      s.close
+      port
+    end
+
+    @@server_port = unused_port
+    @@is_stopped_test_app_server = true
+
+    def setup
+      @client = Client.new("http://0.0.0.0:#{@@server_port}/")
+      if @@is_stopped_test_app_server
+        pid = fork {
+          Rack::Server.start(config: "test/mock_server.ru", Port: @@server_port)
+          exit 0
+        }
+        at_exit do
+          Process.kill(:INT, pid)
+          Process.waitpid(pid)
+        end
+        sleep_until_http_server_is_started("0.0.0.0", @@server_port)
+        @@is_stopped_test_app_server = false
+      end
+    end
+
+    def test_call
+      assert_equal ["a", "b"], @client.call(:test, "a", "b")
+      assert_raise(MessagePack::RPCOverHTTP::RuntimeError) do
+        @client.call(:error)
+      end
+      assert_raise(MockHandler::Error) do
+        @client.call(:user_defined_error)
+      end
+    end
+
+    def test_call_async
+      future = @client.call_async(:test, "a", "b")
+      assert_equal ["a", "b"], future.value
+      assert_raise(MessagePack::RPCOverHTTP::RuntimeError) do
+        future = @client.call(:error)
+        future.value
+      end
+    end
+
+    def test_callback
+      future = @client.callback(:test, "a", "b") do |res|
+        assert_equal ["a", "b"], res
+      end
+      future.value
+      future = @client.callback(:error) do |res, err|
+        assert_kind_of MessagePack::RPCOverHTTP::RuntimeError, err
+      end
+      future.value
+    end
+
+    def test_stream
+      expect = ["a", "b"]
+      @client.stream(:stream_normal, "a", "b") do |res|
+        assert_equal expect.shift, res
+      end
+
+      expect = ["a", "b"]
+      @client.stream(:stream_error) do |res, err|
+        if res
+          assert_equal expect.shift, res
+        else
+          assert_kind_of MessagePack::RPCOverHTTP::RuntimeError, err
+        end
+      end
+    end
+
+    def test_stream_async
+      expect = ["a", "b"]
+      future = @client.stream_async(:stream_normal, "a", "b") do |res|
+        assert_equal expect.shift, res
+      end
+      future.value
+    end
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: msgpack-rpc-over-http
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Narihiro Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.3
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0.1
+description: This library provides MessagePack-RPC via HTTP
+email:
+- authornari@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/msgpack-rpc-over-http.rb
+- lib/msgpack/rpc_over_http/client.rb
+- lib/msgpack/rpc_over_http/error.rb
+- lib/msgpack/rpc_over_http/server.rb
+- lib/msgpack/rpc_over_http/server/dispatcher.rb
+- lib/msgpack/rpc_over_http/server/request_unpacker.rb
+- lib/msgpack/rpc_over_http/server/response_packer.rb
+- lib/msgpack/rpc_over_http/server/streamer.rb
+- lib/msgpack/rpc_over_http/version.rb
+- msgpack-rpc-over-http.gemspec
+- test/helper.rb
+- test/mock_server.ru
+- test/run-test.rb
+- test/test_client.rb
+homepage: https://github.com/authorNari/msgpack-rpc-over-http
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: This library provides MessagePack-RPC via HTTP
+test_files:
+- test/helper.rb
+- test/mock_server.ru
+- test/run-test.rb
+- test/test_client.rb