cosmos 4.0.3 → 4.1.0

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

@@ -51,6 +51,13 @@ module Cosmos
 
     protected
 
+    def get_target_interface_name(target_name)
+      @interfaces.each do |interface_name, interface|
+        return interface_name if interface.target_names.include?(target_name)
+      end
+      nil
+    end
+
     # Processes a file and adds in the configuration defined in the file
     #
     # @param filename [String] The name of the configuration file to parse
@@ -105,6 +112,8 @@ module Cosmos
             System.targets.each do |target_name, target|
               target_filename = File.join(target.dir, 'cmd_tlm_server.txt')
               if File.exist?(target_filename)
+                # Skip this target if it's already been assigned an interface
+                next if get_target_interface_name(target.name)
                 raise parser.error("Cannot use #{keyword} with target name substitutions: #{target.name} != #{target.original_name}") if target.name != target.original_name
                 process_file(target_filename, true)
               end
@@ -116,6 +125,8 @@ module Cosmos
             parser.verify_num_parameters(1, 2, usage)
             target = System.targets[params[0].upcase]
             raise parser.error("Unknown target: #{params[0].upcase}") unless target
+            interface_name = get_target_interface_name(target.name)
+            raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
             target_filename = params[1]
             target_filename = 'cmd_tlm_server.txt' unless target_filename
             target_filename = File.join(target.dir, target_filename)
@@ -164,6 +175,8 @@ module Cosmos
               target_name = params[0].upcase
               target = System.targets[target_name]
               if target
+                interface_name = get_target_interface_name(target.name)
+                raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
                 target.interface = current_interface_or_router
                 current_interface_or_router.target_names << target_name
               else

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

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -16,6 +16,7 @@ if RUBY_ENGINE == 'ruby'
   require 'cosmos/tools/cmd_tlm_server/gui/packets_tab'
   require 'cosmos/tools/cmd_tlm_server/gui/logging_tab'
   require 'cosmos/tools/cmd_tlm_server/gui/status_tab'
+  require 'cosmos/tools/cmd_tlm_server/gui/replay_tab'
   require 'cosmos/gui/qt_tool'
   require 'cosmos/gui/dialogs/splash'
   require 'cosmos/gui/dialogs/exception_dialog'
@@ -85,7 +86,8 @@ module Cosmos
     RUNNING = 1
     ERROR = 2
 
-    TOOL_NAME = "Command and Telemetry Server"
+    TOOL_NAME = "Command and Telemetry Server".freeze
+    BLANK = ''.freeze
 
     attr_writer :no_prompt
 
@@ -109,69 +111,94 @@ module Cosmos
 
     def initialize(options)
       super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
-      Cosmos.load_cosmos_icon("cts.png")
 
+      @ready = false
+      @tabs_ready = false
+      if options.replay
+        @mode = :REPLAY
+        Cosmos.load_cosmos_icon("replay.png")
+      else
+        @mode = :CMD_TLM_SERVER
+        Cosmos.load_cosmos_icon("cts.png")
+      end
       @production = options.production
       @no_prompt = options.no_prompt
       @message_log = nil
       @output_sleeper = Sleeper.new
       @first_output = 0
-      @interfaces_tab = InterfacesTab.new(self)
-      @targets_tab = TargetsTab.new
-      @packets_tab = PacketsTab.new(self)
-      @logging_tab = LoggingTab.new(@production)
-      @status_tab = StatusTab.new
+      @options = options
 
       statusBar.showMessage(tr("")) # Show blank message to initialize status bar
 
       initialize_actions()
       initialize_menus()
       initialize_central_widget()
-      configure_tabs(options)
-      complete_initialize()
-    end
-
-    def configure_tabs(options)
       Splash.execute(self) do |splash|
         ConfigParser.splash = splash
-        splash.message = "Initializing #{TOOL_NAME}"
+        process_server_messages(@options)
+        start(splash)
+        ConfigParser.splash = nil
+      end
+      complete_initialize()
+    end
 
-        # Start the thread that will process server messages and add them to the output text
-        process_server_messages(options)
+    def start(splash)
+      splash.message = "Initializing #{@options.title}" if splash
 
+      if !CmdTlmServer.instance or @mode == :CMD_TLM_SERVER
         CmdTlmServer.meta_callback = method(:meta_callback)
-        cts = CmdTlmServer.new(options.config_file, @production)
+        cts = CmdTlmServer.new(@options.config_file, @production, false, @mode)
+        CmdTlmServerGui.configure_signal_handlers()
         cts.stop_callback = method(:stop_callback)
+        cts.reload_callback = method(:reload)
+        CmdTlmServer.replay_backend.config_change_callback = method(:config_change_callback) if @mode != :CMD_TLM_SERVER
         @message_log = CmdTlmServer.message_log
+        @ready = true
+      end
 
-        # Now that we've started the server (CmdTlmServer.new) we can populate all the tabs
-        splash.message = "Populating Tabs"
-        Qt.execute_in_main_thread(true) do
-          # Override the default title if one was given in the config file
-          self.window_title = CmdTlmServer.title if CmdTlmServer.title
-          splash.progress = 0
-          @interfaces_tab.populate_interfaces(@tab_widget)
-          splash.progress = 100/7 * 1
-          @targets_tab.populate(@tab_widget)
-          splash.progress = 100/7 * 2
-          @packets_tab.populate_commands(@tab_widget)
-          splash.progress = 100/7 * 3
-          @packets_tab.populate_telemetry(@tab_widget)
-          splash.progress = 100/7 * 4
-          @interfaces_tab.populate_routers(@tab_widget)
-          splash.progress = 100/7 * 5
-          @logging_tab.populate(@tab_widget)
-          splash.progress = 100/7 * 6
-          @status_tab.populate(@tab_widget)
-          splash.progress = 100
+      # Now that we've started the server (CmdTlmServer.new) we can populate all the tabs
+      splash.message = "Populating Tabs" if splash
+      Qt.execute_in_main_thread(true) do
+        # Override the default title if one was given in the config file
+        self.window_title = CmdTlmServer.title if CmdTlmServer.title
+        splash.progress = 0 if splash
+        @tabs_ready = false
+        if @mode == :CMD_TLM_SERVER
+          @interfaces_tab.populate_interfaces
+        else
+          @replay_tab.populate
         end
-        ConfigParser.splash = nil
+        splash.progress = 100/7 * 1 if splash
+        @targets_tab.populate
+        splash.progress = 100/7 * 2 if splash
+        @commands_tab.populate_commands
+        splash.progress = 100/7 * 3 if splash
+        @telemetry_tab.populate_telemetry
+        splash.progress = 100/7 * 4 if splash
+        @routers_tab.populate_routers
+        if @mode == :CMD_TLM_SERVER
+          splash.progress = 100/7 * 5 if splash
+          @logging_tab.populate
+        end
+        splash.progress = 100/7 * 6 if splash
+        @status_tab.populate
+        splash.progress = 100 if splash
+        @tabs_ready = true
+        @tab_widget.setCurrentIndex(0)
+        handle_tab_change(0)
       end
     end
 
     def initialize_actions
       super()
 
+      # File actions
+      @file_reload = Qt::Action.new(tr('&Reload Configuration'), self)
+      @file_reload.statusTip = tr('Reload configuraton and reset')
+      @file_reload.connect(SIGNAL('triggered()')) do
+        CmdTlmServer.instance.reload()
+      end
+
       # Edit actions
       @edit_clear_counters = Qt::Action.new(tr('&Clear Counters'), self)
       @edit_clear_counters.statusTip = tr('Clear counters for all interfaces and targets')
@@ -180,6 +207,7 @@ module Cosmos
 
     def initialize_menus
       @file_menu = menuBar.addMenu(tr('&File'))
+      @file_menu.addAction(@file_reload)
       @file_menu.addAction(@exit_action)
 
       # Do not allow clear counters in production mode
@@ -188,8 +216,12 @@ module Cosmos
         @edit_menu.addAction(@edit_clear_counters)
       end
 
-      @about_string = "#{TOOL_NAME} is the heart of the COSMOS system. "
-      @about_string << "It connects to the target and processes command and telemetry requests from other tools."
+      if @mode == :CMD_TLM_SERVER
+        @about_string = "#{TOOL_NAME} is the heart of the COSMOS system. "
+        @about_string << "It connects to the target and processes command and telemetry requests from other tools."
+      else
+        @about_string = "Replay allows playing back data into the COSMOS realtime tools. "
+      end
 
       initialize_help_menu()
     end
@@ -221,30 +253,97 @@ module Cosmos
       Logger.level = Logger::INFO
 
       @tab_thread = nil
+
+      if @mode == :CMD_TLM_SERVER
+        @interfaces_tab = InterfacesTab.new(self, InterfacesTab::INTERFACES, @tab_widget)
+      else
+        @replay_tab = ReplayTab.new(@tab_widget)
+      end
+      @targets_tab = TargetsTab.new(@tab_widget)
+      @commands_tab = PacketsTab.new(self, PacketsTab::COMMANDS, @tab_widget)
+      @telemetry_tab = PacketsTab.new(self, PacketsTab::TELEMETRY, @tab_widget)
+      @routers_tab = InterfacesTab.new(self, InterfacesTab::ROUTERS, @tab_widget)
+      if @mode == :CMD_TLM_SERVER
+        @logging_tab = LoggingTab.new(@production, @tab_widget)
+      end
+      @status_tab = StatusTab.new(@tab_widget)
+    end
+
+    def config_change_callback
+      start(nil)
+    end
+
+    def reload(confirm = true)
+      Qt.execute_in_main_thread(true) do
+        if confirm
+          msg = Qt::MessageBox.new(self)
+          msg.setIcon(Qt::MessageBox::Question)
+          msg.setText("Are you sure? All connections will temporarily disconnect as the server restarts")
+          msg.setWindowTitle('Confirm Reload')
+          msg.setStandardButtons(Qt::MessageBox::Yes | Qt::MessageBox::No)
+          continue = false
+          continue = true if msg.exec() == Qt::MessageBox::Yes
+          msg.dispose
+        else
+          continue = true
+        end
+
+        if continue
+          Splash.execute(self) do |splash|
+            ConfigParser.splash = splash
+            Qt.execute_in_main_thread(true) do
+              @tab_widget.setCurrentIndex(0)
+            end
+            if @mode == :CMD_TLM_SERVER
+              Qt.execute_in_main_thread(true) do
+                splash.message = "Stopping Threads"
+                CmdTlmServer.instance.stop_callback = nil
+                stop_threads()
+              end
+            end
+            System.reset
+            start(splash)
+            Qt.execute_in_main_thread(true) do
+              @tab_widget.setCurrentIndex(0)
+              handle_tab_change(0)
+            end
+            ConfigParser.splash = nil
+          end
+        end
+      end
     end
 
     # Called when the user changes tabs in the Server application. It kills the
     # currently executing tab and then creates a new thread to update the GUI
     # for the selected tab.
     def handle_tab_change(index)
+      return unless @tabs_ready
       kill_tab_thread()
       @tab_sleeper = Sleeper.new
 
       case index
       when 0
-        handle_tab('Interfaces') { @interfaces_tab.update(InterfacesTab::INTERFACES) }
+        if @mode == :CMD_TLM_SERVER
+          handle_tab('Interfaces') { @interfaces_tab.update }
+        else
+          handle_tab('Replay', 0.5) { @replay_tab.update }
+        end
       when 1
         handle_tab('Targets') { @targets_tab.update }
       when 2
-        handle_tab('Commands') { @packets_tab.update(PacketsTab::COMMANDS) }
+        handle_tab('Commands') { @commands_tab.update }
       when 3
-        handle_tab('Telemetry') { @packets_tab.update(PacketsTab::TELEMETRY) }
+        handle_tab('Telemetry') { @telemetry_tab.update }
       when 4
-        handle_tab('Routers') { @interfaces_tab.update(InterfacesTab::ROUTERS) }
+        handle_tab('Routers') { @routers_tab.update }
       when 5
-        handle_tab('Logging') { @logging_tab.update }
+        if @mode == :CMD_TLM_SERVER
+          handle_tab('Logging') { @logging_tab.update }
+        else
+          handle_tab('Status') { @status_tab.update }
+        end
       when 6
-        handle_status_tab()
+        handle_tab('Status') { @status_tab.update }
       end
     end
 
@@ -252,7 +351,9 @@ module Cosmos
     def kill_tab_thread
       @tab_sleeper ||= nil
       @tab_sleeper.cancel if @tab_sleeper
+      @tab_thread_shutdown = true
       Qt::CoreApplication.instance.processEvents
+      Qt::RubyThreadFix.queue.pop.call until Qt::RubyThreadFix.queue.empty?
       Cosmos.kill_thread(self, @tab_thread)
       @tab_thread = nil
     end
@@ -262,12 +363,18 @@ module Cosmos
     # Finally it sleeps using a sleeper so it can be interrupted.
     #
     # @param name [String] Name of the tab
-    def handle_tab(name)
+    def handle_tab(name, period = 1.0)
+      @tab_thread_shutdown = false
       @tab_thread = Thread.new do
         begin
           while true
+            start_time = Time.now.sys
+            break if @tab_thread_shutdown
             Qt.execute_in_main_thread(true) { yield }
-            break if @tab_sleeper.sleep(1)
+            total_time = Time.now.sys - start_time
+            if total_time > 0.0 and total_time < period
+              break if @tab_sleeper.sleep(period - total_time)
+            end
           end
         rescue Exception => error
           Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : #{name} Tab Thread")}
@@ -275,22 +382,11 @@ module Cosmos
       end
     end
 
-    # Update the status tab of the server
-    def handle_status_tab
-      @tab_thread = Thread.new do
-        begin
-          while true
-            start_time = Time.now.sys
-            Qt.execute_in_main_thread(true) { @status_tab.update }
-            total_time = Time.now.sys - start_time
-            if total_time > 0.0 and total_time < 1.0
-              break if @tab_sleeper.sleep(1.0 - total_time)
-            end
-          end
-        rescue Exception => error
-          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Status Tab Thread")}
-        end
-      end
+    def stop_threads
+      kill_tab_thread()
+      @replay_tab.shutdown if @replay_tab
+      CmdTlmServer.instance.stop_logging('ALL') if @mode == :CMD_TLM_SERVER
+      CmdTlmServer.instance.stop
     end
 
     # Called when the user tries to close the server application. Popup a
@@ -303,7 +399,11 @@ module Cosmos
       else
         msg = Qt::MessageBox.new(self)
         msg.setIcon(Qt::MessageBox::Question)
-        msg.setText("Are you sure? All tools connected to this CmdTlmServer will lose connections and cease to function if the CmdTlmServer is closed.")
+        if @mode == :CMD_TLM_SERVER
+          msg.setText("Are you sure? All tools connected to this CmdTlmServer will lose connections and cease to function if the CmdTlmServer is closed.")
+        else
+          msg.setText("Are you sure? All tools connected to this Replay will lose connections and cease to function if the Replay is closed.")
+        end
         msg.setWindowTitle('Confirm Close')
         msg.setStandardButtons(Qt::MessageBox::Yes | Qt::MessageBox::No)
         continue = false
@@ -312,9 +412,7 @@ module Cosmos
       end
 
       if continue
-        kill_tab_thread()
-        CmdTlmServer.instance.stop_logging('ALL')
-        CmdTlmServer.instance.stop
+        stop_threads()
         super(event)
       else
         event.ignore()
@@ -327,7 +425,7 @@ module Cosmos
       # Start thread to read server messages
       @output_thread = Thread.new do
         begin
-          while !@message_log
+          while !@ready
             sleep(1)
           end
           while true
@@ -347,10 +445,10 @@ module Cosmos
     def handle_string_output
       if @string_output.string[-1..-1] == "\n"
         Qt.execute_in_main_thread(true) do
-          lines_to_write = ''
+          lines_to_write = []
           string = @string_output.string.clone
           @string_output.string = @string_output.string[string.length..-1]
-          string.each_line {|out_line| @output.add_formatted_text(out_line); lines_to_write << out_line }
+          string.each_line {|out_line| lines_to_write << out_line; @output.add_formatted_text(out_line) }
           @output.flush
           if @first_output < 2
             # Scroll to the bottom on the first two outputs for Linux
@@ -358,7 +456,9 @@ module Cosmos
             @output.verticalScrollBar.value = @output.verticalScrollBar.maximum
             @first_output += 1
           end
-          @message_log.write(lines_to_write)
+          clean_lines, messages = CmdTlmServerGui.process_output_colors(lines_to_write)
+          @message_log.write(clean_lines) if @message_log
+          messages.each {|msg| CmdTlmServer.instance.post_server_message(msg) }
         end
       end
     end
@@ -366,11 +466,13 @@ module Cosmos
     # CmdTlmServer stop callback called by CmdTlmServer.stop. Ensures all the
     # output is written to the message logs.
     def stop_callback
-      handle_string_output()
-      @output_sleeper.cancel
-      Qt::CoreApplication.processEvents()
-      Cosmos.kill_thread(self, @output_thread)
-      handle_string_output()
+      Qt.execute_in_main_thread(true) do
+        handle_string_output()
+        @output_sleeper.cancel
+        Qt::CoreApplication.processEvents()
+        Cosmos.kill_thread(self, @output_thread)
+        handle_string_output()
+      end
     end
 
     def graceful_kill
@@ -383,12 +485,14 @@ module Cosmos
 
     def self.no_gui_handle_string_output
       if @string_output.string[-1..-1] == "\n"
-        lines_to_write = ''
+        lines_to_write = []
         string = @string_output.string.clone
         @string_output.string = @string_output.string[string.length..-1]
         string.each_line {|out_line| lines_to_write << out_line }
-        @message_log.write(lines_to_write)
-        STDOUT.print lines_to_write if STDIN.isatty # Have a console
+        clean_lines, messages = CmdTlmServerGui.process_output_colors(lines_to_write)
+        @message_log.write(clean_lines) if @mode == :CMD_TLM_SERVER
+        messages.each {|msg| CmdTlmServer.instance.post_server_message(msg) }
+        STDOUT.print clean_lines if STDIN.isatty # Have a console
       end
     end
 
@@ -399,7 +503,47 @@ module Cosmos
       no_gui_handle_string_output()
     end
 
+    def self.no_gui_reload_callback(confirm = false)
+      CmdTlmServer.instance.stop_logging('ALL') if @mode == :CMD_TLM_SERVER
+      CmdTlmServer.instance.stop_callback = nil
+      CmdTlmServer.instance.stop
+      System.reset
+      cts = CmdTlmServer.new(@options.config_file, @options.production, false, @mode)
+
+      # Signal catching needs to be repeated here because Puma interferes
+      ["TERM", "INT"].each {|sig| Signal.trap(sig) {exit}}
+
+      @message_log = CmdTlmServer.message_log
+      cts.stop_callback = method(:no_gui_stop_callback)
+      cts.reload_callback = method(:no_gui_reload_callback)
+    end
+
+    def self.process_output_colors(lines)
+      clean_lines = ''
+      messages = []
+      lines.each do |line|
+        if line =~ /<G>/
+          line.gsub!(/<G>/, BLANK)
+          messages << [line.strip, 'GREEN']
+        elsif line =~ /<Y>/
+          line.gsub!(/<Y>/, BLANK)
+          messages << [line.strip, 'YELLOW']
+        elsif line =~ /<R>/
+          line.gsub!(/<R>/, BLANK)
+          messages << [line.strip, 'RED']
+        elsif line =~ /<B>/
+          line.gsub!(/<B>/, BLANK)
+          messages << [line.strip, 'BLUE']
+        else
+          messages << [line.strip, 'BLACK']
+        end
+        clean_lines << line
+      end
+      return [clean_lines, messages]
+    end
+
     def self.post_options_parsed_hook(options)
+      @options = options
       if options.no_gui
         ["TERM", "INT"].each {|sig| Signal.trap(sig) {exit}}
 
@@ -408,8 +552,18 @@ module Cosmos
           @string_output = StringIO.new("", "r+")
           $stdout = @string_output
           Logger.level = Logger::INFO
-          cts = CmdTlmServer.new(options.config_file, options.production)
+          if options.replay
+            @mode = :REPLAY
+          else
+            @mode = :CMD_TLM_SERVER
+          end
+          cts = CmdTlmServer.new(options.config_file, options.production, false, @mode)
+
+          # Signal catching needs to be repeated here because Puma interferes
+          ["TERM", "INT"].each {|sig| Signal.trap(sig) {exit}}
+
           @message_log = CmdTlmServer.message_log
+          @ready = true
           @output_thread = Thread.new do
             while true
               no_gui_handle_string_output()
@@ -417,29 +571,34 @@ module Cosmos
             end
           end
           cts.stop_callback = method(:no_gui_stop_callback)
+          cts.reload_callback = method(:no_gui_reload_callback)
           sleep # Sleep until waked by signal
         ensure
-          if defined? cts and cts
-            cts.stop_logging('ALL')
-            cts.stop
+          if CmdTlmServer.instance
+            CmdTlmServer.instance.stop_logging('ALL') if @mode == :CMD_TLM_SERVER
+            CmdTlmServer.instance.stop
           end
         end
         return false
       else
-        ["TERM", "INT"].each do |sig|
-          Signal.trap(sig) do
-            # No synchronization is allowed in trap context, so we have
-            # to spawn a thread here to send the close event.
-            Thread.new do
-              Qt.execute_in_main_thread(true) do
-                @@window.no_prompt = true
-                @@window.closeEvent(Qt::CloseEvent.new())
-                exit
-              end
+        CmdTlmServerGui.configure_signal_handlers()
+        return true
+      end
+    end
+
+    def self.configure_signal_handlers
+      ["TERM", "INT"].each do |sig|
+        Signal.trap(sig) do
+          # No synchronization is allowed in trap context, so we have
+          # to spawn a thread here to send the close event.
+          Thread.new do
+            Qt.execute_in_main_thread(true) do
+              @@window.no_prompt = true
+              @@window.closeEvent(Qt::CloseEvent.new())
+              exit
             end
           end
         end
-        return true
       end
     end
 
@@ -457,6 +616,13 @@ module Cosmos
           options.production = false
           options.no_prompt = false
           options.no_gui = false
+          if self.name == "Cosmos::Replay"
+            options.replay = true
+            options.title = "Replay"
+          else
+            options.replay = false
+          end
+
           option_parser.separator "CTS Specific Options:"
           option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
             options.config_file = arg