cosmos 3.5.1 → 3.5.2

data/lib/cosmos/io/json_drb_object.rb

@@ -1,198 +1,198 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU Lesser General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos'
-require 'thread'
-require 'socket'
-require 'json'
-require 'drb/acl'
-require 'drb/drb'
-require 'cosmos/io/json_drb'
-
-module Cosmos
-
-  # Used to forward all method calls to the remote server object. Before using
-  # this class ensure the remote service has been started in the server class:
-  #
-  #   json = JsonDrb.new
-  #   json.start_service('127.0.0.1', 7777, self)
-  #
-  # Now the JsonDRbObject can be used to call server methods directly:
-  #
-  #   server = JsonDRbObject('127.0.0.1', 7777)
-  #   server.cmd(*args)
-  #
-  class JsonDRbObject
-    # @param hostname [String] The name of the machine which has started
-    #   the JSON service
-    # @param port [Integer] The port number of the JSON service
-    def initialize(hostname, port, connect_timeout = 1.0)
-      hostname = '127.0.0.1' if (hostname.to_s.upcase == 'LOCALHOST')
-      begin
-        @addr = Socket.pack_sockaddr_in(port, hostname)
-      rescue => error
-        if error.message =~ /getaddrinfo/
-          raise "Invalid hostname: #{hostname}"
-        else
-          raise error
-        end
-      end
-      @hostname = hostname
-      @port = port
-      @mutex = Mutex.new
-      @socket = nil
-      @id = 0
-      @request_in_progress = false
-      @connect_timeout = connect_timeout
-      @connect_timeout = @connect_timeout.to_f if @connect_timeout
-      @shutdown = false
-    end
-
-    # Disconnects from the JSON server
-    def disconnect
-      Cosmos.close_socket(@socket)
-      # Cannot set @socket to nil here because this method can be called by
-      # other threads and @socket being nil would cause unexpected errors in method_missing
-      # Also don't want to take the mutex so that we can interrupt method_missing if necessary
-      # Only method_missing can set @socket to nil
-    end
-
-    # Permanently disconnects from the JSON server
-    def shutdown
-      @shutdown = true
-      disconnect()
-    end
-
-    # Forwards all method calls to the remote service.
-    #
-    # @param method_name [Symbol] Name of the method to call
-    # @param method_params [Array] Array of parameters to pass to the method
-    # @return The result of the method call. If the method raises an exception
-    #   the same exception is also raised. If something goes wrong with the
-    #   protocol a DRb::DRbConnError exception is raised.
-    def method_missing(method_name, *method_params)
-      @mutex.synchronize do
-        # This flag and loop are used to automatically reconnect and retry if something goes
-        # wrong on the first attempt writing to the socket.   Sockets can become disconnected
-        # between function calls, but as long as the remote server is back up and running the
-        # call should succeed even when it discovers a broken socket on the first attempt.
-        first_try = true
-        loop do
-          raise DRb::DRbConnError, "Shutdown" if @shutdown
-          connect() if !@socket or @socket.closed? or @request_in_progress
-
-          response = make_request(method_name, method_params, first_try)
-          unless response
-            disconnect()
-            @socket = nil
-            was_first_try = first_try
-            first_try = false
-            next if was_first_try
-          end
-          return handle_response(response)
-        end # loop
-      end # @mutex.synchronize
-    end # def method_missing
-
-    private
-
-    def connect
-      if @request_in_progress
-        disconnect()
-        @socket = nil
-        @request_in_progress = false
-      end
-      begin
-        addr = Socket.pack_sockaddr_in(@port, @hostname)
-        @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-        @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        begin
-          @socket.connect_nonblock(addr)
-        rescue IO::WaitWritable
-          begin
-            _, sockets, _ = IO.select(nil, [@socket], nil, @connect_timeout) # wait 3-way handshake completion
-          rescue IOError, Errno::ENOTSOCK
-            disconnect()
-            @socket = nil
-            raise "Connect canceled"
-          end
-          if sockets and !sockets.empty?
-            begin
-              @socket.connect_nonblock(addr) # check connection failure
-            rescue IOError, Errno::ENOTSOCK
-              disconnect()
-              @socket = nil
-              raise "Connect canceled"
-            rescue Errno::EINPROGRESS
-              retry
-            rescue Errno::EISCONN, Errno::EALREADY
-            end
-          else
-            disconnect()
-            @socket = nil
-            raise "Connect timeout"
-          end
-        rescue IOError, Errno::ENOTSOCK
-          disconnect()
-          @socket = nil
-          raise "Connect canceled"
-        end
-      rescue => e
-        raise DRb::DRbConnError, e.message
-      end
-    end
-
-    def make_request(method_name, method_params, first_try)
-      request = JsonRpcRequest.new(method_name, method_params, @id)
-      @id += 1
-
-      request_data = request.to_json(:allow_nan => true)
-      begin
-        STDOUT.puts "Request:\n" if JsonDRb.debug?
-        STDOUT.puts request_data if JsonDRb.debug?
-        @request_in_progress = true
-        JsonDRb.send_data(@socket, request_data)
-        response_data = JsonDRb.receive_message(@socket, '')
-        @request_in_progress = false
-        STDOUT.puts "\nResponse:\n" if JsonDRb.debug?
-        STDOUT.puts response_data if JsonDRb.debug?
-      rescue => e
-        disconnect()
-        @socket = nil
-        return false if first_try
-        raise DRb::DRbConnError, e.message, e.backtrace
-      end
-      response_data
-    end
-
-    def handle_response(response_data)
-      # The code below will always either raise or return breaking out of the loop
-      if response_data
-        response = JsonRpcResponse.from_json(response_data)
-        if JsonRpcErrorResponse === response
-          if response.error.data
-            raise Exception.from_hash(response.error.data)
-          else
-            raise "JsonDRb Error (#{response.error.code}): #{response.error.message}"
-          end
-        else
-          return response.result
-        end
-      else
-        # Socket was closed by server
-        disconnect()
-        @socket = nil
-        raise DRb::DRbConnError, "Socket closed by server"
-      end
-    end
-
-  end # class JsonDRbObject
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Lesser General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'thread'
+require 'socket'
+require 'json'
+require 'drb/acl'
+require 'drb/drb'
+require 'cosmos/io/json_drb'
+
+module Cosmos
+
+  # Used to forward all method calls to the remote server object. Before using
+  # this class ensure the remote service has been started in the server class:
+  #
+  #   json = JsonDrb.new
+  #   json.start_service('127.0.0.1', 7777, self)
+  #
+  # Now the JsonDRbObject can be used to call server methods directly:
+  #
+  #   server = JsonDRbObject('127.0.0.1', 7777)
+  #   server.cmd(*args)
+  #
+  class JsonDRbObject
+    # @param hostname [String] The name of the machine which has started
+    #   the JSON service
+    # @param port [Integer] The port number of the JSON service
+    def initialize(hostname, port, connect_timeout = 1.0)
+      hostname = '127.0.0.1' if (hostname.to_s.upcase == 'LOCALHOST')
+      begin
+        @addr = Socket.pack_sockaddr_in(port, hostname)
+      rescue => error
+        if error.message =~ /getaddrinfo/
+          raise "Invalid hostname: #{hostname}"
+        else
+          raise error
+        end
+      end
+      @hostname = hostname
+      @port = port
+      @mutex = Mutex.new
+      @socket = nil
+      @id = 0
+      @request_in_progress = false
+      @connect_timeout = connect_timeout
+      @connect_timeout = @connect_timeout.to_f if @connect_timeout
+      @shutdown = false
+    end
+
+    # Disconnects from the JSON server
+    def disconnect
+      Cosmos.close_socket(@socket)
+      # Cannot set @socket to nil here because this method can be called by
+      # other threads and @socket being nil would cause unexpected errors in method_missing
+      # Also don't want to take the mutex so that we can interrupt method_missing if necessary
+      # Only method_missing can set @socket to nil
+    end
+
+    # Permanently disconnects from the JSON server
+    def shutdown
+      @shutdown = true
+      disconnect()
+    end
+
+    # Forwards all method calls to the remote service.
+    #
+    # @param method_name [Symbol] Name of the method to call
+    # @param method_params [Array] Array of parameters to pass to the method
+    # @return The result of the method call. If the method raises an exception
+    #   the same exception is also raised. If something goes wrong with the
+    #   protocol a DRb::DRbConnError exception is raised.
+    def method_missing(method_name, *method_params)
+      @mutex.synchronize do
+        # This flag and loop are used to automatically reconnect and retry if something goes
+        # wrong on the first attempt writing to the socket.   Sockets can become disconnected
+        # between function calls, but as long as the remote server is back up and running the
+        # call should succeed even when it discovers a broken socket on the first attempt.
+        first_try = true
+        loop do
+          raise DRb::DRbConnError, "Shutdown" if @shutdown
+          connect() if !@socket or @socket.closed? or @request_in_progress
+
+          response = make_request(method_name, method_params, first_try)
+          unless response
+            disconnect()
+            @socket = nil
+            was_first_try = first_try
+            first_try = false
+            next if was_first_try
+          end
+          return handle_response(response)
+        end # loop
+      end # @mutex.synchronize
+    end # def method_missing
+
+    private
+
+    def connect
+      if @request_in_progress
+        disconnect()
+        @socket = nil
+        @request_in_progress = false
+      end
+      begin
+        addr = Socket.pack_sockaddr_in(@port, @hostname)
+        @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        begin
+          @socket.connect_nonblock(addr)
+        rescue IO::WaitWritable
+          begin
+            _, sockets, _ = IO.select(nil, [@socket], nil, @connect_timeout) # wait 3-way handshake completion
+          rescue IOError, Errno::ENOTSOCK
+            disconnect()
+            @socket = nil
+            raise "Connect canceled"
+          end
+          if sockets and !sockets.empty?
+            begin
+              @socket.connect_nonblock(addr) # check connection failure
+            rescue IOError, Errno::ENOTSOCK
+              disconnect()
+              @socket = nil
+              raise "Connect canceled"
+            rescue Errno::EINPROGRESS
+              retry
+            rescue Errno::EISCONN, Errno::EALREADY
+            end
+          else
+            disconnect()
+            @socket = nil
+            raise "Connect timeout"
+          end
+        rescue IOError, Errno::ENOTSOCK
+          disconnect()
+          @socket = nil
+          raise "Connect canceled"
+        end
+      rescue => e
+        raise DRb::DRbConnError, e.message
+      end
+    end
+
+    def make_request(method_name, method_params, first_try)
+      request = JsonRpcRequest.new(method_name, method_params, @id)
+      @id += 1
+
+      request_data = request.to_json(:allow_nan => true)
+      begin
+        STDOUT.puts "Request:\n" if JsonDRb.debug?
+        STDOUT.puts request_data if JsonDRb.debug?
+        @request_in_progress = true
+        JsonDRb.send_data(@socket, request_data)
+        response_data = JsonDRb.receive_message(@socket, '')
+        @request_in_progress = false
+        STDOUT.puts "\nResponse:\n" if JsonDRb.debug?
+        STDOUT.puts response_data if JsonDRb.debug?
+      rescue => e
+        disconnect()
+        @socket = nil
+        return false if first_try
+        raise DRb::DRbConnError, e.message, e.backtrace
+      end
+      response_data
+    end
+
+    def handle_response(response_data)
+      # The code below will always either raise or return breaking out of the loop
+      if response_data
+        response = JsonRpcResponse.from_json(response_data)
+        if JsonRpcErrorResponse === response
+          if response.error.data
+            raise Exception.from_hash(response.error.data)
+          else
+            raise "JsonDRb Error (#{response.error.code}): #{response.error.message}"
+          end
+        else
+          return response.result
+        end
+      else
+        # Socket was closed by server
+        disconnect()
+        @socket = nil
+        raise DRb::DRbConnError, "Socket closed by server"
+      end
+    end
+
+  end # class JsonDRbObject
+
+end # module Cosmos

data/lib/cosmos/io/json_rpc.rb

@@ -1,365 +1,365 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU Lesser General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'json'
-
-class Object
-  def as_json(options = nil) #:nodoc:
-    if respond_to?(:to_hash)
-      to_hash
-    else
-      instance_variables
-    end
-  end
-end
-
-class Struct #:nodoc:
-  def as_json(options = nil)
-    pairs = []
-    self.each_pair { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
-    Hash[*pairs]
-  end
-end
-
-class TrueClass
-  def as_json(options = nil) self end #:nodoc:
-end
-
-class FalseClass
-  def as_json(options = nil) self end #:nodoc:
-end
-
-class NilClass
-  def as_json(options = nil) self end #:nodoc:
-end
-
-class String
-  NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
-
-  def as_json(options = nil)
-    if self =~ NON_ASCII_PRINTABLE
-      self.to_json_raw_object
-    else
-      self
-    end
-  end #:nodoc:
-end
-
-class Symbol
-  def as_json(options = nil) to_s end #:nodoc:
-end
-
-class Numeric
-  def as_json(options = nil) self end #:nodoc:
-end
-
-class Regexp
-  def as_json(options = nil) to_s end #:nodoc:
-end
-
-module Enumerable
-  def as_json(options = nil) #:nodoc:
-    to_a.as_json(options)
-  end
-end
-
-class Array
-  def as_json(options = nil) #:nodoc:
-    map { |v| v.as_json(options) }
-  end
-end
-
-class Hash
-  def as_json(options = nil) #:nodoc:
-    pairs = []
-    self.each { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
-    Hash[*pairs]
-  end
-end
-
-class Time
-  def as_json(options = nil) #:nodoc:
-    to_json(options).remove_quotes
-  end
-end
-
-class Date
-  def as_json(options = nil) #:nodoc:
-    to_json(options).remove_quotes
-  end
-end
-
-class DateTime
-  def as_json(options = nil) #:nodoc:
-    to_json(options).remove_quotes
-  end
-end
-
-class Exception
-  def as_json(*a)
-    hash = {}
-    hash['class'] = self.class.name
-    hash['message'] = self.message
-    hash['backtrace'] = self.backtrace
-    instance_vars = {}
-    self.instance_variables.each do |instance_var_name|
-      instance_vars[instance_var_name.to_s] = self.instance_variable_get(instance_var_name.to_s.intern)
-    end
-    hash['instance_variables'] = instance_vars
-    hash.as_json(*a)
-  end
-
-  def to_json(*a)
-    as_json(*a).to_json(*a)
-  end
-
-  def self.from_hash(hash)
-    begin
-      # Get Error class handling namespaced constants
-      split_error_class_name = hash['class'].split("::")
-      error_class = Object
-      split_error_class_name.each do |name|
-        error_class = error_class.const_get(name)
-      end
-    rescue
-      error = Cosmos::JsonDRbUnknownError.new(hash['message'])
-      error.set_backtrace(hash['backtrace'].concat(caller()))
-      raise error
-    end
-    error = error_class.new(hash['message'])
-    error.set_backtrace(hash['backtrace'].concat(caller())) if hash['backtrace']
-    hash['instance_variables'].each do |name, value|
-      error.instance_variable_set(name.intern, value)
-    end
-    error
-  end
-end
-
-module Cosmos
-  # An unknown JSON DRb error which can be re-raised by Exception
-  class JsonDRbUnknownError < StandardError; end
-
-  # Base class for all JSON Remote Procedure Calls. Provides basic
-  # comparison and Hash to JSON conversions.
-  class JsonRpc
-    include Comparable
-
-    def initialize
-      @hash = {}
-    end
-
-    # @param other [JsonRpc] Another JsonRpc to compare hash values with
-    def <=>(other)
-      self.as_json <=> other.as_json
-    end
-
-    # @param a [Array] Array of options
-    # @return [Hash] Hash representing the object
-    def as_json(*a)
-      @hash.as_json(*a)
-    end
-
-    # @param a [Array] Array of options
-    # @return [String] The JSON encoded String
-    def to_json(*a)
-      as_json(*a).to_json(*a)
-    end
-  end
-
-  # Represents a JSON Remote Procedure Call Request
-  class JsonRpcRequest < JsonRpc
-    DANGEROUS_METHODS = ['__send__', 'send', 'instance_eval', 'instance_exec']
-
-    # @param method_name [String] The name of the method to call
-    # @param method_params [Array<String>] Array of strings which represent the
-    #   parameters to send to the method
-    # @param id [Integer] The identifier which will be matched to the response
-    def initialize(method_name, method_params, id)
-      super()
-      @hash['jsonrpc'.freeze] = "2.0".freeze
-      @hash['method'.freeze] = method_name.to_s
-      if method_params and method_params.length != 0
-        @hash['params'.freeze] = method_params
-      end
-      @hash['id'.freeze] = id.to_i
-    end
-
-    # @return [String] The method to call
-    def method
-      @hash['method'.freeze]
-    end
-
-    # @return [Array<String>] Array of strings which represent the
-    #   parameters to send to the method
-    def params
-      @hash['params'.freeze] || []
-    end
-
-    # @return [Integer] The request identifier
-    def id
-      @hash['id'.freeze]
-    end
-
-    # Creates a JsonRpcRequest object from a JSON encoded String. The version
-    # must be 2.0 and the JSON must include the method and id members.
-    #
-    # @param request_data [String] JSON encoded string representing the request
-    # @return [JsonRpcRequest]
-    def self.from_json(request_data)
-      begin
-        hash = JSON.parse(request_data, :allow_nan => true, :create_additions => true)
-        # Verify the jsonrpc version is correct and there is a method and id
-        raise unless (hash['jsonrpc'.freeze] == "2.0".freeze && hash['method'.freeze] && hash['id'.freeze])
-        self.from_hash(hash)
-      rescue
-        raise "Invalid JSON-RPC 2.0 Request"
-      end
-    end
-
-    # Creates a JsonRpcRequest object from a Hash
-    #
-    # @param hash [Hash] Hash containing the following keys: method, params,
-    #   and id
-    # @return [JsonRpcRequest]
-    def self.from_hash(hash)
-      self.new(hash['method'.freeze], hash['params'.freeze], hash['id'.freeze])
-    end
-  end
-
-  # Represents a JSON Remote Procedure Call Response
-  class JsonRpcResponse < JsonRpc
-
-    # @param id [Integer] The identifier which will be matched to the request
-    def initialize(id)
-      super()
-      @hash['jsonrpc'.freeze] = "2.0".freeze
-      @hash['id'.freeze] = id
-    end
-
-    # Creates a JsonRpcResponse object from a JSON encoded String. The version
-    # must be 2.0 and the JSON must include the id members. It must also
-    # include either result for success or error for failure but never both.
-    #
-    # @param response_data [String] JSON encoded string representing the response
-    # @return [JsonRpcResponse]
-    def self.from_json(response_data)
-      msg = "Invalid JSON-RPC 2.0 Response"
-      begin
-        hash = JSON.parse(response_data, :allow_nan => true, :create_additions => true)
-      rescue
-        raise msg
-      end
-
-      # Verify the jsonrpc version is correct and there is an ID
-      raise msg unless hash['jsonrpc'.freeze] == "2.0".freeze and hash.key?('id'.freeze)
-      # If there is a result this is probably a good response
-      if hash.key?('result'.freeze)
-        # Can't have an error key in a good response
-        raise msg if hash.key?('error'.freeze)
-        JsonRpcSuccessResponse.from_hash(hash)
-      elsif hash.key?('error'.freeze)
-        # There was an error key so create an error response
-        JsonRpcErrorResponse.from_hash(hash)
-      else
-        # Neither a result or error key so raise exception
-        raise msg
-      end
-    end
-  end
-
-  # Represents a JSON Remote Procedure Call Success Response
-  class JsonRpcSuccessResponse < JsonRpcResponse
-
-    # @param id [Integer] The identifier which will be matched to the request
-    def initialize(result, id)
-      super(id)
-      @hash['result'.freeze] = result
-    end
-
-    # @return [Object] The result of the method request
-    def result
-      @hash['result'.freeze]
-    end
-
-    # Creates a JsonRpcSuccessResponse object from a Hash
-    #
-    # @param hash [Hash] Hash containing the following keys: result and id
-    # @return [JsonRpcSuccessResponse]
-    def self.from_hash(hash)
-      self.new(hash['result'.freeze], hash['id'.freeze])
-    end
-  end
-
-  # Represents a JSON Remote Procedure Call Error Response
-  class JsonRpcErrorResponse < JsonRpcResponse
-
-    # @param error [JsonRpcError] The error object
-    # @param id [Integer] The identifier which will be matched to the request
-    def initialize(error, id)
-      super(id)
-      @hash['error'.freeze] = error
-    end
-
-    # @return [JsonRpcError] The error object
-    def error
-      @hash['error'.freeze]
-    end
-
-    # Creates a JsonRpcErrorResponse object from a Hash
-    #
-    # @param hash [Hash] Hash containing the following keys: error and id
-    # @return [JsonRpcErrorResponse]
-    def self.from_hash(hash)
-      self.new(JsonRpcError.from_hash(hash['error'.freeze]), hash['id'.freeze])
-    end
-  end
-
-  # Represents a JSON Remote Procedure Call Error
-  class JsonRpcError < JsonRpc
-
-    # @param code [Integer] The error type that occurred
-    # @param message [String] A short description of the error
-    # @param data [Hash] Additional information about the error
-    def initialize(code, message, data = nil)
-      super()
-      @hash['code'] = code
-      @hash['message'] = message
-      @hash['data'] = data
-    end
-
-    # @return [Integer] The error type that occurred
-    def code
-      @hash['code']
-    end
-
-    # @return [String] A short description of the error
-    def message
-      @hash['message']
-    end
-
-    # @return [Hash] Additional information about the error
-    def data
-      @hash['data']
-    end
-
-    # Creates a JsonRpcError object from a Hash
-    #
-    # @param hash [Hash] Hash containing the following keys: code, message, and
-    #   optionally data
-    # @return [JsonRpcError]
-    def self.from_hash(hash)
-      if hash['code'] and (hash['code'].to_i == hash['code']) and hash['message']
-        self.new(hash['code'], hash['message'], hash['data'])
-      else
-        raise "Invalid JSON-RPC 2.0 Error"
-      end
-    end
-  end
-end
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Lesser General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'json'
+
+class Object
+  def as_json(options = nil) #:nodoc:
+    if respond_to?(:to_hash)
+      to_hash
+    else
+      instance_variables
+    end
+  end
+end
+
+class Struct #:nodoc:
+  def as_json(options = nil)
+    pairs = []
+    self.each_pair { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
+    Hash[*pairs]
+  end
+end
+
+class TrueClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class FalseClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class NilClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class String
+  NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
+
+  def as_json(options = nil)
+    if self =~ NON_ASCII_PRINTABLE
+      self.to_json_raw_object
+    else
+      self
+    end
+  end #:nodoc:
+end
+
+class Symbol
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+class Numeric
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class Regexp
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+module Enumerable
+  def as_json(options = nil) #:nodoc:
+    to_a.as_json(options)
+  end
+end
+
+class Array
+  def as_json(options = nil) #:nodoc:
+    map { |v| v.as_json(options) }
+  end
+end
+
+class Hash
+  def as_json(options = nil) #:nodoc:
+    pairs = []
+    self.each { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
+    Hash[*pairs]
+  end
+end
+
+class Time
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class Date
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class DateTime
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class Exception
+  def as_json(*a)
+    hash = {}
+    hash['class'] = self.class.name
+    hash['message'] = self.message
+    hash['backtrace'] = self.backtrace
+    instance_vars = {}
+    self.instance_variables.each do |instance_var_name|
+      instance_vars[instance_var_name.to_s] = self.instance_variable_get(instance_var_name.to_s.intern)
+    end
+    hash['instance_variables'] = instance_vars
+    hash.as_json(*a)
+  end
+
+  def to_json(*a)
+    as_json(*a).to_json(*a)
+  end
+
+  def self.from_hash(hash)
+    begin
+      # Get Error class handling namespaced constants
+      split_error_class_name = hash['class'].split("::")
+      error_class = Object
+      split_error_class_name.each do |name|
+        error_class = error_class.const_get(name)
+      end
+    rescue
+      error = Cosmos::JsonDRbUnknownError.new(hash['message'])
+      error.set_backtrace(hash['backtrace'].concat(caller()))
+      raise error
+    end
+    error = error_class.new(hash['message'])
+    error.set_backtrace(hash['backtrace'].concat(caller())) if hash['backtrace']
+    hash['instance_variables'].each do |name, value|
+      error.instance_variable_set(name.intern, value)
+    end
+    error
+  end
+end
+
+module Cosmos
+  # An unknown JSON DRb error which can be re-raised by Exception
+  class JsonDRbUnknownError < StandardError; end
+
+  # Base class for all JSON Remote Procedure Calls. Provides basic
+  # comparison and Hash to JSON conversions.
+  class JsonRpc
+    include Comparable
+
+    def initialize
+      @hash = {}
+    end
+
+    # @param other [JsonRpc] Another JsonRpc to compare hash values with
+    def <=>(other)
+      self.as_json <=> other.as_json
+    end
+
+    # @param a [Array] Array of options
+    # @return [Hash] Hash representing the object
+    def as_json(*a)
+      @hash.as_json(*a)
+    end
+
+    # @param a [Array] Array of options
+    # @return [String] The JSON encoded String
+    def to_json(*a)
+      as_json(*a).to_json(*a)
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Request
+  class JsonRpcRequest < JsonRpc
+    DANGEROUS_METHODS = ['__send__', 'send', 'instance_eval', 'instance_exec']
+
+    # @param method_name [String] The name of the method to call
+    # @param method_params [Array<String>] Array of strings which represent the
+    #   parameters to send to the method
+    # @param id [Integer] The identifier which will be matched to the response
+    def initialize(method_name, method_params, id)
+      super()
+      @hash['jsonrpc'.freeze] = "2.0".freeze
+      @hash['method'.freeze] = method_name.to_s
+      if method_params and method_params.length != 0
+        @hash['params'.freeze] = method_params
+      end
+      @hash['id'.freeze] = id.to_i
+    end
+
+    # @return [String] The method to call
+    def method
+      @hash['method'.freeze]
+    end
+
+    # @return [Array<String>] Array of strings which represent the
+    #   parameters to send to the method
+    def params
+      @hash['params'.freeze] || []
+    end
+
+    # @return [Integer] The request identifier
+    def id
+      @hash['id'.freeze]
+    end
+
+    # Creates a JsonRpcRequest object from a JSON encoded String. The version
+    # must be 2.0 and the JSON must include the method and id members.
+    #
+    # @param request_data [String] JSON encoded string representing the request
+    # @return [JsonRpcRequest]
+    def self.from_json(request_data)
+      begin
+        hash = JSON.parse(request_data, :allow_nan => true, :create_additions => true)
+        # Verify the jsonrpc version is correct and there is a method and id
+        raise unless (hash['jsonrpc'.freeze] == "2.0".freeze && hash['method'.freeze] && hash['id'.freeze])
+        self.from_hash(hash)
+      rescue
+        raise "Invalid JSON-RPC 2.0 Request"
+      end
+    end
+
+    # Creates a JsonRpcRequest object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: method, params,
+    #   and id
+    # @return [JsonRpcRequest]
+    def self.from_hash(hash)
+      self.new(hash['method'.freeze], hash['params'.freeze], hash['id'.freeze])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Response
+  class JsonRpcResponse < JsonRpc
+
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(id)
+      super()
+      @hash['jsonrpc'.freeze] = "2.0".freeze
+      @hash['id'.freeze] = id
+    end
+
+    # Creates a JsonRpcResponse object from a JSON encoded String. The version
+    # must be 2.0 and the JSON must include the id members. It must also
+    # include either result for success or error for failure but never both.
+    #
+    # @param response_data [String] JSON encoded string representing the response
+    # @return [JsonRpcResponse]
+    def self.from_json(response_data)
+      msg = "Invalid JSON-RPC 2.0 Response"
+      begin
+        hash = JSON.parse(response_data, :allow_nan => true, :create_additions => true)
+      rescue
+        raise msg
+      end
+
+      # Verify the jsonrpc version is correct and there is an ID
+      raise msg unless hash['jsonrpc'.freeze] == "2.0".freeze and hash.key?('id'.freeze)
+      # If there is a result this is probably a good response
+      if hash.key?('result'.freeze)
+        # Can't have an error key in a good response
+        raise msg if hash.key?('error'.freeze)
+        JsonRpcSuccessResponse.from_hash(hash)
+      elsif hash.key?('error'.freeze)
+        # There was an error key so create an error response
+        JsonRpcErrorResponse.from_hash(hash)
+      else
+        # Neither a result or error key so raise exception
+        raise msg
+      end
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Success Response
+  class JsonRpcSuccessResponse < JsonRpcResponse
+
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(result, id)
+      super(id)
+      @hash['result'.freeze] = result
+    end
+
+    # @return [Object] The result of the method request
+    def result
+      @hash['result'.freeze]
+    end
+
+    # Creates a JsonRpcSuccessResponse object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: result and id
+    # @return [JsonRpcSuccessResponse]
+    def self.from_hash(hash)
+      self.new(hash['result'.freeze], hash['id'.freeze])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Error Response
+  class JsonRpcErrorResponse < JsonRpcResponse
+
+    # @param error [JsonRpcError] The error object
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(error, id)
+      super(id)
+      @hash['error'.freeze] = error
+    end
+
+    # @return [JsonRpcError] The error object
+    def error
+      @hash['error'.freeze]
+    end
+
+    # Creates a JsonRpcErrorResponse object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: error and id
+    # @return [JsonRpcErrorResponse]
+    def self.from_hash(hash)
+      self.new(JsonRpcError.from_hash(hash['error'.freeze]), hash['id'.freeze])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Error
+  class JsonRpcError < JsonRpc
+
+    # @param code [Integer] The error type that occurred
+    # @param message [String] A short description of the error
+    # @param data [Hash] Additional information about the error
+    def initialize(code, message, data = nil)
+      super()
+      @hash['code'] = code
+      @hash['message'] = message
+      @hash['data'] = data
+    end
+
+    # @return [Integer] The error type that occurred
+    def code
+      @hash['code']
+    end
+
+    # @return [String] A short description of the error
+    def message
+      @hash['message']
+    end
+
+    # @return [Hash] Additional information about the error
+    def data
+      @hash['data']
+    end
+
+    # Creates a JsonRpcError object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: code, message, and
+    #   optionally data
+    # @return [JsonRpcError]
+    def self.from_hash(hash)
+      if hash['code'] and (hash['code'].to_i == hash['code']) and hash['message']
+        self.new(hash['code'], hash['message'], hash['data'])
+      else
+        raise "Invalid JSON-RPC 2.0 Error"
+      end
+    end
+  end
+end