sr-jimson 0.11.0

data/lib/sr/jimson/client/error.rb

@@ -0,0 +1,23 @@
+module Sr::Jimson
+  class Client
+    module Error
+      class InvalidResponse < StandardError
+        def initialize()
+          super('Invalid or empty response from server.')
+        end
+      end
+
+      class InvalidJSON < StandardError
+        def initialize(json)
+          super("Couldn't parse JSON string received from server:\n#{json}")
+        end
+      end
+
+      class ServerError < StandardError
+        def initialize(code, message)
+          super("Server error #{code}: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/sr/jimson/handler.rb

@@ -0,0 +1,25 @@
+module Sr::Jimson
+  module Handler
+
+    def jimson_default_methods
+      self.instance_methods.map(&:to_s) - Object.methods.map(&:to_s)
+    end
+
+    def jimson_expose(*methods)
+      @jimson_exposed_methods ||= []
+      @jimson_exposed_methods += methods.map(&:to_s)
+    end
+
+    def jimson_exclude(*methods)
+      @jimson_excluded_methods ||= []
+      @jimson_excluded_methods += methods.map(&:to_s)
+    end
+
+    def jimson_exposed_methods
+      @jimson_exposed_methods ||= []
+      @jimson_excluded_methods ||= []
+      (jimson_default_methods - @jimson_excluded_methods + @jimson_exposed_methods).sort
+    end
+
+  end
+end

data/lib/sr/jimson/request.rb

@@ -0,0 +1,25 @@
+module Sr::Jimson
+  class Request
+
+    attr_accessor :method, :params, :id
+    def initialize(method, params, id = nil)
+      @method = method
+      @params = params
+      @id = id
+    end
+
+    def to_h
+      h = {
+        'jsonrpc' => '2.0',
+        'method'  => @method
+      }
+      h.merge!('params' => @params) if !!@params && !params.empty?
+      h.merge!('id' => id)
+    end
+
+    def to_json(*a)
+      MultiJson.encode(self.to_h)
+    end
+
+  end
+end

data/lib/sr/jimson/response.rb

@@ -0,0 +1,30 @@
+module Sr::Jimson
+  class Response
+    attr_accessor :result, :error, :id
+
+    def initialize(id)
+      @id = id
+    end
+
+    def to_h
+      h = {'jsonrpc' => '2.0'}
+      h.merge!('result' => @result) if !!@result
+      h.merge!('error' => @error) if !!@error
+      h.merge!('id' => @id)
+    end
+
+    def is_error?
+      !!@error
+    end
+
+    def succeeded?
+      !!@result
+    end
+
+    def populate!(data)
+      @error = data['error'] if !!data['error']
+      @result = data['result'] if !!data['result']
+    end
+
+  end
+end

data/lib/sr/jimson/router.rb

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

data/lib/sr/jimson/router/map.rb

@@ -0,0 +1,75 @@
+module Sr::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 = Sr::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?(Sr::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?(Sr::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/sr/jimson/server.rb

@@ -0,0 +1,224 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'multi_json'
+require 'sr/jimson/handler'
+require 'sr/jimson/router'
+require 'sr/jimson/server/error'
+
+module Sr::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 Sr::Jimson::Router or extends Sr::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)
+      MultiJson.decode(post)
+    rescue
+      raise Server::Error::ParseError.new
+    end
+  end
+end

data/lib/sr/jimson/server/error.rb

@@ -0,0 +1,66 @@
+module Sr::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