cosmos 4.0.3 → 4.1.0

data/lib/cosmos/io/json_drb_object.rb

@@ -15,6 +15,8 @@ require 'json'
 require 'drb/acl'
 require 'drb/drb'
 require 'cosmos/io/json_drb'
+require 'uri'
+require 'httpclient'
 
 module Cosmos
 
@@ -36,7 +38,7 @@ module Cosmos
     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)
+        addr = Socket.pack_sockaddr_in(port, hostname)
       rescue => error
         if error.message =~ /getaddrinfo/
           raise "Invalid hostname: #{hostname}"
@@ -46,9 +48,9 @@ module Cosmos
       end
       @hostname = hostname
       @port = port
+      @uri = URI("http://#{@hostname}:#{@port}")
+      @http = nil
       @mutex = Mutex.new
-      @socket = nil
-      @pipe_reader, @pipe_writer = IO.pipe
       @id = 0
       @request_in_progress = false
       @connect_timeout = connect_timeout
@@ -56,17 +58,12 @@ module Cosmos
       @shutdown = false
     end
 
-    # Disconnects from the JSON server
+    # Disconnects from http 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
+      @http.reset_all if @http
     end
 
-    # Permanently disconnects from the JSON server
+    # Permanently disconnects from the http server
     def shutdown
       @shutdown = true
       disconnect()
@@ -81,19 +78,14 @@ module Cosmos
     #   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
+          connect() if !@http 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
@@ -108,44 +100,13 @@ module Cosmos
     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"
+        if !@http
+          @http = HTTPClient.new
+          @http.connect_timeout = @connect_timeout
+          @http.receive_timeout = nil # Allow long polling
         end
       rescue => e
         raise DRb::DRbConnError, e.message
@@ -158,17 +119,19 @@ module Cosmos
 
       request_data = request.to_json(:allow_nan => true)
       begin
-        STDOUT.puts "Request:\n" if JsonDRb.debug?
+        STDOUT.puts "\nRequest:\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)
+        headers = {'Content-Type' => 'application/json-rpc'}
+        res = @http.post(@uri,
+                         :body   => request_data,
+                         :header => headers)
+        response_data = res.body
         @request_in_progress = false
-        STDOUT.puts "\nResponse:\n" if JsonDRb.debug?
+        STDOUT.puts "Response:\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
@@ -177,7 +140,7 @@ module Cosmos
 
     def handle_response(response_data)
       # The code below will always either raise or return breaking out of the loop
-      if response_data
+      if response_data and response_data.to_s.length > 0
         response = JsonRpcResponse.from_json(response_data)
         if JsonRpcErrorResponse === response
           if response.error.data
@@ -189,10 +152,8 @@ module Cosmos
           return response.result
         end
       else
-        # Socket was closed by server
         disconnect()
-        @socket = nil
-        raise DRb::DRbConnError, "Socket closed by server"
+        raise DRb::DRbConnError, "No response from server"
       end
     end
 

data/lib/cosmos/io/json_drb_rack.rb

@@ -0,0 +1,79 @@
+# encoding: ascii-8bit
+
+# Copyright 2017 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'rack'
+
+module Cosmos
+
+  # JsonDrbRack implements a rack application that can be served by a
+  # webserver to process COSMOS json_drb requests via http.
+  class JsonDrbRack
+    # @param drb [JsonDRb] - An instance of the JsonDRb class that'll be used
+    #   to process the JSON request and generate a response
+    def initialize(drb)
+      @drb = drb
+    end
+
+    # Handles a request.
+    #
+    # @param env [Hash] - A rack env hash, can be turned into a Rack::Request
+    # @return [Integer, Hash, [String]] - Http response code, content headers,
+    #   response body
+    def call(env)
+      request = Rack::Request.new(env)
+
+      # ACL allow_addr? function takes address in the form returned by
+      # IPSocket.peeraddr.
+      req_addr = ["AF_INET", request.port, request.host.to_s, request.ip.to_s]
+
+      if @drb.acl and !@drb.acl.allow_addr?(req_addr)
+        status       = 403
+        content_type = "text/plain"
+        body         = "Forbidden"
+      elsif request.post?
+        status, content_type, body = handle_post(request)
+      else
+        status       = 405
+        content_type = "text/plain"
+        body         = "Request not allowed"
+      end
+  
+      return status, {'Content-Type' => content_type}, [body]
+    end
+    
+    # Handles an http post.
+    #
+    # @param request [Rack::Request] - A rack post request
+    # @return [Integer, String, String] - Http response code, content type,
+    #   response body.
+    def handle_post(request)
+      request_data = request.body.read
+      start_time = Time.now.sys
+      response_data, error_code = @drb.process_request(request_data, start_time)
+  
+      # Convert json error code into html status code
+      # see http://www.jsonrpc.org/historical/json-rpc-over-http.html#errors
+      if error_code
+        case error_code
+          when JsonRpcError::ErrorCode::PARSE_ERROR      then status = 500 # Internal server error
+          when JsonRpcError::ErrorCode::INVALID_REQUEST  then status = 400 # Bad request
+          when JsonRpcError::ErrorCode::METHOD_NOT_FOUND then status = 404 # Not found
+          when JsonRpcError::ErrorCode::INVALID_PARAMS   then status = 500 # Internal server error
+          when JsonRpcError::ErrorCode::INTERNAL_ERROR   then status = 500 # Internal server error
+          else status = 500 # Internal server error
+        end
+      else
+        status = 200 # OK
+      end
+
+      return status, "application/json-rpc", response_data
+    end
+  end
+end

data/lib/cosmos/io/json_rpc.rb

@@ -60,6 +60,23 @@ class Numeric
   def as_json(options = nil) self end #:nodoc:
 end
 
+class Float
+  def self.json_create(object)
+    case object['raw']
+      when "Infinity"  then  Float::INFINITY
+      when "-Infinity" then -Float::INFINITY
+      when "NaN"       then  Float::NAN
+    end
+  end
+
+  def as_json(options = nil)
+    return {"json_class"=>Float, "raw"=>"Infinity"}  if self.infinite? ==  1
+    return {"json_class"=>Float, "raw"=>"-Infinity"} if self.infinite? == -1
+    return {"json_class"=>Float, "raw"=>"NaN"}       if self.nan?
+    return self
+  end
+end
+
 class Regexp
   def as_json(options = nil) to_s end #:nodoc:
 end
@@ -324,6 +341,16 @@ module Cosmos
   # Represents a JSON Remote Procedure Call Error
   class JsonRpcError < JsonRpc
 
+    # Enumeration of JSON RPC error codes
+    class ErrorCode
+      PARSE_ERROR      = -32700
+      INVALID_REQUEST  = -32600
+      METHOD_NOT_FOUND = -32601
+      INVALID_PARAMS   = -32602
+      INTERNAL_ERROR   = -32603
+      OTHER_ERROR      = -1
+    end
+
     # @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

data/lib/cosmos/io/udp_sockets.rb

@@ -18,38 +18,55 @@ Socket::IP_MULTICAST_TTL = 10 unless Socket.const_defined?('IP_MULTICAST_TTL')
 
 module Cosmos
 
-  # Creates a UDPSocket and implements a non-blocking write.
-  class UdpWriteSocket
+  class UdpReadWriteSocket
+    # @param bind_port [Integer[ Port to write data out from and receive data on (0 = randomly assigned)
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    # @param external_port [Integer] External port to write to
+    # @param external_address [String] External host to send data to
+    # @param multicast_interface_address [String] Local outgoing interface to send multicast packets from
+    # @param ttl [Integer] Time To Live for outgoing multicast packets
+    # @param read_multicast [Boolean] Whether or not to try to read from the external address as multicast
+    # @param write_multicast [Boolean] Whether or not to write to the external address as multicast
+    def initialize(
+      bind_port = 0,
+      bind_address = "0.0.0.0",
+      external_port = nil,
+      external_address = nil,
+      multicast_interface_address = nil,
+      ttl = 1,
+      read_multicast = true,
+      write_multicast = true)
 
-    # @param dest_address [String] Host to send data to
-    # @param dest_port [Integer] Port to send data to
-    # @param src_port [Integer[ Port to send data out from
-    # @param interface_address [String] Local outgoing interface to send from
-    # @param ttl [Integer] Time To Live for outgoing packets
-    def initialize(dest_address,
-                   dest_port,
-                   src_port = nil,
-                   interface_address = nil,
-                   ttl = 1,
-                   bind_address = "0.0.0.0")
       @socket = UDPSocket.new
 
       # Basic setup to reuse address
       @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
 
-      # Set source port if given
-      @socket.bind(bind_address, src_port) if src_port
+      # Bind to local address and port - This sets recv port, write_src port, recv_address, and write_src_address
+      @socket.bind(bind_address, bind_port) if (bind_address and bind_port)
 
       # Default send to the specified address and port
-      @socket.connect(dest_address, dest_port)
+      @socket.connect(external_address, external_port) if (external_address and external_port)
 
       # Handle multicast
-      if UdpWriteSocket.multicast?(dest_address)
-        # Basic setup set time to live
-        @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl.to_i)
+      if UdpReadWriteSocket.multicast?(external_address)
+        if write_multicast
+          # Basic setup set time to live
+          @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl.to_i)
+
+          # Set outgoing interface
+          @socket.setsockopt(
+            Socket::IPPROTO_IP,
+            Socket::IP_MULTICAST_IF,
+            IPAddr.new(multicast_interface_address).hton) if multicast_interface_address
+        end
 
-        # Set outgoing interface
-        @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF, IPAddr.new(interface_address).hton) if interface_address
+        # Receive messages sent to the multicast address
+        if read_multicast
+          multicast_interface_address = "0.0.0.0" unless multicast_interface_address
+          membership = IPAddr.new(external_address).hton + IPAddr.new(multicast_interface_address).hton
+          @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+        end
       end
     end
 
@@ -78,6 +95,23 @@ module Cosmos
       end
     end
 
+    # @param read_timeout [Float] Time in seconds to wait for the read to
+    #   complete
+    def read(read_timeout = nil)
+      data = nil
+      begin
+        data, _ = @socket.recvfrom_nonblock(65536)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        result = IO.fast_select([@socket], nil, nil, read_timeout)
+        if result
+          retry
+        else
+          raise Timeout::Error, "Read Timeout"
+        end
+      end
+      data
+    end
+
     # Defer all methods to the UDPSocket
     def method_missing(method, *args, &block)
       @socket.__send__(method, *args, &block)
@@ -105,47 +139,57 @@ module Cosmos
     end
   end
 
-  # Creates a UDPSocket and implements a non-blocking read.
-  class UdpReadSocket
-
-    # @param recv_port [Integer] Port to receive data on
-    # @param multicast_address [String] Address to add multicast
-    def initialize(recv_port = 0, multicast_address = nil, interface_address = nil, bind_address = "0.0.0.0")
-      @socket = UDPSocket.new
-
-      # Basic setup to reuse address
-      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
-
-      # bind to port
-      @socket.bind(bind_address, recv_port)
+  # Creates a UDPSocket and implements a non-blocking write.
+  class UdpWriteSocket < UdpReadWriteSocket
 
-      if UdpWriteSocket.multicast?(multicast_address)
-        interface_address = "0.0.0.0" unless interface_address
-        membership = IPAddr.new(multicast_address).hton + IPAddr.new(interface_address).hton
-        @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
-      end
+    # @param dest_address [String] Host to send data to
+    # @param dest_port [Integer] Port to send data to
+    # @param src_port [Integer[ Port to send data out from
+    # @param multicast_interface_address [String] Local outgoing interface to send multicast packets from
+    # @param ttl [Integer] Time To Live for outgoing packets
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    def initialize(
+      dest_address,
+      dest_port,
+      src_port = nil,
+      multicast_interface_address = nil,
+      ttl = 1,
+      bind_address = "0.0.0.0")
+
+      super(
+        src_port,
+        bind_address,
+        dest_port,
+        dest_address,
+        multicast_interface_address,
+        ttl,
+        false,
+        true)
     end
+  end
 
-    # @param read_timeout [Float] Time in seconds to wait for the read to
-    #   complete
-    def read(read_timeout = nil)
-      data = nil
-      begin
-        data, _ = @socket.recvfrom_nonblock(65536)
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        result = IO.fast_select([@socket], nil, nil, read_timeout)
-        if result
-          retry
-        else
-          raise Timeout::Error, "Read Timeout"
-        end
-      end
-      data
-    end
+  # Creates a UDPSocket and implements a non-blocking read.
+  class UdpReadSocket < UdpReadWriteSocket
 
-    # Defer all methods to the UDPSocket
-    def method_missing(method, *args, &block)
-      @socket.__send__(method, *args, &block)
+    # @param recv_port [Integer] Port to receive data on
+    # @param multicast_address [String] Address to add multicast
+    # @param multicast_interface_address [String] Local incoming interface to receive multicast packets on
+    # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
+    def initialize(
+      recv_port = 0,
+      multicast_address = nil,
+      multicast_interface_address = nil,
+      bind_address = "0.0.0.0")
+
+      super(
+        recv_port,
+        bind_address,
+        nil,
+        multicast_address,
+        multicast_interface_address,
+        1,
+        true,
+        false)
     end
   end