rpc 0.1 → 0.2

data/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+/*.gem

data/CHANGELOG

@@ -0,0 +1,7 @@
+= Version 0.2
+  * [FEATURE] Full JSON-RPC 2.0 support (added batch, errors and notifications).
+
+= Version 0.1
+  * [FEATURE] Net::HTTP(S) client.
+  * [FEATURE] EM HTTP Request client.
+  * [FEATURE] JSON-RPC encoder.

data/Gemfile

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+source "http://gemcutter.org"
+
+group(:examples) do
+  gem "rack"
+end
+
+group(:em) do
+  gem "em-http-request"
+end
+
+# group(:amqp) do
+#   gem "amq-client"
+# end
+
+group(:test) do
+  gem "rspec", ">=2.0.0"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://gemcutter.org/
+  specs:
+    addressable (2.2.5)
+    diff-lcs (1.1.2)
+    em-http-request (0.3.0)
+      addressable (>= 2.0.0)
+      escape_utils
+      eventmachine (>= 0.12.9)
+    escape_utils (0.2.3)
+    eventmachine (0.12.10)
+    rack (1.2.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-http-request
+  rack
+  rspec (>= 2.0.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jakub Stastny aka botanicus
+
+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.textile

@@ -0,0 +1,7 @@
+h1. About
+
+Generic RPC library for Ruby. Currently it supports JSON-RPC over HTTP, support for AMQP and Redis will follow soon.
+
+h1. Usage
+
+See examples.

data/examples/em-http-request-json/client.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+
+RPC.logging = true
+
+client = RPC::Clients::EmHttpRequest.new("http://127.0.0.1:8081")
+
+RPC::Client.new(client) do |client|
+  # Get result of an existing method.
+  client.server_timestamp do |result, error|
+    puts "Server timestamp is #{result}"
+  end
+
+  # Get result of a non-existing method via method_missing.
+  client.send(:+, 1) do |result, error|
+    puts "Method missing works: #{result}"
+  end
+
+  # Synchronous error handling.
+  client.buggy_method do |result, error|
+    STDERR.puts "EXCEPTION CAUGHT:"
+    STDERR.puts "#{error.class} #{error.message}"
+  end
+end

data/examples/net-http-json/client.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+
+RPC.logging = true
+
+client = RPC::Client.setup("http://127.0.0.1:8081")
+
+# Get result of an existing method.
+puts "Server timestamp is #{client.server_timestamp}"
+
+# Get result of a non-existing method via method_missing.
+puts "Method missing works: #{client + 1}"
+
+# Synchronous error handling.
+begin
+  client.buggy_method
+rescue Exception => exception
+  STDERR.puts "EXCEPTION CAUGHT: #{exception.inspect}"
+end
+
+# Notification isn't supported, because HTTP works in
+# request/response mode, so it does behave in the same
+# manner as RPC via method_missing.
+puts "Sending a notification ..."
+client.notification(:log, "Some shit.")
+
+# Batch.
+result = client.batch([[:log, ["Message"], nil], [:a_method, []]])
+puts "Batch result: #{result}"

data/examples/net-http-json/console.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require "rpc"
+require "irb"
+
+@client = RPC::Client.setup("http://127.0.0.1:8081")
+
+puts "~ RPC Client initialised, use @client to access it."
+
+IRB.start(__FILE__)

data/examples/server.ru

@@ -0,0 +1,54 @@
+#!/usr/bin/env rackup --port 8081
+# encoding: utf-8
+
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require "rpc"
+require "rack/request"
+
+RPC.logging = true
+# RPC.development = true
+
+class RpcRunner
+  def server
+    @server ||= RPC::Server.new(RemoteObject.new)
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    command = request.body.read
+    binary  = self.server.execute(command)
+    if binary.match(/NoMethodError/)
+      response(404, binary)
+    else
+      response(200, binary)
+    end
+  end
+
+  def response(status, body)
+    headers = {
+      "Content-Type" => "application/json-rpc",
+      "Content-Length" => body.bytesize.to_s}
+    [status, headers, [body]]
+  end
+end
+
+class RemoteObject
+  def server_timestamp
+    Time.now.to_i
+  end
+
+  def buggy_method
+    raise "It doesn't work!"
+  end
+
+  def method_missing(name, *args)
+    "[SERVER] received method #{name} with #{args.inspect}"
+  end
+end
+
+map("/") do
+  run RpcRunner.new
+end

data/lib/rpc.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+module RPC
+  module Clients
+    autoload :NetHttp, "rpc/clients/net-http"
+    autoload :EmHttpRequest, "rpc/clients/em-http-request"
+  end
+
+  module Encoders
+    autoload :Json, "rpc/encoders/json"
+  end
+
+  def self.logging
+    @logging ||= $DEBUG
+  end
+
+  def self.logging=(boolean)
+    @logging = boolean
+  end
+
+  def self.log(message)
+    STDERR.puts(message) if self.logging
+  end
+
+  def self.development=(boolean)
+    @development = boolean
+  end
+
+  def self.development?
+    !! @development
+  end
+
+  def self.full_const_get(const_name)
+    parts = const_name.sub(/^::/, "").split("::")
+    parts.reduce(Object) do |constant, part|
+      constant.const_get(part)
+    end
+  end
+
+  class Server
+    def initialize(subject, encoder = RPC::Encoders::Json::Server.new)
+      @subject, @encoder = subject, encoder
+    end
+
+    def execute(encoded_command)
+      @encoder.execute(encoded_command, @subject)
+    end
+  end
+
+  module ExceptionsMixin
+    attr_accessor :server_backtrace
+
+    # NOTE: We can't use super to get the client backtrace,
+    # because backtrace is generated only if there is none
+    # yet and because we are redefining the backtrace method,
+    # there always will be some backtrace.
+    def backtrace
+      @backtrace ||= begin
+        caller(3) + ["... server ..."] + self.server_backtrace
+      end
+    end
+  end
+
+  class Client < BasicObject
+    def self.setup(uri, client_class = Clients::NetHttp, encoder = Encoders::Json::Client.new)
+      client = client_class.new(uri)
+      self.new(client, encoder)
+    end
+
+    def initialize(client, encoder = Encoders::Json::Client.new, &block)
+      @client, @encoder = client, encoder
+
+      if block
+        @client.run do
+          block.call(self)
+        end
+      else
+        @client.connect
+      end
+    end
+
+    def notification(*args)
+      data = @encoder.notification(*args)
+      @client.send(data)
+    end
+
+    def batch(*args)
+      data = @encoder.batch(*args)
+      @client.send(data)
+    end
+
+    # 1) Sync: it'll return the value.
+    # 2) Async: you have to add #subscribe
+    def method_missing(method, *args, &callback)
+      binary = @encoder.encode(method, *args)
+
+      if @client.async?
+        @client.send(binary) do |encoded_result|
+          result = @encoder.decode(encoded_result)
+          callback.call(result["result"], get_exception(result["error"]))
+        end
+      else
+        ::Kernel.raise("You can't specify callback for a synchronous client.") if callback
+
+        encoded_result = @client.send(binary)
+        result = @encoder.decode(encoded_result)
+
+        if result.respond_to?(:merge) # Hash, only one result.
+          result_or_raise(result)
+        else # Array, multiple results.
+          result.map do |result|
+            result_or_raise(result)
+          end
+        end
+      end
+    end
+
+    def result_or_raise(result)
+      if error = result["error"]
+        exception = self.get_exception(error)
+        ::Kernel.raise(exception)
+      else
+        result["result"]
+      end
+    end
+
+    def get_exception(error)
+      return unless error
+      exception = error["error"]
+      resolved_class = ::RPC.full_const_get(exception["class"])
+      klass = resolved_class || ::RuntimeError
+      message = resolved_class ? exception["message"] : error["message"]
+      instance = klass.new(message)
+      instance.extend(::RPC::ExceptionsMixin)
+      instance.server_backtrace = exception["backtrace"]
+      instance
+    end
+
+    def close_connection
+      @client.disconnect
+    end
+  end
+end

data/lib/rpc/clients/em-http-request.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+# https://github.com/eventmachine/em-http-request
+
+require "eventmachine"
+require "em-http-request"
+
+# Note that we support only HTTP POST. JSON-RPC can be done
+# via HTTP GET as well, but since HTTP POST is the preferred
+# method, I decided to implement only it. More info can is here:
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+module RPC
+  module Clients
+    class EmHttpRequest
+      HEADERS ||= {"Accept" => "application/json-rpc"}
+
+      def initialize(uri)
+        @client = EventMachine::HttpRequest.new(uri)
+        @in_progress = 0
+      end
+
+      def connect
+      end
+
+      def disconnect
+      end
+
+      def run(&block)
+        EM.run do
+          block.call
+
+          # Note: There's no way how to stop the
+          # reactor when there are no remaining events.
+          EM.add_periodic_timer(0.1) do
+            EM.stop if @in_progress == 0
+          end
+        end
+      end
+
+      def send(data, &callback)
+        request = @client.post(head: HEADERS, body: data)
+        @in_progress += 1
+        request.callback do |response|
+          callback.call(response.response)
+          @in_progress -= 1
+        end
+      end
+
+      def async?
+        true
+      end
+    end
+  end
+end

data/lib/rpc/clients/net-http.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require "uri"
+
+# Note that we support only HTTP POST. JSON-RPC can be done
+# via HTTP GET as well, but since HTTP POST is the preferred
+# method, I decided to implement only it. More info can is here:
+# http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+
+module Net
+  autoload :HTTP,  "net/http"
+  autoload :HTTPS, "net/https"
+end
+
+module RPC
+  module Clients
+    class NetHttp
+      HEADERS ||= {"Accept" => "application/json-rpc"}
+
+      def initialize(uri)
+        @uri = URI.parse(uri)
+        klass = Net.const_get(@uri.scheme.upcase)
+        @client = klass.new(@uri.host, @uri.port)
+      end
+
+      def connect
+        @client.start
+      end
+
+      def disconnect
+        @client.finish
+      end
+
+      def run(&block)
+        self.connect
+        block.call
+        self.disconnect
+      end
+
+      def send(data)
+        path = @uri.path.empty? ? "/" : @uri.path
+        @client.post(path, data, HEADERS).body
+      end
+
+      def async?
+        false
+      end
+    end
+  end
+end

data/lib/rpc/encoders/json.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+# http://en.wikipedia.org/wiki/JSON-RPC
+
+begin
+  require "yajl/json_gem"
+rescue LoadError
+  require "json"
+end
+
+module RPC
+  module Encoders
+    module Json
+      # This library works with JSON-RPC 2.0
+      # http://groups.google.com/group/json-rpc/web/json-rpc-2-0
+      JSON_RPC_VERSION ||= "2.0"
+
+      # http://json-rpc.org/wd/JSON-RPC-1-1-WD-20060807.html#ErrorObject
+      module Errors
+        # @note The exceptions are "eaten", because no client should be able to shut the server down.
+        def exception(exception, code = 000, message = "#{exception.class}: #{exception.message}")
+          unless RPC.development?
+            object = {class: exception.class.to_s, message: exception.message, backtrace: exception.backtrace}
+            self.error(message, code, object)
+          else
+            raise exception
+          end
+        end
+
+        def error(message, code, object)
+          error = {name: "JSONRPCError", code: code, message: message, error: object}
+          RPC.log "ERROR #{message} (#{code}) #{error[:error].inspect}"
+          error
+        end
+      end
+
+      class Request
+        attr_reader :data
+        def initialize(method, params, id = self.generate_id)
+          @data = {jsonrpc: JSON_RPC_VERSION, method: method, params: params}
+          @data.merge!(id: id) unless id.nil?
+        end
+
+        def generate_id
+          rand(999_999_999_999)
+        end
+      end
+
+      class Client
+        include Errors
+
+        def encode(method, *args)
+          data = Request.new(method, args).data
+          RPC.log "CLIENT ENCODE #{data.inspect}"
+          JSON.generate(data)
+        end
+
+        # Notifications are calls which don't require response.
+        # They look just the same, but they don't have any id.
+        def notification(method, *args)
+          data = Request.new(method, args, nil).data
+          RPC.log "CLIENT ENCODE NOTIFICATION #{data.inspect}"
+          JSON.generate(data)
+        end
+
+        # Provide list of requests and notifications to run on the server.
+        #
+        # @example
+        #   ["list", ["/"], ["clear", "logs", nil]]
+        def batch(requests)
+          data = requests.map { |request| Request.new(*request).data }
+          RPC.log "CLIENT ENCODE BATCH #{data.inspect}"
+          JSON.generate(data)
+        end
+
+        # TODO: support batch
+        def decode(binary)
+          object = JSON.parse(binary)
+          RPC.log "CLIENT DECODE #{object.inspect}"
+          object
+        rescue JSON::ParserError => error
+          self.exception(error, -32600, "Invalid Request.")
+        end
+      end
+
+      class Server
+        include Errors
+
+        def decode(binary)
+          object = JSON.parse(binary)
+          RPC.log "SERVER DECODE #{object.inspect}"
+          object
+        rescue JSON::ParserError => error
+          # This is supposed to result in HTTP 500.
+          raise self.exception(error, -32700, "Parse error.")
+        end
+
+        def execute(encoded_result, subject)
+          result = self.decode(encoded_result)
+
+          if result.respond_to?(:merge) # Hash, only one result.
+            self.encode(result_or_error(subject, result))
+          else # Array, multiple results.
+            self.encode(
+              result.map do |result|
+                result_or_error(subject, result)
+              end
+            )
+          end
+        end
+
+        def result_or_error(subject, command)
+          method, args = command["method"], command["params"]
+          result = subject.send(method, *args)
+          self.response(result, nil, command["id"])
+        rescue NoMethodError => error
+          error = self.exception(error, -32601, "Method not found.")
+          self.response(nil, error, command["id"])
+        rescue ArgumentError => error
+          error = self.exception(error, -32602, "Invalid params.")
+          self.response(nil, error, command["id"])
+        rescue Exception => exception
+          error = self.exception(exception)
+          self.response(nil, error, command["id"])
+        end
+
+        def response(result, error, id)
+          {jsonrpc: JSON_RPC_VERSION, result: result, error: error, id: id}
+        end
+
+        def encode(response)
+          RPC.log "SERVER ENCODE: #{response.inspect}"
+          JSON.generate(response)
+        end
+      end
+    end
+  end
+end

data/rpc.gemspec

@@ -0,0 +1,34 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+require "base64"
+
+Gem::Specification.new do |s|
+  s.name = "rpc"
+  s.version = "0.2"
+  s.authors = ["Jakub Stastny aka botanicus"]
+  s.homepage = "http://github.com/ruby-amqp/rpc"
+  s.summary = "Generic RPC library for Ruby."
+  s.description = "#{s.summary} Currently it supports JSON-RPC over HTTP, support for AMQP and Redis will follow soon."
+  s.cert_chain = nil
+  s.email = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  s.has_rdoc = true
+
+  # files
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  # Ruby version
+  s.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+
+  begin
+    require "changelog"
+  rescue LoadError
+    warn "You have to have changelog gem installed for post install message"
+  else
+    s.post_install_message = CHANGELOG.new.version_changes
+  end
+
+  # RubyForge
+  s.rubyforge_project = "rpc"
+end

metadata

@@ -2,14 +2,14 @@
 name: rpc
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Jakub Stastny aka botanicus
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2011-04-13 00:00:00 +01:00
+date: 2011-05-04 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -21,14 +21,32 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- .gitignore
+- CHANGELOG
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.textile
+- examples/em-http-request-json/client.rb
+- examples/net-http-json/client.rb
+- examples/net-http-json/console.rb
+- examples/server.ru
+- lib/rpc.rb
+- lib/rpc/clients/amqp/coolio.rb
+- lib/rpc/clients/amqp/eventmachine.rb
+- lib/rpc/clients/amqp/socket.rb
+- lib/rpc/clients/em-http-request.rb
+- lib/rpc/clients/net-http.rb
+- lib/rpc/clients/redis.rb
+- lib/rpc/encoders/json.rb
+- lib/rpc/encoders/xml.rb
+- rpc.gemspec
 has_rdoc: true
 homepage: http://github.com/ruby-amqp/rpc
 licenses: []
 
-post_install_message: "[\e[32mVersion 0.1\e[0m] [FEATURE] Net::HTTP client.\n\
-  [\e[32mVersion 0.1\e[0m] [FEATURE] JSON-RPC encoder.\n"
+post_install_message: "[\e[32mVersion 0.2\e[0m] [FEATURE] Full JSON-RPC 2.0 support (added batch, errors and notifications).\n"
 rdoc_options: []
 
 require_paths: