cosmos 3.9.1 → 3.9.2

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

@@ -73,7 +73,7 @@ module Cosmos
     # The default host
     DEFAULT_HOST = 'localhost'
     # The default configuration file name
-    DEFAULT_CONFIG_FILE = 'cmd_tlm_server.txt'
+    DEFAULT_CONFIG_FILE = File.join(Cosmos::USERPATH, 'config', 'tools', 'cmd_tlm_server', 'cmd_tlm_server.txt')
     # The maximum number of limits events that are queued. Used when
     # subscribing to limits events.
     DEFAULT_LIMITS_EVENT_QUEUE_SIZE = 1000
@@ -128,7 +128,7 @@ module Cosmos
       @next_packet_data_queue_id = 1
 
       # Process cmd_tlm_server.txt
-      @config = CmdTlmServerConfig.new(File.join('config', 'tools', 'cmd_tlm_server', config_file))
+      @config = CmdTlmServerConfig.new(config_file)
       @background_tasks = BackgroundTasks.new(@config)
       @commanding = Commanding.new(@config)
       @interfaces = Interfaces.new(@config, method(:identified_packet_callback))
@@ -187,6 +187,7 @@ module Cosmos
       end
 
       @routers.add_preidentified('PREIDENTIFIED_ROUTER', System.instance.ports['CTS_PREIDENTIFIED'])
+      @routers.add_cmd_preidentified('PREIDENTIFIED_CMD_ROUTER', System.instance.ports['CTS_CMD_ROUTER'])
       System.telemetry.limits_change_callback = method(:limits_change_callback)
       @interfaces.start
       @routers.start

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

@@ -89,6 +89,15 @@ module Cosmos
         command.buffer = packet.buffer
       end
 
+      # Write to Command Routers
+      interface.cmd_routers.each do |cmd_router|
+        begin
+          cmd_router.write(command) if cmd_router.write_allowed? and cmd_router.connected?
+        rescue => err
+          Logger.error "Problem writing to cmd router #{cmd_router.name} - #{err.class}:#{err.message}"
+        end
+      end
+
       # Write to command packet logs
       interface.packet_log_writer_pairs.each do |packet_log_writer_pair|
         packet_log_writer_pair.cmd_log_writer.write(command)

data/lib/cosmos/tools/cmd_tlm_server/gui/interfaces_tab.rb

@@ -104,9 +104,9 @@ module Cosmos
       interfaces_table.setRowCount(interfaces.all.length)
       interfaces_table.setColumnCount(10)
       if name == ROUTERS
-        interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts  "])
+        interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Pkts Rcvd  ", "  Pkts Sent  "])
       else
-        interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts  "])
+        interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts "])
       end
 
       populate_interface_table(name, interfaces, interfaces_table)

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

@@ -57,7 +57,11 @@ module Cosmos
       @thread = Thread.new do
         @cancel_thread = false
         begin
-          Logger.info "Starting packet reading for #{@interface.name}"
+          if @interface.read_allowed?
+            Logger.info "Starting packet reading for #{@interface.name}"
+          else
+            Logger.info "Starting connection maintenance for #{@interface.name}"
+          end
           while true
             break if @cancel_thread
             unless @interface.connected?
@@ -77,28 +81,33 @@ module Cosmos
               end
             end
 
-            begin
-              packet = @interface.read
-              unless packet
-                Logger.info "Clean disconnect from #{@interface.name} (returned nil)"
-                handle_connection_lost(nil)
+            if @interface.read_allowed?
+              begin
+                packet = @interface.read
+                unless packet
+                  Logger.info "Clean disconnect from #{@interface.name} (returned nil)"
+                  handle_connection_lost(nil)
+                  if @cancel_thread
+                    break
+                  else
+                    next
+                  end
+                end
+                packet.received_time = Time.now unless packet.received_time
+              rescue Exception => err
+                handle_connection_lost(err)
                 if @cancel_thread
                   break
                 else
                   next
                 end
               end
-              packet.received_time = Time.now unless packet.received_time
-            rescue Exception => err
-              handle_connection_lost(err)
-              if @cancel_thread
-                break
-              else
-                next
-              end
-            end
 
-            handle_packet(packet)
+              handle_packet(packet)
+            else
+              @thread_sleeper.sleep(1)
+              handle_connection_lost(nil) if !@interface.connected?
+            end
           end  # loop
         rescue Exception => error
           if @fatal_exception_callback
@@ -121,7 +130,7 @@ module Cosmos
         @thread_sleeper.cancel
         @interface.disconnect
       end
-      Cosmos.kill_thread(self, @thread) if @thread != Thread.current
+      Cosmos.kill_thread(self, @thread) if @thread and @thread != Thread.current
     end
 
     def graceful_kill

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

@@ -27,6 +27,16 @@ module Cosmos
       @identified_packet_callback = identified_packet_callback
     end
 
+    # Get the targets of an interface
+    #
+    # @param interface_name [String] Interface to return target list
+    # @return [Array<String>] All the targets mapped to this interface
+    def targets(interface_name)
+      interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless interface
+      interface.target_names
+    end
+
     # Determines all targets in the system and maps them to the given interface
     #
     # @param interface_name [String] The interface to map all targets to
@@ -102,6 +112,22 @@ module Cosmos
       return new_interface
     end
 
+    # Get info about an interface by name
+    #
+    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric, 
+    #   Numeric, Numeric>] Array containing \[state, num_clients, 
+    #   write_queue_size, read_queue_size, bytes_written, bytes_read, 
+    #   write_count, read_count] for the interface
+    def get_info(interface_name)
+      interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless interface
+
+      return [state(interface_name),      interface.num_clients, 
+              interface.write_queue_size, interface.read_queue_size,
+              interface.bytes_written,    interface.bytes_read,
+              interface.write_count,      interface.read_count]
+    end
+
     protected
 
     # Start an interface's packet reading thread

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

@@ -121,6 +121,35 @@ module Cosmos
       return packet_log_writer_pair.tlm_log_writer.filename
     end
 
+    # @param packet_log_writer_name [String] The name of the log writer to
+    #   get info for
+    # @return [Array<Boolean, Numeric, String, Numeric, Boolean, Numeric, 
+    #   String, Numeric>] array containing \[cmd log enabled, cmd queue size, 
+    #   cmd filename, cmd file size, tlm log enabled, tlm queue size,
+    #   tlm filename, tlm file size] for the packet log writer
+    def get_info(packet_log_writer_name = 'DEFAULT')
+      packet_log_writer_pair = @config.packet_log_writer_pairs[packet_log_writer_name.upcase]
+      raise "Unknown packet log writer: #{packet_log_writer_name}" unless packet_log_writer_pair
+      cmd_file_size = 0
+      begin
+        cmd_file_size = File.size(packet_log_writer_pair.cmd_log_writer.filename) if packet_log_writer_pair.cmd_log_writer.filename
+      rescue Exception
+      end
+      tlm_file_size = 0
+      begin
+        tlm_file_size = File.size(packet_log_writer_pair.tlm_log_writer.filename) if packet_log_writer_pair.tlm_log_writer.filename
+      rescue Exception
+      end
+      return [packet_log_writer_pair.cmd_log_writer.logging_enabled,
+              packet_log_writer_pair.cmd_log_writer.queue.size,
+              packet_log_writer_pair.cmd_log_writer.filename,
+              cmd_file_size,
+              packet_log_writer_pair.tlm_log_writer.logging_enabled,
+              packet_log_writer_pair.tlm_log_writer.queue.size,
+              packet_log_writer_pair.tlm_log_writer.filename,
+              tlm_file_size]
+    end
+
     # @return [Hash<String, PacketLogWriterPair>] Packet log writer hash. Each
     #   pair encapsulates a command and telemetry log writer.
     def all

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

@@ -45,6 +45,23 @@ module Cosmos
       end
     end
 
+    # Adds a Preidentified command router to the system with given name and port.
+    # All interfaces defined by the Command/Telemetry configuration are
+    # directed to this router to output commands
+    #
+    # @param router_name [String] Name of the command router
+    # @param port [Integer] Port to pass to the {TcpipServerInterface}
+    def add_cmd_preidentified(cmd_router_name, port)
+      cmd_router_name = cmd_router_name.upcase
+      cmd_router = TcpipServerInterface.new(port, nil, 10.0, nil, 'PREIDENTIFIED')
+      cmd_router.name = cmd_router_name
+      cmd_router.disable_disconnect = true
+      @config.routers[cmd_router_name] = cmd_router
+      @config.interfaces.each do |interface_name, interface|
+        interface.cmd_routers << cmd_router
+      end
+    end
+
     # Recreate a router with new initialization parameters
     #
     # @param router_name [String] Name of the router
@@ -73,6 +90,22 @@ module Cosmos
       return new_router
     end
 
+    # Get info about an router by name
+    #
+    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric, 
+    #   Numeric, Numeric>] Array containing \[state, num_clients, 
+    #   write_queue_size, read_queue_size, bytes_written, bytes_read, 
+    #   read_count, write_count] for the interface
+    def get_info(router_name)
+      router = @config.routers[router_name.upcase]
+      raise "Unknown router: #{router_name}" unless router
+
+      return [state(router_name),      router.num_clients, 
+              router.write_queue_size, router.read_queue_size,
+              router.bytes_written,    router.bytes_read,
+              router.read_count,       router.write_count]
+    end
+
     protected
 
     # Start an router's packet reading thread

data/lib/cosmos/tools/data_viewer/data_viewer.rb

@@ -57,7 +57,7 @@ module Cosmos
       @components = []
       @packets = []
       @packet_to_components_mapping = {}
-      @config_filename = File.join(Cosmos::USERPATH, 'config', 'tools', 'data_viewer', options.config_file)
+      @config_filename = options.config_file
       process_config()
 
       # Load System Definition and Event Data

data/lib/cosmos/tools/launcher/launcher.rb

@@ -18,19 +18,21 @@ Cosmos.catch_fatal_exception do
 end
 
 module Cosmos
-
+  # Provides a group of buttons which can be configured to launch any of the
+  # COSMOS tools as well as any custom applications.
   class Launcher < QtTool
-
     def initialize(options)
       super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
 
-      # Set environment variable of COSMOS_USERPATH so that all launched apps know where to find the configuration
+      # Set environment variable of COSMOS_USERPATH so that all launched apps
+      # know where to find the configuration
       ENV['COSMOS_USERPATH'] = Cosmos::USERPATH
 
       Cosmos.load_cosmos_icon("launcher.png")
       layout.setSizeConstraint(Qt::Layout::SetFixedSize)
 
-      @about_string = "Launcher provides a list of applications to launch at the click of a button. It can also launch multiple applications and configure their exact placement on the screen."
+      @about_string = "Launcher provides a list of applications to launch at the click of a button. "\
+        "It can also launch multiple applications and configure their exact placement on the screen."
       initialize_actions()
       initialize_menus()
       initialize_central_widget()
@@ -38,29 +40,21 @@ module Cosmos
     end
 
     def initialize_menus
-      # File Menu
       @file_menu = menuBar().addMenu(tr('&File'))
       @file_menu.addAction(@exit_action)
-
-      # Help Menu
       initialize_help_menu()
     end
 
     def initialize_central_widget
-      # Create the central widget
-      central_widget = Qt::Widget.new
-      setCentralWidget(central_widget)
-
-      # Read the configuration file
-      config_file = File.join(Cosmos::USERPATH, 'config', 'tools', 'launcher', @options.config_file)
       begin
-        config = LauncherConfig.new(config_file)
+        config = LauncherConfig.new(@options.config_file)
       rescue => error
-        ExceptionDialog.new(self, error, "Error parsing #{config_file}")
+        ExceptionDialog.new(self, error, "Error parsing #{@options.config_file}")
       end
 
-      # Set the title
       self.window_title = config.title
+      central_widget = Qt::Widget.new
+      setCentralWidget(central_widget)
 
       # Create each button or divider
       default_icon_filename = 'COSMOS_64x64.png'
@@ -102,6 +96,7 @@ module Cosmos
             "font-family:#{config.tool_font_settings[0]}; " \
             "font-size:#{config.tool_font_settings[1]}px"
           label.setStyleSheet(stylesheet)
+          label.setObjectName("ButtonLabel")
           label.wordWrap = true
           label.setFixedWidth(70)
           label.setSizePolicy(Qt::SizePolicy::Fixed, Qt::SizePolicy::Fixed)
@@ -115,6 +110,7 @@ module Cosmos
 
         when :DIVIDER
           divider = Qt::Frame.new
+          divider.setObjectName("Divider")
           divider.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Raised)
           divider.setLineWidth(1)
           divider.setMidLineWidth(1)
@@ -126,6 +122,7 @@ module Cosmos
             "font-family:#{config.label_font_settings[0]}; " \
             "font-size:#{config.label_font_settings[1]}px"
           label.setStyleSheet(stylesheet)
+          label.setObjectName("Label")
           widgets << label
 
         else
@@ -172,17 +169,9 @@ module Cosmos
         unless option_parser and options
           option_parser, options = create_default_options()
           options.title = 'Launcher'
-          options.config_file = 'launcher.txt'
-          option_parser.separator "Launcher Specific Options:"
-          option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
-            options.config_file = arg
-          end
         end
-
         super(option_parser, options)
       end
     end
-
-  end # class Launcher
-
+  end
 end

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

@@ -228,10 +228,6 @@ module Cosmos
     # @return [String] Message indicating success or fail
     def open_config(filename)
       return "" unless filename
-
-      unless Pathname.new(filename).absolute?
-        filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'limits_monitor', filename)
-      end
       return "Configuration file #{filename} not found!" unless File.exist?(filename)
 
       @ignored = []
@@ -595,7 +591,7 @@ module Cosmos
     end
 
     # @return [String] Fully qualified path to the configuration file
-    def config_path
+    def default_config_path
       # If the config file has been set then just return it
       return @filename if @filename
       # This is the default path to the configuration files
@@ -605,7 +601,7 @@ module Cosmos
     # Opens the configuration file and loads the ignored items
     def open_config_file
       filename = Qt::FileDialog::getOpenFileName(self,
-        "Open Configuration File", config_path())
+        "Open Configuration File", default_config_path())
       unless filename.nil? || filename.empty?
         result = @limits_items.open_config(filename)
         statusBar.showMessage(tr(result))
@@ -615,7 +611,7 @@ module Cosmos
     # Saves the ignored items to the configuration file
     def save_config_file
       filename = Qt::FileDialog.getSaveFileName(self,
-        'Save As...', config_path(), 'Configuration Files (*.txt)')
+        'Save As...', default_config_path(), 'Configuration Files (*.txt)')
       unless filename.nil? || filename.empty?
         result = @limits_items.save_config(filename)
         statusBar.showMessage(tr(result))

data/lib/cosmos/tools/packet_viewer/packet_viewer.rb

@@ -334,16 +334,16 @@ module Cosmos
           derived = []
           System.telemetry.items(target_name, packet_name).each do |item|
             if item.data_type == :DERIVED
-              derived << [item.name, item.states, item.description]
+              derived << [item.name, item.states, item.description, true]
             else
-              tlm_items << [item.name, item.states, item.description]
+              tlm_items << [item.name, item.states, item.description, false]
               @derived_row += 1
             end
           end
           tlm_items.concat(derived) # Tack the derived onto the end
         else
           System.telemetry.items(target_name, packet_name).each do |item|
-            tlm_items << [item.name, item.states, item.description]
+            tlm_items << [item.name, item.states, item.description, item.data_type == :DERIVED]
           end
         end
       rescue
@@ -360,8 +360,9 @@ module Cosmos
       row = 0
       featured_item = nil
       @ignored_rows = []
-      tlm_items.each do |tlm_name, states, description|
+      tlm_items.each do |tlm_name, states, description, derived|
         @ignored_rows << row if System.targets[target_name].ignored_items.include?(tlm_name)
+        tlm_name = "*#{tlm_name}" if derived
         item = Qt::TableWidgetItem.new(tr("#{tlm_name}:"))
         item.setTextAlignment(Qt::AlignRight)
         item.setFlags(Qt::NoItemFlags | Qt::ItemIsSelectable)
@@ -497,6 +498,7 @@ module Cosmos
       item = @table.itemAt(point)
       if item
         item_name = @table.item(item.row, 0).text[0..-2] # Remove :
+        item_name = item_name[1..-1] if item_name[0] == '*'
         if target_name.length > 0 and packet_name.length > 0 and item_name.length > 0
           menu = Qt::Menu.new()
 

data/lib/cosmos/tools/script_runner/script_runner.rb

@@ -33,7 +33,6 @@ module Cosmos
       Cosmos.load_cosmos_icon("script_runner.png")
       setAcceptDrops(true) # Allow dropping in files
 
-      @config_file = options.config_file
       @server_config_file = options.server_config_file
 
       # Add procedures to search path
@@ -50,22 +49,35 @@ module Cosmos
       @running_icon = Cosmos.get_icon('running.png')
       @no_icon = Qt::Icon.new
 
-      # Handle configuration
-      filename = File.join(::Cosmos::USERPATH, %w(config tools script_runner), @config_file)
-      if File.exist?(filename)
-        ScriptRunnerConfig.new(filename)
-      elsif @config_file != 'script_runner.txt'
-        raise "Could not find config file #{filename}"
+      if File.exist?(options.config_file)
+        ScriptRunnerConfig.new(options.config_file)
+      else
+        raise "Could not find config file #{options.config_file}"
       end
 
       @procedure_dir = System.paths['PROCEDURES'][0]
       @debug = false
 
       # Create the initial tab(s)
-      if ARGV.length == 0
+      initial_tabs = []
+      ARGV.each do |argv_filename|
+        proc_filename = find_procedure(argv_filename)
+        initial_tabs << proc_filename if proc_filename
+      end
+      if options.run_procedure
+        options.run_procedure = find_procedure(options.run_procedure)
+        initial_tabs << options.run_procedure if options.run_procedure
+      end
+      initial_tabs.uniq!
+
+      if initial_tabs.length == 0
         create_tab()
       else
-        ARGV.each {|argv_filename| create_tab(argv_filename)}
+        initial_tabs.each {|filename| create_tab(filename)}
+      end
+
+      if options.run_procedure
+        run_procedure(options.run_procedure)
       end
     end
 
@@ -468,6 +480,7 @@ module Cosmos
           close_active_tab()
         else
           active_script_runner_frame().stop_message_log
+          active_script_runner_frame().clear_breakpoints
           @tab_book.setTabText(0, '  Untitled  ')
           @tab_book.currentTab.clear
         end
@@ -852,6 +865,7 @@ module Cosmos
     def close_active_tab
       if @tab_book.count > 1
         active_script_runner_frame().stop_message_log
+        active_script_runner_frame().clear_breakpoints
         tab_index = @tab_book.currentIndex
         @tab_book.removeTab(tab_index)
         if tab_index >= 1
@@ -902,6 +916,37 @@ module Cosmos
       return safe_to_continue
     end
 
+    def find_procedure(filename)
+      # If the filename is already sufficient, just expand the path.
+      return File.expand_path(filename) if File.exist?(filename)
+
+      # If the filename wasn't sufficient, can we find the file in one of the
+      # system procedure directories?
+      System.paths['PROCEDURES'].each do |path|
+        new_filename = File.join(path, filename)
+        return File.expand_path(new_filename) if File.exist?(new_filename)
+      end
+
+      # Ok, how about one of the target procedure directories?
+      System.targets.each do |target_name, target|
+        new_filename = File.join(target.dir, 'procedures', filename)
+        return File.expand_path(new_filename) if File.exist?(new_filename)
+      end
+
+      # Couldn't find the file anywhere.
+      return nil
+    end
+
+    def run_procedure(filename)
+      # Switch to the desired tab and begin execution
+      @tab_book.tabs.each_with_index do |tab, index|
+        if tab.filename == filename
+          @tab_book.setCurrentIndex(index)
+        end
+      end
+      @tab_book.currentTab.run()
+    end
+
     def self.run(option_parser = nil, options = nil)
       Cosmos.catch_fatal_exception do
         unless option_parser and options
@@ -912,6 +957,7 @@ module Cosmos
           options.auto_size = false
           options.config_file = "script_runner.txt"
           options.server_config_file = CmdTlmServer::DEFAULT_CONFIG_FILE
+          options.run_procedure = nil
 
           option_parser.separator "Script Runner Specific Options:"
           option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
@@ -920,6 +966,9 @@ module Cosmos
           option_parser.on("-s", "--server FILE", "Use the specified server configuration file for disconnect mode") do |arg|
             options.server_config_file = arg
           end
+          option_parser.on("-r", "--run FILE", "Open and run the specified procedure") do |arg|
+            options.run_procedure = arg
+          end
         end
 
         super(option_parser, options)