jimson-temp 0.9.2

data/lib/jimson/router.rb

@@ -0,0 +1,24 @@
+require 'jimson/router/map'
+require 'forwardable'
+
+module Jimson
+  class Router
+    extend Forwardable
+
+    def_delegators :@map, :handler_for_method,
+                          :root,
+                          :namespace,
+                          :jimson_methods,
+                          :strip_method_namespace
+
+    def initialize
+      @map = Map.new
+    end
+
+    def draw(&block)
+      @map.instance_eval &block
+      self
+    end
+
+  end
+end

data/lib/jimson/router/map.rb

@@ -0,0 +1,75 @@
+module Jimson
+  class Router
+
+    #
+    # Provides a DSL for routing method namespaces to handlers.
+    # Only handles root-level and non-nested namespaces, e.g. 'foo.bar' or 'foo'.
+    #
+    class Map
+
+      def initialize
+        @routes = {}
+      end
+
+      #
+      # Set the root handler, i.e. the handler used for a bare method like 'foo'
+      #
+      def root(handler)
+        handler = handler.new if handler.is_a?(Class)
+        @routes[''] = handler
+      end
+
+      #
+      # Define the handler for a namespace
+      #
+      def namespace(ns, handler = nil, &block)
+        if !!handler
+          handler = handler.new if handler.is_a?(Class)
+          @routes[ns.to_s] = handler
+        else
+          # passed a block for nested namespacing
+          map = Jimson::Router::Map.new
+          @routes[ns.to_s] = map
+          map.instance_eval &block
+        end
+      end
+
+      #
+      # Return the handler for a (possibly namespaced) method name
+      #
+      def handler_for_method(method)
+        parts = method.split('.')
+        ns = (method.index('.') == nil ? '' : parts.first)
+        handler = @routes[ns]
+        if handler.is_a?(Jimson::Router::Map)
+          return handler.handler_for_method(parts[1..-1].join('.'))
+        end
+        handler
+      end
+
+      #
+      # Strip off the namespace part of a method and return the bare method name
+      #
+      def strip_method_namespace(method)
+        method.split('.').last
+      end
+
+      #
+      # Return an array of all methods on handlers in the map, fully namespaced
+      #
+      def jimson_methods
+        arr = @routes.keys.map do |ns|
+          prefix = (ns == '' ? '' : "#{ns}.")
+          handler = @routes[ns]
+          if handler.is_a?(Jimson::Router::Map)
+            handler.jimson_methods
+          else
+            handler.class.jimson_exposed_methods.map { |method| prefix + method }
+          end
+        end
+        arr.flatten
+      end
+
+    end
+  end
+end

data/lib/jimson/server.rb

@@ -0,0 +1,225 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'multi_json'
+require 'jimson/handler'
+require 'jimson/router'
+require 'jimson/server/error'
+
+module Jimson
+  class Server
+    
+    class System
+      extend Handler
+
+      def initialize(router)
+        @router = router
+      end
+
+      def listMethods
+        @router.jimson_methods
+      end
+
+      def isAlive 
+        true
+      end
+    end
+
+    JSON_RPC_VERSION = '2.0'
+
+    attr_accessor :router, :host, :port, :show_errors, :opts
+
+    #
+    # Create a Server with routes defined
+    #
+    def self.with_routes(opts = {}, &block)
+      router = Router.new
+      router.send(:draw, &block)
+      self.new(router, opts)
+    end
+
+    #
+    # +router_or_handler+ is an instance of Jimson::Router or extends Jimson::Handler
+    #
+    # +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'
+    # * :show_errors - true or false, send backtraces in error responses?
+    #
+    # Remaining options are forwarded to the underlying Rack server.
+    #
+    def initialize(router_or_handler, opts = {})
+      if !router_or_handler.is_a?(Router)
+        # arg is a handler, wrap it in a Router
+        @router = Router.new
+        @router.root router_or_handler
+      else
+        # arg is a router
+        @router = router_or_handler
+      end
+      @router.namespace 'system', System.new(@router)
+
+      @host = opts.delete(:host) || '0.0.0.0'
+      @port = opts.delete(:port) || 8999
+      @show_errors = opts.delete(:show_errors) || false 
+      @opts = opts
+    end
+
+    #
+    # Starts the server so it can process requests
+    #
+    def start
+      Rack::Server.start(opts.merge(
+        :app    => self,
+        :Host   => @host,
+        :Port   => @port
+      ))
+    end
+
+    #
+    # Entry point for Rack
+    #
+    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 Server::Error::InvalidRequest.new if request.empty?
+          response = request.map { |req| handle_request(req) }
+        else
+          response = handle_request(request)
+        end
+      rescue Server::Error::ParseError, Server::Error::InvalidRequest => e
+        response = error_response(e)
+      rescue Server::Error => e
+        response = error_response(e, request)
+      rescue StandardError, Exception => e
+        response = error_response(Server::Error::InternalError.new(e))
+      end
+
+      response.compact! if response.is_a?(Array)
+
+      return nil if response.nil? || (response.respond_to?(:empty?) && response.empty?)
+
+      MultiJson.encode(response)
+    end
+
+    def handle_request(request)
+      response = nil
+      begin
+        if !validate_request(request)
+          response = error_response(Server::Error::InvalidRequest.new)
+        else
+          response = create_response(request)
+        end
+      rescue Server::Error => 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, Bignum, 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)
+      method = request['method']
+      params = request['params']
+      result = dispatch_request(method, params)
+
+      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')
+
+      return response 
+
+      rescue Server::Error => e
+        raise e
+      rescue ArgumentError
+        raise Server::Error::InvalidParams.new
+      rescue Exception, StandardError => e
+        raise Server::Error::ApplicationError.new(e, @show_errors)
+    end
+
+    def dispatch_request(method, params)
+      method_name = method.to_s
+      handler = @router.handler_for_method(method_name)
+      method_name = @router.strip_method_namespace(method_name)
+
+      if handler.nil? \
+      || !handler.class.jimson_exposed_methods.include?(method_name) \
+      || !handler.respond_to?(method_name)
+        raise Server::Error::MethodNotFound.new(method)
+      end
+
+      if params.nil?
+        return handler.send(method_name)
+      elsif params.is_a?(Hash)
+        return handler.send(method_name, params)
+      else
+        return handler.send(method_name, *params)
+      end
+    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 = MultiJson.decode(post)
+      rescue 
+        raise Server::Error::ParseError.new 
+    end
+
+  end
+end

data/lib/jimson/server/error.rb

@@ -0,0 +1,66 @@
+module Jimson
+  class Server
+    class Error < StandardError
+      attr_accessor :code, :message
+
+      def initialize(code, message)
+        @code = code
+        @message = message
+        super(message)
+      end
+
+      def to_h
+        {
+          'code'    => @code,
+          'message' => @message
+        }
+      end
+
+      class ParseError < Error
+        def initialize
+          super(-32700, 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.')
+        end
+      end
+
+      class InvalidRequest < Error
+        def initialize
+          super(-32600, 'The JSON sent is not a valid Request object.')
+        end
+      end
+
+      class MethodNotFound < Error
+        def initialize(method)
+          super(-32601, "Method '#{method}' not found.")
+        end
+      end
+
+      class InvalidParams < Error
+        def initialize
+          super(-32602, 'Invalid method parameter(s).')
+        end
+      end
+
+      class InternalError < Error
+        def initialize(e)
+          super(-32603, "Internal server error: #{e}")
+        end
+      end
+
+      class ApplicationError < Error
+        def initialize(err, show_error = false)
+          msg = "Server application error"
+          msg += ': ' + err.message + ' at ' + err.backtrace.first if show_error
+          super(-32099, msg)
+        end
+      end
+
+      CODES = {
+                -32700 => ParseError,
+                -32600 => InvalidRequest,
+                -32601 => MethodNotFound,
+                -32602 => InvalidParams,
+                -32603 => InternalError
+              }
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+module Jimson
+  describe Client do
+    BOILERPLATE = {'jsonrpc' => '2.0', 'id' => 1}
+
+    before(:each) do
+      @resp_mock = mock('http_response')
+      ClientHelper.stub!(:make_id).and_return(1)
+    end
+
+    after(:each) do
+    end
+
+    describe "hidden methods" do
+      it "should reveal inspect" do
+        Client.new(SPEC_URL).inspect.should match /Jimson::Client/
+      end
+
+      it "should reveal to_s" do
+        Client.new(SPEC_URL).to_s.should match /Jimson::Client/
+      end
+    end
+
+    describe "#[]" do
+      before(:each) do
+        @client = Client.new(SPEC_URL)
+      end
+
+      context "when using a symbol to specify a namespace" do
+        it "sends the method prefixed with the namespace in the request" do
+          expected = MultiJson.encode({
+           'jsonrpc' => '2.0',
+           'method'  => 'foo.sum',
+           'params'  => [1,2,3],
+           'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          @client[:foo].sum(1, 2, 3).should == 42
+        end
+
+        context "when the namespace is nested" do
+          it "sends the method prefixed with the full namespace in the request" do
+            expected = MultiJson.encode({
+             'jsonrpc' => '2.0',
+             'method'  => 'foo.bar.sum',
+             'params'  => [1,2,3],
+             'id'      => 1
+            })
+            response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+            RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+            @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+            @client[:foo][:bar].sum(1, 2, 3).should == 42
+          end
+        end
+      end
+
+      context "when sending positional arguments" do
+        it "sends a request with the correct method and args" do
+          expected = MultiJson.encode({
+           'jsonrpc' => '2.0',
+           'method'  => 'foo',
+           'params'  => [1,2,3],
+           'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          @client['foo', 1, 2, 3].should == 42
+        end
+
+        context "when one of the args is an array" do
+          it "sends a request with the correct method and args" do
+            expected = MultiJson.encode({
+             'jsonrpc' => '2.0',
+             'method'  => 'foo',
+             'params'  => [[1,2],3],
+             'id'      => 1
+            })
+            response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+            RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+            @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+            @client['foo', [1, 2], 3].should == 42
+          end
+        end
+      end
+    end
+
+    describe "sending a single request" do
+      context "when using positional parameters" do
+        before(:each) do
+          @expected = MultiJson.encode({
+                       'jsonrpc' => '2.0',
+                       'method'  => 'foo',
+                       'params'  => [1,2,3],
+                       'id'      => 1
+          })
+        end
+        it "sends a valid JSON-RPC request and returns the result" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient.should_receive(:post).with(SPEC_URL, @expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo(1,2,3).should == 42
+        end
+
+        it "sends a valid JSON-RPC request with custom options" do
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient.should_receive(:post).with(SPEC_URL, @expected, {:content_type => 'application/json', :timeout => 10000}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL, :timeout => 10000)
+          client.foo(1,2,3).should == 42
+        end
+      end
+
+      context "when one of the parameters is an array" do
+        it "sends a correct JSON-RPC request (array is preserved) and returns the result" do
+          expected = MultiJson.encode({
+            'jsonrpc' => '2.0',
+            'method'  => 'foo',
+            'params'  => [[1,2],3],
+            'id'      => 1
+          })
+          response = MultiJson.encode(BOILERPLATE.merge({'result' => 42}))
+          RestClient.should_receive(:post).with(SPEC_URL, expected, {:content_type => 'application/json'}).and_return(@resp_mock)
+          @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+          client = Client.new(SPEC_URL)
+          client.foo([1,2],3).should == 42
+        end
+      end
+    end
+
+    describe "sending a batch request" do
+      it "sends a valid JSON-RPC batch request and puts the results in the response objects" do
+        batch = MultiJson.encode([
+          {"jsonrpc" => "2.0", "method" => "sum", "params" => [1,2,4], "id" => "1"},
+          {"jsonrpc" => "2.0", "method" => "subtract", "params" => [42,23], "id" => "2"},
+          {"jsonrpc" => "2.0", "method" => "foo_get", "params" => [{"name" => "myself"}], "id" => "5"},
+          {"jsonrpc" => "2.0", "method" => "get_data", "id" => "9"} 
+        ])
+
+        response = MultiJson.encode([
+          {"jsonrpc" => "2.0", "result" => 7, "id" => "1"},
+          {"jsonrpc" => "2.0", "result" => 19, "id" => "2"},
+          {"jsonrpc" => "2.0", "error" => {"code" => -32601, "message" => "Method not found."}, "id" => "5"},
+          {"jsonrpc" => "2.0", "result" => ["hello", 5], "id" => "9"}
+        ])
+
+        ClientHelper.stub!(:make_id).and_return('1', '2', '5', '9')
+        RestClient.should_receive(:post).with(SPEC_URL, batch, {:content_type => 'application/json'}).and_return(@resp_mock)
+        @resp_mock.should_receive(:body).at_least(:once).and_return(response)
+        client = Client.new(SPEC_URL)
+
+        sum = subtract = foo = data = nil
+        Jimson::Client.batch(client) do |batch|
+          sum = batch.sum(1,2,4)
+          subtract = batch.subtract(42,23)
+          foo = batch.foo_get('name' => 'myself')
+          data = batch.get_data
+        end
+
+        sum.succeeded?.should be_true
+        sum.is_error?.should be_false
+        sum.result.should == 7
+
+        subtract.result.should == 19
+
+        foo.is_error?.should be_true
+        foo.succeeded?.should be_false
+        foo.error['code'].should == -32601
+
+        data.result.should == ['hello', 5]
+      end
+    end
+
+    describe "error handling" do
+      context "when an error occurs in the Jimson::Client code" do
+        it "tags the raised exception with Jimson::Client::Error" do
+          client_helper = ClientHelper.new(SPEC_URL)
+          ClientHelper.stub!(:new).and_return(client_helper)
+          client = Client.new(SPEC_URL)
+          client_helper.stub!(:send_single_request).and_raise "intentional error"
+          lambda { client.foo }.should raise_error(Jimson::Client::Error)
+        end
+      end
+    end
+
+  end
+end