cosmos 4.0.3 → 4.1.0

data/lib/cosmos/gui/qt.rb

@@ -252,6 +252,7 @@ module Cosmos
         end
       end
     end
+    return config_change_success, change_error
   end
 end
 
@@ -458,17 +459,13 @@ class Qt::PlainTextEdit
       text << "\n"
     end
     if text =~ /<G>/ or color == Cosmos::GREEN
-      text.gsub!(/<G>/, BLANK)
-      addText(text, Cosmos::GREEN)
+      addText(text.gsub(/<G>/, BLANK), Cosmos::GREEN)
     elsif text =~ /<Y>/ or color == Cosmos::YELLOW
-      text.gsub!(/<Y>/, BLANK)
-      addText(text, Cosmos::YELLOW)
+      addText(text.gsub(/<Y>/, BLANK), Cosmos::YELLOW)
     elsif text =~ /<R>/ or color == Cosmos::RED
-      text.gsub!(/<R>/, BLANK)
-      addText(text, Cosmos::RED)
+      addText(text.gsub(/<R>/, BLANK), Cosmos::RED)
     elsif text =~ /<B>/ or color == Cosmos::BLUE
-      text.gsub!(/<B>/, BLANK)
-      addText(text, Cosmos::BLUE)
+      addText(text.gsub(/<B>/, BLANK), Cosmos::BLUE)
     else
       addText(text) # default is Cosmos::BLACK
     end

data/lib/cosmos/gui/qt_tool.rb

@@ -75,21 +75,21 @@ module Cosmos
     # @param filename [String] Path to a configuration file
     # @param type [String] File extension, e.g. '.txt'
     # @param tool_name [String] Name of the tool calling this method
-    # @return [String|nil] Path to a configuration file or nil if none found
+    # @return [String|nil] Path to a configuration file. If a filename was
+    #   passed and the configuration file is not found, the original filename
+    #   is returned. If no filename was passed nil is returned.
     def config_path(filename, type, tool_name)
       return filename if filename && File.exist?(filename)
       if filename
         # Add the configuration dir onto the filename
-        filename = File.join(@options.config_dir, filename)
+        new_filename = File.join(@options.config_dir, filename)
+        return new_filename if File.exist?(new_filename)
       else
         # No file passed so default to a file named after the class
-        filename = File.join(@options.config_dir, "#{tool_name}#{type}")
-      end
-      if File.exist? filename
-        filename
-      else
-        nil
+        new_filename = File.join(@options.config_dir, "#{tool_name}#{type}")
+        return new_filename if File.exist?(new_filename)
       end
+      filename
     end
 
     # Create the exit_action and the about_action. The exit_action is not

data/lib/cosmos/gui/text/ruby_editor.rb

@@ -403,37 +403,37 @@ module Cosmos
     end
 
     def create_add_breakpoint_action(point)
-      add_breakpoint = Qt::Action.new(tr("Add Breakpoint"), self)
-      add_breakpoint.statusTip = tr("Add a breakpoint at this line")
-      add_breakpoint.connect(SIGNAL('triggered()')) do
+      action = Qt::Action.new(tr("Add Breakpoint"), self)
+      action.statusTip = tr("Add a breakpoint at this line")
+      action.connect(SIGNAL('triggered()')) do
         line_at_point(point) do |line|
           add_breakpoint(line)
           emit breakpoint_set(line)
         end
       end
-      add_breakpoint
+      action
     end
 
     def create_clear_breakpoint_action(point)
-      clear_breakpoint = Qt::Action.new(tr("Clear Breakpoint"), self)
-      clear_breakpoint.statusTip = tr("Clear an existing breakpoint at this line")
-      clear_breakpoint.connect(SIGNAL('triggered()')) do
+      action = Qt::Action.new(tr("Clear Breakpoint"), self)
+      action.statusTip = tr("Clear an existing breakpoint at this line")
+      action.connect(SIGNAL('triggered()')) do
         line_at_point(point) do |line|
           clear_breakpoint(line)
           emit breakpoint_cleared(line)
         end
       end
-      clear_breakpoint
+      action
     end
 
     def create_clear_all_breakpoints_action
-      clear_all_breakpoints = Qt::Action.new(tr("Clear All Breakpoints"), self)
-      clear_all_breakpoints.statusTip = tr("Clear all existing breakpoints")
-      clear_all_breakpoints.connect(SIGNAL('triggered()')) do
+      action = Qt::Action.new(tr("Clear All Breakpoints"), self)
+      action.statusTip = tr("Clear all existing breakpoints")
+      action.connect(SIGNAL('triggered()')) do
         clear_breakpoints
         emit breakpoints_cleared
       end
-      clear_all_breakpoints
+      action
     end
 
     # Get the top and bottom coordinates of the block in viewport coordinates

data/lib/cosmos/gui/utilities/script_module_gui.rb

@@ -76,16 +76,16 @@ module Cosmos
       return result
     end
 
-    def save_file_dialog(directory = Cosmos::USERPATH, message = "Save File")
-      _get_main_thread_gui {|window| Qt::FileDialog.getSaveFileName(window, message, directory) }
+    def save_file_dialog(directory = Cosmos::USERPATH, message = "Save File", filter = "All Files (*.*)")
+      _get_main_thread_gui {|window| Qt::FileDialog.getSaveFileName(window, message, directory, filter) }
     end
 
-    def open_file_dialog(directory = Cosmos::USERPATH, message = "Open File")
-      _get_main_thread_gui {|window| Qt::FileDialog.getOpenFileName(window, message, directory) }
+    def open_file_dialog(directory = Cosmos::USERPATH, message = "Open File", filter = "All Files (*.*)")
+      _get_main_thread_gui {|window| Qt::FileDialog.getOpenFileName(window, message, directory, filter) }
     end
 
-    def open_files_dialog(directory = Cosmos::USERPATH, message = "Open File(s)")
-      _get_main_thread_gui {|window| Qt::FileDialog.getOpenFileNames(window, message, directory) }
+    def open_files_dialog(directory = Cosmos::USERPATH, message = "Open File(s)", filter = "All Files (*.*)")
+      _get_main_thread_gui {|window| Qt::FileDialog.getOpenFileNames(window, message, directory, filter) }
     end
 
     def open_directory_dialog(directory = Cosmos::USERPATH, message = "Open Directory")
@@ -134,7 +134,7 @@ module Cosmos
       result = nil
       _get_main_thread_gui do |window|
         msg = Qt::MessageBox.new(window)
-        msg.setIcon(Qt::MessageBox::Warning)
+        msg.setIcon(Qt::MessageBox::Question)
         msg.setText(message)
         msg.setWindowTitle(title)
         msg.setStandardButtons(Qt::MessageBox::Yes | Qt::MessageBox::No)
@@ -221,7 +221,7 @@ module Cosmos
 
     def prompt_vertical_message_box(string, buttons)
       loop do
-        result = buttons[0]
+        result = buttons[0].clone
         Qt.execute_in_main_thread(true, 0.05) do
           dialog = _build_dialog(string)
 
@@ -258,7 +258,7 @@ module Cosmos
 
     def prompt_combo_box(string, options)
       loop do
-        result = options[0]
+        result = options[0].clone
         Qt.execute_in_main_thread(true, 0.05) do
           dialog = _build_dialog(string)
           # Check if the last parameter is false which means they don't want

data/lib/cosmos/gui/widgets/realtime_button_bar.rb

@@ -15,25 +15,20 @@ require 'cosmos'
 require 'cosmos/gui/qt'
 
 module Cosmos
-
-  # RealtimeButtonBar class
-  #
-  # This class implements the RealtimeButtonBar
-  #
+  # Create a horizontal or vertical widget which contains buttons to control
+  # scripting. The Step button is hidden by default, and Start, Pause, and
+  # Stop are visible.
   class RealtimeButtonBar < Qt::Widget
-
-    # Accessors for callbacks
+    attr_accessor :step_callback
     attr_accessor :start_callback
     attr_accessor :pause_callback
     attr_accessor :stop_callback
-
-    # Readers for buttons
+    attr_reader :step_button
     attr_reader :start_button
     attr_reader :pause_button
     attr_reader :stop_button
 
-    # Constructor
-    def initialize (parent, orientation = Qt::Horizontal)
+    def initialize(parent, orientation = Qt::Horizontal)
       super(parent)
       if orientation == Qt::Horizontal
         # Horizontal Frame for overall widget
@@ -56,15 +51,21 @@ module Cosmos
         @stop_button  = Qt::PushButton.new('Stop')
         @pause_button = Qt::PushButton.new('Pause')
         @start_button = Qt::PushButton.new('Start')
+        @step_button  = Qt::PushButton.new('Step')
+        @step_button.setHidden(true)
+        @overall_frame.addWidget(@step_button)
         @overall_frame.addWidget(@start_button)
         @overall_frame.addWidget(@pause_button)
         @overall_frame.addWidget(@stop_button)
       else
         # Buttons
         @button_frame = Qt::HBoxLayout.new
+        @step_button = Qt::PushButton.new('Step')
+        @step_button.setHidden(true)
         @start_button = Qt::PushButton.new('Start')
         @pause_button = Qt::PushButton.new('Pause')
         @stop_button  = Qt::PushButton.new('Stop')
+        @button_frame.addWidget(@step_button)
         @button_frame.addWidget(@start_button)
         @button_frame.addWidget(@pause_button)
         @button_frame.addWidget(@stop_button)
@@ -75,9 +76,11 @@ module Cosmos
 
       # Connect handlers
       @stop_button.connect(SIGNAL('clicked()')) { @stop_callback.call if @stop_callback }
-      @pause_button.connect(SIGNAL('clicked()'))  { @pause_callback.call if @pause_callback }
-      @start_button.connect(SIGNAL('clicked()'))  { @start_callback.call if @start_callback }
+      @pause_button.connect(SIGNAL('clicked()')) { @pause_callback.call if @pause_callback }
+      @start_button.connect(SIGNAL('clicked()')) { @start_callback.call if @start_callback }
+      @step_button.connect(SIGNAL('clicked()')) { @step_callback.call if @step_callback }
 
+      @step_callback = nil
       @start_callback = nil
       @pause_callback = nil
       @stop_callback  = nil
@@ -92,7 +95,5 @@ module Cosmos
     def state= (new_state)
       @state.setText(new_state.to_s)
     end
-
-  end # class RealtimeButtonBar
-
-end # module Cosmos
+  end
+end

data/lib/cosmos/interfaces/protocols/fixed_protocol.rb

@@ -53,7 +53,7 @@ module Cosmos
 
     # Identifies an unknown buffer of data as a Packet. The raw data is
     # returned but the packet that matched is recorded so it can be set in the
-    # post_read_packet callback.
+    # read_packet callback.
     #
     # @return [String|Symbol] The identified packet data or :STOP if more data
     #   is required to build a packet
@@ -82,7 +82,7 @@ module Cosmos
               return :STOP if @data.length < identified_packet.defined_length
             end
             # Set some variables so we can update the packet in
-            # post_read_packet
+            # read_packet
             @received_time = Time.now.sys
             @target_name = identified_packet.target_name
             @packet_name = identified_packet.packet_name

data/lib/cosmos/interfaces/protocols/template_protocol.rb

@@ -121,6 +121,9 @@ module Cosmos
         # Grab the response packet specified in the command
         result_packet = System.telemetry.packet(@interface.target_names[0], @response_packet).clone
         result_packet.received_time = nil
+        result_packet.id_items.each do |item|
+          result_packet.write_item(item, item.id_value, :RAW)
+        end
 
         # Convert the response template into a Regexp
         response_item_names = []

data/lib/cosmos/interfaces/udp_interface.rb

@@ -75,18 +75,29 @@ module Cosmos
     # the constructor and a new {UdpReadSocket} if the read_port was given in
     # the constructor.
     def connect
-      @read_socket = UdpReadSocket.new(
-        @read_port,
-        @hostname,
-        @interface_address,
-        @bind_address) if @read_port
-      @write_socket = UdpWriteSocket.new(
-        @hostname,
-        @write_dest_port,
-        @write_src_port,
-        @interface_address,
-        @ttl,
-        @bind_address) if @write_dest_port
+      if @read_port and @write_dest_port and @write_src_port and (@read_port == @write_src_port)
+        @read_socket = UdpReadWriteSocket.new(
+          @read_port,
+          @bind_address,
+          @write_dest_port,
+          @hostname,
+          @interface_address,
+          @ttl)
+        @write_socket = @read_socket
+      else
+        @read_socket = UdpReadSocket.new(
+          @read_port,
+          @hostname,
+          @interface_address,
+          @bind_address) if @read_port
+        @write_socket = UdpWriteSocket.new(
+          @hostname,
+          @write_dest_port,
+          @write_src_port,
+          @interface_address,
+          @ttl,
+          @bind_address) if @write_dest_port
+      end
       @thread_sleeper = nil
     end
 
@@ -105,9 +116,11 @@ module Cosmos
 
     # Close the active ports (read and/or write) and set the sockets to nil.
     def disconnect
-      Cosmos.close_socket(@write_socket)
-      @write_socket = nil
+      if @write_socket != @read_socket
+        Cosmos.close_socket(@write_socket)
+      end
       Cosmos.close_socket(@read_socket)
+      @write_socket = nil
       @read_socket = nil
       @thread_sleeper.cancel if @thread_sleeper
       @thread_sleeper = nil

data/lib/cosmos/io/buffered_file.rb

@@ -51,7 +51,6 @@ else
           if @buffer.length <= 0
             return nil
           end
-
           if read_length <= @buffer.length
             result = @buffer[@buffer_index, read_length]
             @buffer_index += read_length

data/lib/cosmos/io/json_drb.rb

@@ -15,6 +15,28 @@ require 'drb/acl'
 require 'drb/drb'
 require 'set'
 require 'cosmos/io/json_rpc'
+require 'cosmos/io/json_drb_rack'
+require 'rack/handler/puma'
+if RUBY_ENGINE == 'ruby' and %w(2.2.7 2.2.8 2.3.4 2.4.1).include? RUBY_VERSION
+  require 'stopgap_13632'
+end
+
+# Add methods to the Puma::Launcher and Puma::Single class so we can tell
+# if the server has been started.
+module Puma
+  class Launcher
+    def running
+      @runner and @runner.running
+    end
+  end
+  class Runner
+  end
+  class Single < Runner
+    def running
+      @server and @server.running
+    end
+  end
+end
 
 module Cosmos
 
@@ -25,7 +47,6 @@ module Cosmos
   # methods.
   class JsonDRb
     MINIMUM_REQUEST_TIME = 0.0001
-    FAST_READ = (RUBY_VERSION > "2.1")
 
     @@debug = false
 
@@ -37,7 +58,6 @@ module Cosmos
     attr_accessor :acl
 
     def initialize
-      @listen_socket = nil
       @thread = nil
       @acl = nil
       @object = nil
@@ -46,52 +66,46 @@ module Cosmos
       @request_times = []
       @request_times_index = 0
       @request_mutex = Mutex.new
-      @client_sockets = []
-      @client_threads = []
-      @client_pipe_writers = []
-      @client_mutex = Mutex.new
-      @thread_reader, @thread_writer = IO.pipe
+      @server = nil
+      @server_mutex = Mutex.new
     end
 
     # Returns the number of connected clients
     # @return [Integer] The number of connected clients
     def num_clients
-      @client_threads.length
+      clients = 0
+      @server_mutex.synchronize do
+        if @server
+          # @server.stats() returns a string like: { "backlog": 0, "running": 0 }
+          # "running" indicates the number of server threads running, and
+          # therefore the number of clients connected.
+          stats = @server.stats()
+          stats =~ /"running": \d*/
+          clients = $&.split(":")[1].to_i
+        end
+      end
+      return clients
     end
 
     # Stops the DRb service by closing the socket and the processing thread
     def stop_service
-      Cosmos.kill_thread(self, @thread)
+      # Kill the server thread; it can take a while, so use
+      # graceful_timeout = 5, timeout_interval = 0.1, hard_timeout = 5
+      Cosmos.kill_thread(self, @thread, 5, 0.1, 5)
       @thread = nil
-      Cosmos.close_socket(@listen_socket)
-      @listen_socket = nil
-      client_threads = nil
-      @client_mutex.synchronize do
-        @client_sockets.each do |client_socket|
-          Cosmos.close_socket(client_socket)
-        end
-        @client_pipe_writers.each do |client_pipe_writer|
-          client_pipe_writer.write('.')
-        end
-        client_threads = @client_threads.clone
-      end
-
-      # This cannot be inside of the client_mutex or the threads will not
-      # be able to shutdown because they will stick on the client_mutex
-      client_threads.each do |client_thread|
-        Cosmos.kill_thread(self, client_thread)
-      end
-
-      @client_mutex.synchronize do
-        @client_threads.clear
-        @client_sockets.clear
-        @client_pipe_writers.clear
+      @server_mutex.synchronize do
+        @server = nil
       end
     end
 
     # Gracefully kill the thread
     def graceful_kill
-      @thread_writer.write('.') if @thread
+      @server_mutex.synchronize do
+        begin
+          @server.stop if @server and @server.running
+        rescue
+        end
+      end
     end
 
     # @param hostname [String] The host to start the service on
@@ -99,58 +113,80 @@ module Cosmos
     # @param object [Object] The object to send the DRb requests to. This
     #   object must either include the Cosmos::Script module or be the
     #   CmdTlmServer.
-    def start_service(hostname = nil, port = nil, object = nil)
+    def start_service(hostname = nil, port = nil, object = nil, max_threads = 1000)
+      server_started = false
+      @server_mutex.synchronize do
+        server_started = true if @server
+      end
+      return if server_started
+
       if hostname and port and object
-        @thread_reader, @thread_writer = IO.pipe
         @object = object
         hostname = '127.0.0.1'.freeze if (hostname.to_s.upcase == 'LOCALHOST'.freeze)
 
-        # Create a socket to accept connections from clients
-        begin
-          @listen_socket = TCPServer.new(hostname, port)
-          @listen_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1) unless Kernel.is_windows?
-        # The address is use error is pretty typical if an existing
-        # CmdTlmServer is running so explicitly rescue this
-        rescue Errno::EADDRINUSE
-          raise "Error binding to port #{port}.\n" +
-                "Either another application is using this port\n" +
-                "or the operating system is being slow cleaning up.\n" +
-                "Make sure all sockets/streams are closed in all applications,\n" +
-                "wait 1 minute and try again."
-        # Something else went wrong which is fatal
-        rescue => error
-          Logger.error "JsonDRb listen thread unable to be created.\n#{error.formatted}"
-          Cosmos.handle_fatal_exception(error)
-        end
-
-        # Start the listen thread which accepts connections
         @thread = Thread.new do
+
+          # Create an http server to accept requests from clients
           begin
-            while true
-              begin
-                socket = @listen_socket.accept_nonblock
-              rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EINTR, Errno::EWOULDBLOCK
-                read_ready, _ = IO.select([@listen_socket, @thread_reader])
-                if read_ready and read_ready.include?(@thread_reader)
-                  # Thread should be killed
-                  break
-                else
-                  retry
-                end
+            server_config = {
+              :Host   => hostname,
+              :Port   => port,
+              :Silent => true,
+              :Verbose => false,
+              :Threads => "0:#{max_threads}",
+            }
+
+            # The run call will block until the server is stopped.
+            Rack::Handler::Puma.run(JsonDrbRack.new(self), server_config) do |server|
+              @server_mutex.synchronize do
+                @server = server
               end
+            end
 
-              if @acl and !@acl.allow_socket?(socket)
-                Cosmos.close_socket(socket)
-                next
-              end
-              # Create new thread for new connection
-              create_client_thread(socket)
+            # Wait for all puma threads to stop before trying to close
+            # the sockets
+            start_time = Time.now
+            while true
+              puma_threads = false
+              Thread.list.each {|thread| puma_threads = true if thread.inspect.match(/puma/)}
+              break if !puma_threads
+              break if (Time.now - start_time) > 10.0
+              sleep 0.25
             end
-          rescue Exception => error
-            Logger.error "JsonDRb listen thread unexpectedly died.\n#{error.formatted}"
+
+            # Puma doesn't clean up it's own sockets after shutting down,
+            # so we'll do that here.
+            @server_mutex.synchronize do
+              @server.binder.close() if @server
+            end
+
+          # The address in use error is pretty typical if an existing
+          # CmdTlmServer is running so explicitly rescue this
+          rescue Errno::EADDRINUSE
+            @server = nil
+            raise "Error binding to port #{port}.\n" +
+                  "Either another application is using this port\n" +
+                  "or the operating system is being slow cleaning up.\n" +
+                  "Make sure all sockets/streams are closed in all applications,\n" +
+                  "wait 1 minute and try again."
+          # Something else went wrong which is fatal
+          rescue => error
+            @server = nil
+            Logger.error "JsonDRb http server could not be started or unexpectedly died.\n#{error.formatted}"
             Cosmos.handle_fatal_exception(error)
           end
         end
+
+        # Wait for the server to be started in the thread before returning.
+        start_time = Time.now
+        while ((Time.now - start_time) < 5.0) and !server_started
+          sleep(0.1)
+          @server_mutex.synchronize do
+            server_started = true if @server and @server.running
+          end
+        end
+        raise "JsonDRb http server could not be started." unless server_started
+
       elsif hostname or port or object
         raise "0 or 3 parameters must be given"
       else
@@ -188,81 +224,6 @@ module Cosmos
       avg
     end
 
-    # @param socket [Socket] The socket to the client
-    # @param data [String] Binary data which has already been read from the
-    #   socket.
-    # @param pipe_reader [IO.pipe] Used to break out of select
-    # @return [String] The request message
-    def self.receive_message(socket, data, pipe_reader)
-      self.get_at_least_x_bytes_of_data(socket, data, 4, pipe_reader)
-      if data.length >= 4
-        length = data[0..3].unpack('N'.freeze)[0]
-        data.replace(data[4..-1])
-      else
-        return nil
-      end
-
-      self.get_at_least_x_bytes_of_data(socket, data, length, pipe_reader)
-      if data.length >= length
-        message = data[0..(length - 1)]
-        data.replace(data[length..-1])
-        return message
-      else
-        return nil
-      end
-    end
-
-    # @param socket [Socket] The socket to the client
-    # @param current_data [String] Binary data read from the socket
-    # @param required_num_bytes [Integer] The minimum number of bytes to read
-    # @param pipe_reader [IO.pipe] Used to break out of select
-    #   before returning
-    def self.get_at_least_x_bytes_of_data(socket, current_data, required_num_bytes, pipe_reader)
-      while (current_data.length < required_num_bytes)
-        if FAST_READ
-          data = socket.read_nonblock(65535, exception: false)
-          raise EOFError, 'end of file reached' unless data
-          if data == :wait_readable
-            IO.fast_select([socket, pipe_reader], nil, nil, nil)
-          else
-            current_data << data
-          end
-        else
-          begin
-            current_data << socket.read_nonblock(65535)
-          rescue IO::WaitReadable
-            IO.fast_select([socket, pipe_reader], nil, nil, nil)
-          end
-        end
-      end
-    end
-
-    # @param socket [Socket] The socket to the client
-    # @param data [String] Binary data to send to the socket
-    # @param send_timeout [Float] The number of seconds to wait for the send to
-    #   complete
-    def self.send_data(socket, data, send_timeout = 10.0)
-      num_bytes_to_send = data.length + 4
-      total_bytes_sent = 0
-      bytes_sent = 0
-      data_to_send = [data.length].pack('N'.freeze) << data.clone
-
-      loop do
-        begin
-          bytes_sent = socket.write_nonblock(data_to_send[total_bytes_sent..-1])
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          result = IO.fast_select(nil, [socket], nil, send_timeout)
-          if result
-            retry
-          else
-            raise Timeout::Error, "Send Timeout"
-          end
-        end
-        total_bytes_sent += bytes_sent
-        break if total_bytes_sent >= num_bytes_to_send
-      end
-    end
-
     # @return [Boolean] Whether debug messages are enabled
     def self.debug?
       @@debug
@@ -273,66 +234,20 @@ module Cosmos
       @@debug = value
     end
 
-    protected
-
-    # Creates a new Thread to service the JSON DRb requests from the client.
-    #
-    # @param socket [Socket] The socket which the server accepted from the
-    #   client.
-    def create_client_thread(socket)
-      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
-
-      Thread.new(socket) do |my_socket|
-        pipe_reader, pipe_writer = IO.pipe
-        @client_mutex.synchronize do
-          @client_sockets << my_socket
-          @client_threads << Thread.current
-          @client_pipe_writers << pipe_writer
-        end
-
-        data = ''
-
-        begin
-          while true
-            begin
-              request_data = JsonDRb.receive_message(my_socket, data, pipe_reader)
-              start_time = Time.now.sys
-              @request_count += 1
-            rescue Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ENOTSOCK, IOError
-              # Socket was closed
-              break
-            end
-            if request_data
-              break unless process_request(request_data, my_socket, start_time)
-            else
-              # Socket was closed by client
-              break
-            end
-          end
-        rescue Exception => error
-          Logger.error "JsonDrb client thread unexpectedly died.\n#{error.formatted}"
-        end
-
-        @client_mutex.synchronize do
-          Cosmos.close_socket(my_socket)
-          @client_sockets.delete(my_socket)
-          @client_threads.delete(Thread.current)
-          @client_pipe_writers.delete(pipe_writer)
-        end
-      end
-    end
-
-    # Process the JSON request data, execute the method, and send the response.
+    # Process the JSON request data, execute the method, and create a response.
     #
     # @param request_data [String] The JSON encoded request
-    # @param my_socket [Socket] The socket to send the response out on
     # @param start_time [Time] The time when the initial request was received
-    def process_request(request_data, my_socket, start_time)
+    # @return response_data, error_code [String, Integer/nil] The JSON encoded
+    #   response and error code
+    def process_request(request_data, start_time)
+      @request_count += 1
       STDOUT.puts request_data if JsonDRb.debug?
       begin
         request = JsonRpcRequest.from_json(request_data)
         response = nil
+        error_code = nil
+        response_data = nil
 
         if (@method_whitelist and @method_whitelist.include?(request.method)) or
            (!@method_whitelist and !JsonRpcRequest::DANGEROUS_METHODS.include?(request.method))
@@ -344,41 +259,46 @@ module Cosmos
           rescue Exception => error
             if request.id
               if NoMethodError === error
+                error_code = JsonRpcError::ErrorCode::METHOD_NOT_FOUND
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(-32601, "Method not found", error), request.id)
+                  JsonRpcError.new(error_code, "Method not found", error), request.id)
               elsif ArgumentError === error
+                error_code = JsonRpcError::ErrorCode::INVALID_PARAMS
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(-32602, "Invalid params", error), request.id)
+                  JsonRpcError.new(error_code, "Invalid params", error), request.id)
               else
+                error_code = JsonRpcError::ErrorCode::OTHER_ERROR
                 response = JsonRpcErrorResponse.new(
-                  JsonRpcError.new(-1, error.message, error), request.id)
+                  JsonRpcError.new(error_code, error.message, error), request.id)
               end
             end
           end
         else
           if request.id
+            error_code = JsonRpcError::ErrorCode::OTHER_ERROR
             response = JsonRpcErrorResponse.new(
-              JsonRpcError.new(-1, "Cannot call unauthorized methods"), request.id)
+              JsonRpcError.new(error_code, "Cannot call unauthorized methods"), request.id)
           end
         end
-        process_response(response, my_socket, start_time) if response
+        response_data = process_response(response, start_time) if response
+        return response_data, error_code
       rescue => error
-        response = JsonRpcErrorResponse.new(JsonRpcError.new(-32600, "Invalid Request", error), nil)
-        process_response(response, my_socket, start_time)
+        error_code = JsonRpcError::ErrorCode::INVALID_REQUEST
+        response = JsonRpcErrorResponse.new(JsonRpcError.new(error_code, "Invalid Request", error), nil)
+        response_data = process_response(response, start_time)
+        return response_data, error_code
       end
-      true
     end
 
-    def process_response(response, socket, start_time)
+    protected
+
+    def process_response(response, start_time)
       response_data = response.to_json(:allow_nan => true)
       STDOUT.puts response_data if JsonDRb.debug?
-      JsonDRb.send_data(socket, response_data)
       end_time = Time.now.sys
       request_time = end_time - start_time
       add_request_time(request_time)
-    rescue
-      # Socket was closed?
-      return false
+      return response_data
     end
 
   end