cosmos 4.0.3-java

data/lib/cosmos/io/json_drb_object.rb

@@ -0,0 +1,201 @@
+# 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
+      @pipe_reader, @pipe_writer = IO.pipe
+      @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)
+      @pipe_writer.write('.')
+      # 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
+      end
+    end
+
+    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)
+        @pipe_reader, @pipe_writer = IO.pipe
+        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, '', @pipe_reader)
+        @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

@@ -0,0 +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