cosmos 3.1.2 → 3.2.0

data/lib/cosmos/streams/serial_stream.rb

@@ -123,6 +123,11 @@ module Cosmos
       end
     end
 
+    # Connect the stream
+    def connect
+      # N/A - Serial streams 'connect' on creation
+    end
+
     # @return [Boolean] Whether the serial stream is connected to the serial
     #   port
     def connected?

data/lib/cosmos/streams/stream.rb

@@ -12,8 +12,8 @@ require 'timeout' # For Timeout::Error
 
 module Cosmos
 
-  # Interface that implments the following methods: read, write(data),
-  # connected? and disconnect. Streams are simply data sources which
+  # Class that implments the following methods: read, write(data),
+  # connect, connected? and disconnect. Streams are simply data sources which
   # {StreamProtocol} classes read and write to. This separation of concerns
   # allows Streams to simply focus on getting and sending raw data while the
   # higher level processing occurs in {StreamProtocol}.
@@ -42,12 +42,18 @@ module Cosmos
       raise "write not defined by Stream"
     end
 
+    # Connects the stream
+    def connect
+      raise "connect not defined by Stream"
+    end
+
     # @return [Boolean] true if connected or false otherwise
     def connected?
       raise "connected? not defined by Stream"
     end
 
     # Disconnects the stream
+    # Note that streams are not designed to be reconnected and must be recreated
     def disconnect
       raise "disconnect not defined by Stream"
     end

data/lib/cosmos/streams/stream_protocol.rb

@@ -103,6 +103,7 @@ module Cosmos
       @data = ''
       @data.force_encoding('ASCII-8BIT')
       @stream = stream
+      @stream.connect
     end
 
     # @return [Boolean] Whether the stream attribute has been set and is

data/lib/cosmos/streams/tcpip_client_stream.rb

@@ -28,7 +28,7 @@ module Cosmos
     #   a write only stream.
     # @param write_timeout (see TcpipSocketStream#initialize)
     # @param read_timeout (see TcpipSocketStream#initialize)
-    def initialize(hostname, write_port, read_port, write_timeout, read_timeout)
+    def initialize(hostname, write_port, read_port, write_timeout, read_timeout, connect_timeout = 5.0)
       @hostname = hostname
       if (@hostname.to_s.upcase == 'LOCALHOST')
         @hostname = '127.0.0.1'
@@ -41,8 +41,8 @@ module Cosmos
       write_addr = nil
       read_addr = nil
       begin
-        write_addr = Socket.pack_sockaddr_in(@write_port, @hostname) if @write_port
-        read_addr  = Socket.pack_sockaddr_in(@read_port, @hostname) if @read_port
+        @write_addr = Socket.pack_sockaddr_in(@write_port, @hostname) if @write_port
+        @read_addr = Socket.pack_sockaddr_in(@read_port, @hostname) if @read_port
       rescue => error
         if error.message =~ /getaddrinfo/
           raise "Invalid hostname: #{@hostname}"
@@ -52,26 +52,56 @@ module Cosmos
       end
 
       write_socket = nil
-      if write_addr
+      if @write_addr
         write_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
         write_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        write_socket.connect(write_addr)
       end
 
       read_socket = nil
-      if read_addr
+      if @read_addr
         if @write_port != @read_port
           read_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
           read_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-          read_socket.connect(read_addr)
         else
           read_socket = write_socket
         end
       end
 
+      @connect_timeout = ConfigParser.handle_nil(connect_timeout)
+      @connect_timeout = @connect_timeout.to_f if @connect_timeout
+
       super(write_socket, read_socket, write_timeout, read_timeout)
     end
 
+    # Connect the socket(s)
+    def connect
+      connect_nonblock(@write_socket, @write_addr) if @write_socket
+      connect_nonblock(@read_socket, @read_addr) if @read_socket and @read_socket != @write_socket
+      super()
+    end
+
+    protected
+
+    def connect_nonblock(socket, addr)
+      begin
+        socket.connect_nonblock(addr)
+      rescue IO::WaitWritable
+        begin
+          _, sockets, _ = IO.select(nil, [socket], nil, @connect_timeout) # wait 3-way handshake completion
+        rescue Errno::ENOTSOCK
+          raise "Connect canceled"
+        end
+        if sockets and !sockets.empty?
+          begin
+            socket.connect_nonblock(addr) # check connection failure
+          rescue Errno::EISCONN
+          end
+        else
+          raise "Connect timeout"
+        end
+      end
+    end
+
   end # class TcpipClientStream
 
 end # module Cosmos

data/lib/cosmos/streams/tcpip_socket_stream.rb

@@ -35,7 +35,6 @@ module Cosmos
       @write_timeout = @write_timeout.to_f if @write_timeout
       @read_timeout  = ConfigParser.handle_nil(read_timeout)
       @read_timeout  = @read_timeout.to_f if @read_timeout
-      @connected = true
 
       # Mutex on write is needed to protect from commands coming in from more
       # than one tool
@@ -120,6 +119,12 @@ module Cosmos
       end
     end
 
+    # Connect the stream
+    def connect
+      # If called directly this class is acting as a server and does not need to connect the sockets
+      @connected = true
+    end
+
     # @return [Boolean] Whether the sockets are connected
     def connected?
       @connected
@@ -127,11 +132,9 @@ module Cosmos
 
     # Disconnect by closing the sockets
     def disconnect
-      if @connected
-        @write_socket.close if @write_socket and !@write_socket.closed?
-        @read_socket.close if @read_socket and !@read_socket.closed?
-        @connected = false
-      end
+      @write_socket.close if @write_socket and !@write_socket.closed?
+      @read_socket.close if @read_socket and !@read_socket.closed?
+      @connected = false
     end
 
   end # class TcpipSocketStream

data/lib/cosmos/system/target.rb

@@ -135,12 +135,9 @@ module Cosmos
           usage = "#{keyword} <FILENAME>"
           parser.verify_num_parameters(1, 1, usage)
           begin
-            require parameters[0]
-          rescue LoadError => err
-            msg = "Unable to require #{parameters[0]} due to #{err.message}. " +
-              "Ensure #{parameters[0]} is in the COSMOS lib directory."
-            Logger.instance.error msg
-            raise parser.error(msg)
+            Cosmos.require_file(parameters[0])
+          rescue Exception => err
+            raise parser.error(err.message)
           end
           @requires << parameters[0]
 

data/lib/cosmos/tools/cmd_tlm_server/cmd_tlm_server_config.rb

@@ -61,9 +61,9 @@ module Cosmos
     # @param recursive [Boolean] Whether process_file is being called
     #   recursively
     def process_file(filename, recursive = false)
-      current_interface = nil
+      current_interface_or_router = nil
+      current_type = nil
       current_interface_log_added = false
-      current_router = nil
 
       Logger.info "Processing CmdTlmServer configuration in file: #{File.expand_path(filename)}"
 
@@ -122,94 +122,103 @@ module Cosmos
             parser.verify_num_parameters(2, nil, usage)
             interface_class = Cosmos.require_class(params[1])
             if params[2]
-              current_interface = interface_class.new(*params[2..-1])
+              current_interface_or_router = interface_class.new(*params[2..-1])
             else
-              current_interface = interface_class.new
+              current_interface_or_router = interface_class.new
             end
+            current_type = :INTERFACE
             current_interface_log_added = false
-            current_interface.packet_log_writer_pairs << @packet_log_writer_pairs['DEFAULT']
-            current_interface.name = params[0].upcase
-            @interfaces[params[0].upcase] = current_interface
+            current_interface_or_router.packet_log_writer_pairs << @packet_log_writer_pairs['DEFAULT']
+            current_interface_or_router.name = params[0].upcase
+            @interfaces[params[0].upcase] = current_interface_or_router
 
-          when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG', 'DONT_LOG', 'TARGET', 'LOG_RAW'
-            raise parser.error("No current interface for #{keyword}") unless current_interface
+          when 'LOG', 'DONT_LOG', 'TARGET'
+            raise parser.error("No current interface for #{keyword}") unless current_interface_or_router and current_type == :INTERFACE
 
             case keyword
 
-            when 'DONT_CONNECT'
-              parser.verify_num_parameters(0, 0, "#{keyword}")
-              current_interface.connect_on_startup = false
-
-            when 'DONT_RECONNECT'
-              parser.verify_num_parameters(0, 0, "#{keyword}")
-              current_interface.auto_reconnect = false
-
-            when 'RECONNECT_DELAY'
-              parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
-              current_interface.reconnect_delay = Float(params[0])
-
-            when 'DISABLE_DISCONNECT'
-              parser.verify_num_parameters(0, 0, "#{keyword}")
-              current_interface.disable_disconnect = true
-
             when 'LOG'
               parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
               packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
               raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
-              current_interface.packet_log_writer_pairs.delete(@packet_log_writer_pairs['DEFAULT']) unless current_interface_log_added
+              current_interface_or_router.packet_log_writer_pairs.delete(@packet_log_writer_pairs['DEFAULT']) unless current_interface_log_added
               current_interface_log_added = true
-              current_interface.packet_log_writer_pairs << packet_log_writer_pair unless current_interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+              current_interface_or_router.packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.packet_log_writer_pairs.include?(packet_log_writer_pair)
 
             when 'DONT_LOG'
               parser.verify_num_parameters(0, 0, "#{keyword}")
-              current_interface.packet_log_writer_pairs = []
+              current_interface_or_router.packet_log_writer_pairs = []
 
             when 'TARGET'
               parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
               target_name = params[0].upcase
               target = System.targets[target_name]
               if target
-                target.interface = current_interface
-                current_interface.target_names << target_name
+                target.interface = current_interface_or_router
+                current_interface_or_router.target_names << target_name
               else
-                raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface.name}")
+                raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface_or_router.name}")
               end
 
-            when 'LOG_RAW'
+            end # end case keyword for all keywords that require a current interface
+
+          when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG_RAW', 'ROUTER_LOG_RAW', 'OPTION'
+            raise parser.error("No current interface or router for #{keyword}") unless current_interface_or_router
+
+            case keyword
+
+            when 'DONT_CONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.connect_on_startup = false
+
+            when 'DONT_RECONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.auto_reconnect = false
+
+            when 'RECONNECT_DELAY'
+              parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
+              current_interface_or_router.reconnect_delay = Float(params[0])
+
+            when 'DISABLE_DISCONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.disable_disconnect = true
+
+            # TODO: Deprecate ROUTER_LOG_RAW
+            when 'LOG_RAW', 'ROUTER_LOG_RAW'
               parser.verify_num_parameters(0, nil, "#{keyword} <Raw Logger Class File (optional)> <Raw Logger Parameters (optional)>")
-              current_interface.raw_logger_pair = RawLoggerPair.new(current_interface.name, params)
+              current_interface_or_router.raw_logger_pair = RawLoggerPair.new(current_interface_or_router.name, params)
 
-            end # end case keyword for all keywords that require a current interface
+            when 'OPTION'
+              parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+              current_interface_or_router.set_option(params[0], params[1..-1])
+
+            end # end case keyword for all keywords that require a current interface or router
 
           when 'ROUTER'
             usage = "ROUTER <Name> <Filename> <Specific Parameters>"
             parser.verify_num_parameters(2, nil, usage)
             router_class = Cosmos.require_class(params[1])
             if params[2]
-              current_router = router_class.new(*params[2..-1])
+              current_interface_or_router = router_class.new(*params[2..-1])
             else
-              current_router = router_class.new
+              current_interface_or_router = router_class.new
             end
-            current_router.name = params[0].upcase
-            @routers[params[0].upcase] = current_router
+            current_type = :ROUTER
+            current_interface_or_router.name = params[0].upcase
+            @routers[params[0].upcase] = current_interface_or_router
 
           when 'ROUTE'
-            raise parser.error("No current router for #{keyword}") unless current_router
+            raise parser.error("No current router for #{keyword}") unless current_interface_or_router and current_type == :ROUTER
             usage = "ROUTE <Interface Name>"
             parser.verify_num_parameters(1, 1, usage)
             interface_name = params[0].upcase
             interface = @interfaces[interface_name]
-            raise parser.error("Unknown interface #{interface_name} mapped to router #{current_router.name}") unless interface
-            unless current_router.interfaces.include? interface
-              current_router.interfaces << interface
-              interface.routers << current_router
+            raise parser.error("Unknown interface #{interface_name} mapped to router #{current_interface_or_router.name}") unless interface
+            unless current_interface_or_router.interfaces.include? interface
+              current_interface_or_router.interfaces << interface
+              interface.routers << current_interface_or_router
             end
 
-          when 'ROUTER_LOG_RAW'
-            raise parser.error("No current router for #{keyword}") unless current_router
-            parser.verify_num_parameters(0, nil, "#{keyword} <Raw Logger Class File (optional)> <Raw Logger Parameters (optional)>")
-            current_router.raw_logger_pair = RawLoggerPair.new(current_router.name, params)
-
           when 'BACKGROUND_TASK'
             usage = "#{keyword} <Filename> <Specific Parameters>"
             parser.verify_num_parameters(1, nil, usage)

data/lib/cosmos/tools/cmd_tlm_server/interface_thread.rb

@@ -183,12 +183,16 @@ module Cosmos
       if @connection_failed_callback
         @connection_failed_callback.call(connect_error)
       else
-        Logger.error "#{@interface.name} Connection Failed: #{connect_error.to_s}"
+        Logger.error "#{@interface.name} Connection Failed: #{connect_error.class}:#{connect_error.message}"
         case connect_error
-        when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT
+        when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::ENOTSOCK
           # Do not write an exception file for these extremely common cases
         else
-          Cosmos.write_exception_file(connect_error)
+          if RuntimeError === connect_error and (connect_error.message =~ /canceled/ or connect_error.message =~ /timeout/)
+            # Do not write an exception file for these extremely common cases
+          else
+            Cosmos.write_exception_file(connect_error)
+          end
         end
       end
       disconnect()

data/lib/cosmos/tools/limits_monitor/limits_monitor.rb

@@ -757,7 +757,7 @@ module Cosmos
       @cancel_thread = true
       @value_sleeper.cancel
       @limits_sleeper.cancel
-      script_disconnect()
+      shutdown_cmd_tlm()
       Cosmos.kill_thread(self, @limits_thread, 2)
       Cosmos.kill_thread(self, @value_thread, 2)
       super(event)

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_realtime_thread.rb

@@ -64,7 +64,13 @@ module Cosmos
     end # def kill
 
     def graceful_kill
-      # Just to remove warning
+      # Allow the callbacks a chance to update the GUI so that they can die gracefully
+      if defined? Qt and Thread.current == Thread.main
+        5.times do
+          Qt::CoreApplication.instance.processEvents
+          sleep(0.05)
+        end
+      end
     end
 
   end # class TabbedPlotsRealtimeThread

data/lib/cosmos/tools/tlm_viewer/tlm_viewer.rb

@@ -433,9 +433,8 @@ module Cosmos
           event.ignore()
         else
           # Close any open screens
-          script_disconnect()
-          Screen.close_all_screens(self)
           shutdown_cmd_tlm()
+          Screen.close_all_screens(self)
           @json_drb.stop_service if @json_drb
           super(event)
         end

data/lib/cosmos/top_level.rb

@@ -527,13 +527,7 @@ module Cosmos
   def self.require_class(class_filename)
     class_name = class_filename.filename_to_class_name
     return class_name.to_class if class_name.to_class and defined? class_name.to_class
-    begin
-      require class_filename
-    rescue LoadError => err
-      msg = "Unable to require #{class_filename} due to #{err.message}. Ensure #{class_filename} is in the COSMOS lib directory."
-      Logger.error msg
-      raise msg
-    end
+    self.require_file(class_filename)
     klass = class_name.to_class
     if klass
       return klass
@@ -542,6 +536,19 @@ module Cosmos
     end
   end
 
+  # Requires a file with a standard error message if it fails
+  #
+  # @param filename [String] The name of the file to require
+  def self.require_file(filename)
+    begin
+      require filename
+    rescue Exception => err
+      msg = "Unable to require #{filename} due to #{err.message}. Ensure #{filename} is in the COSMOS lib directory."
+      Logger.error msg
+      raise msg
+    end
+  end
+
   # @param filename [String] Name of the file to open in the editor
   def self.open_in_text_editor(filename)
     if filename
@@ -621,10 +628,14 @@ module Cosmos
   def self.kill_thread(owner, thread, graceful_timeout = 1, timeout_interval = 0.01, hard_timeout = 1)
     if thread
       if owner and owner.respond_to? :graceful_kill
-        owner.graceful_kill
-        end_time = Time.now + graceful_timeout
-        while thread.alive? && ((end_time - Time.now) > 0)
-          sleep(timeout_interval)
+        if Thread.current != thread
+          owner.graceful_kill
+          end_time = Time.now + graceful_timeout
+          while thread.alive? && ((end_time - Time.now) > 0)
+            sleep(timeout_interval)
+          end
+        else
+          Logger.warn "Threads cannot graceful_kill themselves"
         end
       elsif owner
         Logger.info "Thread owner #{owner.class} does not support graceful_kill"