jimson 0.2.3 → 0.3.0

data/CHANGELOG.rdoc

@@ -1,3 +1,9 @@
+== 0.3.0 / 2011-08-11
+
+* Major enhancements
+
+  * Replace eventmachine-httpserver with rack for more cross-platform goodness
+
 == 0.2.3 / 2011-08-01
 
 * Bug fixes

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/jimson/client.rb

@@ -80,8 +80,10 @@ module Jimson
 
       return data['result']
 
-      rescue Exception, StandardError
-        raise Jimson::ClientError::InternalError.new($!)
+      rescue Jimson::ClientError::Generic, Jimson::ServerError::Generic => e
+        raise e
+      rescue Exception, StandardError => e
+        raise Jimson::ClientError::InternalError.new(e)
     end
 
     def valid_response?(data)

data/lib/jimson/client_error.rb

@@ -1,24 +1,27 @@
 module Jimson
   module ClientError
-    class InvalidResponse < Exception
+    class Generic < Exception
+    end
+
+    class InvalidResponse < Generic 
       def initialize()
         super('Invalid or empty response from server.')
       end
     end
 
-    class InvalidJSON < Exception
+    class InvalidJSON <  Generic
       def initialize(json)
         super("Couldn't parse JSON string received from server:\n#{json}")
       end
     end
 
-    class InternalError < Exception
+    class InternalError < Generic
       def initialize(e)
         super("An internal client error occurred when processing the request: #{e}\n#{e.backtrace.join("\n")}")
       end
     end
 
-    class UnknownServerError < Exception
+    class UnknownServerError < Generic 
       def initialize(code, message)
         super("The server specified an error the client doesn't know about: #{code} #{message}")
       end

data/lib/jimson/http_server.rb

@@ -0,0 +1,138 @@
+require 'jimson/server_error'
+
+module Jimson
+  class HttpServer
+
+    JSON_RPC_VERSION = '2.0'
+
+    def initialize(handler)
+      @handler = handler
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      resp = Rack::Response.new
+      return resp.finish if !req.post?
+      resp.write process(req.body.read)
+      resp.finish
+    end
+
+    def process(content)
+      begin
+        request = parse_request(content)
+        if request.is_a?(Array)
+          raise Jimson::ServerError::InvalidRequest.new if request.empty?
+          response = request.map { |req| handle_request(req) }
+        else
+          response = handle_request(request)
+        end
+      rescue Jimson::ServerError::ParseError, Jimson::ServerError::InvalidRequest => e
+        response = error_response(e)
+      rescue Jimson::ServerError::Generic => e
+        response = error_response(e, request)
+      rescue StandardError, Exception
+        response = error_response(Jimson::ServerError::InternalError.new)
+      end
+
+      response.compact! if response.is_a?(Array)
+
+      return nil if response.nil? || (response.respond_to?(:empty?) && response.empty?)
+
+      response.to_json
+    end
+
+    def handle_request(request)
+      response = nil
+      begin
+        if !validate_request(request)
+          response = error_response(Jimson::ServerError::InvalidRequest.new)
+        else
+          response = create_response(request)
+        end
+      rescue Jimson::ServerError::Generic => e
+        response = error_response(e, request)
+      end
+
+      response
+    end
+
+    def validate_request(request)
+      required_keys = %w(jsonrpc method)
+      required_types = {
+                         'jsonrpc' => [String],
+                         'method'  => [String], 
+                         'params'  => [Hash, Array],
+                         'id'      => [String, Fixnum, NilClass]
+                       }
+      
+      return false if !request.is_a?(Hash)
+
+      required_keys.each do |key|
+        return false if !request.has_key?(key)
+      end
+
+      required_types.each do |key, types|
+        return false if request.has_key?(key) && !types.any? { |type| request[key].is_a?(type) }
+      end
+
+      return false if request['jsonrpc'] != JSON_RPC_VERSION
+      
+      true
+    end
+
+    def create_response(request)
+      params = request['params']
+      begin
+        if params.is_a?(Hash)
+          result = @handler.send(request['method'], params)
+        else
+          result = @handler.send(request['method'], *params)
+        end
+      rescue NoMethodError
+        raise Jimson::ServerError::MethodNotFound.new 
+      rescue ArgumentError
+        raise Jimson::ServerError::InvalidParams.new
+      rescue
+        raise Jimson::ServerError::ApplicationError.new($!)
+      end
+
+      response = success_response(request, result)
+
+      # A Notification is a Request object without an "id" member.
+      # The Server MUST NOT reply to a Notification, including those 
+      # that are within a batch request.
+      response = nil if !request.has_key?('id')
+
+      response 
+    end
+
+    def error_response(error, request = nil)
+      resp = {
+               'jsonrpc' => JSON_RPC_VERSION,
+               'error'   => error.to_h,
+             }
+      if !!request && request.has_key?('id')
+        resp['id'] = request['id'] 
+      else
+        resp['id'] = nil
+      end
+
+      resp
+    end
+
+    def success_response(request, result)
+      {
+        'jsonrpc' => JSON_RPC_VERSION,
+        'result'  => result,  
+        'id'      => request['id']
+      }
+    end
+
+    def parse_request(post)
+      data = JSON.parse(post)
+      rescue 
+        raise Jimson::ServerError::ParseError.new 
+    end
+
+  end
+end

data/lib/jimson/server.rb

@@ -1,162 +1,41 @@
-require 'eventmachine'
-require 'evma_httpserver'
-require 'logger'
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'rack/showexceptions'
 require 'json'
-require 'jimson/server_error'
+require 'jimson/http_server'
 
 module Jimson
-  class HttpServer < EM::Connection
-    include EM::HttpServer
-
-    JSON_RPC_VERSION = '2.0'
-
-    def self.handler=(handler)
-      @@handler = handler
-    end
-
-    def process_http_request
-      resp = EM::DelegatedHttpResponse.new( self )
-      resp.status = 200
-      resp.content = process_post(@http_post_content)
-      resp.send_response
-    end
-
-    def process_post(content)
-      begin
-        request = parse_request(@http_post_content)
-        if request.is_a?(Array)
-          raise Jimson::ServerError::InvalidRequest.new if request.empty?
-          response = request.map { |req| handle_request(req) }
-        else
-          response = handle_request(request)
-        end
-      rescue Jimson::ServerError::ParseError, Jimson::ServerError::InvalidRequest => e
-        response = error_response(e)
-      rescue Jimson::ServerError::Generic => e
-        response = error_response(e, request)
-      rescue StandardError, Exception
-        response = error_response(Jimson::ServerError::InternalError.new)
-      end
-
-      response.compact! if response.is_a?(Array)
-
-      return nil if response.nil? || (response.respond_to?(:empty?) && response.empty?)
-
-      response.to_json
-    end
-
-    def handle_request(request)
-      response = nil
-      begin
-        if !validate_request(request)
-          response = error_response(Jimson::ServerError::InvalidRequest.new)
-        else
-          response = create_response(request)
-        end
-      rescue Jimson::ServerError::Generic => e
-        response = error_response(e, request)
-      end
-
-      response
-    end
-
-    def validate_request(request)
-      required_keys = %w(jsonrpc method)
-      required_types = {
-                         'jsonrpc' => [String],
-                         'method'  => [String], 
-                         'params'  => [Hash, Array],
-                         'id'      => [String, Fixnum, NilClass]
-                       }
-      
-      return false if !request.is_a?(Hash)
-
-      required_keys.each do |key|
-        return false if !request.has_key?(key)
-      end
-
-      required_types.each do |key, types|
-        return false if request.has_key?(key) && !types.any? { |type| request[key].is_a?(type) }
-      end
-
-      return false if request['jsonrpc'] != JSON_RPC_VERSION
-      
-      true
-    end
-
-    def create_response(request)
-      params = request['params']
-      begin
-        if params.is_a?(Hash)
-          result = @@handler.send(request['method'], params)
-        else
-          result = @@handler.send(request['method'], *params)
-        end
-      rescue NoMethodError
-        raise Jimson::ServerError::MethodNotFound.new 
-      rescue ArgumentError
-        raise Jimson::ServerError::InvalidParams.new
-      rescue
-        raise Jimson::ServerError::ApplicationError.new($!)
-      end
-
-      response = success_response(request, result)
-
-      # A Notification is a Request object without an "id" member.
-      # The Server MUST NOT reply to a Notification, including those 
-      # that are within a batch request.
-      response = nil if !request.has_key?('id')
-
-      response 
-    end
-
-    def error_response(error, request = nil)
-      resp = {
-               'jsonrpc' => JSON_RPC_VERSION,
-               'error'   => error.to_h,
-             }
-      if !!request && request.has_key?('id')
-        resp['id'] = request['id'] 
-      else
-        resp['id'] = nil
-      end
-
-      resp
-    end
-
-    def success_response(request, result)
-      {
-        'jsonrpc' => JSON_RPC_VERSION,
-        'result'  => result,  
-        'id'      => request['id']
-      }
-    end
-
-    def parse_request(post)
-      data = JSON.parse(post)
-      rescue 
-        raise Jimson::ServerError::ParseError.new 
-    end
-
-  end
-
   class Server
     
-    attr_accessor :handler, :host, :port, :logger
-
-    def initialize(handler, host = '0.0.0.0', port = 8999, logger = Logger.new(STDOUT))
+    attr_accessor :handler, :host, :port
+
+    #
+    # +handler+ is an instance of the class to expose as a JSON-RPC server
+    #
+    # +opts+ may include:
+    # * :host - the hostname or ip to bind to
+    # * :port - the port to listen on
+    # * :server - the rack handler to use, e.g. 'webrick' or 'thin'
+    #
+    def initialize(handler, opts = {})
       @handler = handler
-      @host = host
-      @port = port
-      @logger = logger
+      @app = Jimson::HttpServer.new(@handler)
+      @host = opts[:host] || '0.0.0.0'
+      @port = opts[:port] || 8999
+      @server = opts[:server] || 'webrick'
     end
 
+    #
+    # Starts the server so it can process requests
+    #
     def start
-      Jimson::HttpServer.handler = @handler
-      EM.run do
-        EM::start_server(@host, @port, Jimson::HttpServer)
-        @logger.info("Server listening on #{@host}:#{@port} with handler '#{@handler}'")
-      end
+      Rack::Server.start(
+        :server => @server,
+        :app    => @app,
+        :Host   => @host,
+        :Port   => @port
+      )
     end
 
   end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ require 'json'
 
 SPEC_URL = 'http://localhost:8999'
 
-pid = Process.spawn(File.dirname(__FILE__) + '/em_helper.rb')
+pid = Process.spawn(File.dirname(__FILE__) + '/server_helper.rb')
 
 RSpec.configure do |config|
   config.after(:all) do

metadata

@@ -1,71 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jimson
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.0
   prerelease: 
-  version: 0.2.3
 platform: ruby
-authors: 
+authors:
 - Chris Kite
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-01 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rest-client
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &17785440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.6.3
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: eventmachine
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *17785440
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &17780040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.12.10
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: eventmachine_httpserver
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *17780040
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &17779580 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.2.1
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: json
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.5.1
-  type: :runtime
-  version_requirements: *id004
+  version_requirements: *17779580
 description: 
 email: 
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - VERSION
 - LICENSE.txt
 - CHANGELOG.rdoc
@@ -77,41 +62,38 @@ files:
 - lib/jimson/server_error.rb
 - lib/jimson/response.rb
 - lib/jimson/request.rb
+- lib/jimson/http_server.rb
 - lib/jimson/client.rb
 - spec/server_spec.rb
 - spec/client_spec.rb
-- spec/em_helper.rb
+- spec/server_helper.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://www.github.com/chriskite/jimson
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: JSON-RPC 2.0 client and server
-test_files: 
+test_files:
 - spec/server_spec.rb
 - spec/client_spec.rb
-- spec/em_helper.rb
+- spec/server_helper.rb
 - spec/spec_helper.rb