cosmos 4.5.0 → 5.0.2.pre.beta2

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

@@ -1,650 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2017 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos'
-require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
-if RUBY_ENGINE == 'ruby'
-  require 'cosmos/tools/cmd_tlm_server/gui/interfaces_tab'
-  require 'cosmos/tools/cmd_tlm_server/gui/targets_tab'
-  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'
-  require 'cosmos/gui/dialogs/set_tlm_dialog'
-else
-  # The following stubs allow the CmdTlmServer to run under JRuby with no gui
-  require 'ostruct'
-  require 'optparse'
-
-  class QtTool
-    def self.slots(*args)
-      # Do nothing
-    end
-
-    def self.create_default_options
-      options = OpenStruct.new
-      options.redirect_io = true
-      options.title = "COSMOS Tool"
-      parser = OptionParser.new do |option_parser|
-        option_parser.banner = "Usage: ruby #{option_parser.program_name} [options]"
-        option_parser.separator("")
-
-        # Create the help option
-        option_parser.on("-h", "--help", "Show this message") do
-          puts option_parser
-          exit
-        end
-
-        # Create the version option
-        option_parser.on("-v", "--version", "Show version") do
-          puts "COSMOS Version: #{COSMOS_VERSION}"
-          puts "User Version: #{USER_VERSION}" if defined? USER_VERSION
-          exit
-        end
-
-        # Create the system option
-        option_parser.on("--system FILE", "Use an alternative system.txt file") do |arg|
-          System.instance(File.join(USERPATH, 'config', 'system', arg))
-        end
-      end
-
-      return parser, options
-    end
-
-    def self.run(option_parser = nil, options = nil)
-      Cosmos.set_working_dir do
-        option_parser, options = create_default_options() unless option_parser and options
-        option_parser.parse!(ARGV)
-        post_options_parsed_hook(options)
-      end
-    end
-  end
-end
-
-module Cosmos
-  # Implements the GUI functions of the Command and Telemetry Server. All the
-  # QT calls are implemented here. The non-GUI functionality is contained in
-  # the CmdTlmServer class.
-  class CmdTlmServerGui < QtTool
-    slots 'handle_tab_change(int)'
-
-    STOPPED = 0
-    RUNNING = 1
-    ERROR = 2
-
-    TOOL_NAME = "Command and Telemetry Server".freeze
-    BLANK = ''.freeze
-
-    attr_writer :no_prompt
-
-    if RUBY_ENGINE == 'ruby'
-      # For the CTS we display all the tables as full size
-      # Thus we don't want the table to absorb the scroll wheel events but
-      # instead pass them up to the container so the entire window will scroll.
-      class Qt::TableWidget
-        def wheelEvent(event)
-          event.ignore()
-        end
-      end
-    end
-
-    def meta_callback
-      Qt.execute_in_main_thread(true) do
-        result = SetTlmDialog.execute(self, 'Enter Metadata', 'Set Metadata', 'Cancel', 'SYSTEM', 'META')
-        exit(1) unless result
-      end
-    end
-
-    def initialize(options)
-      super(options) # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
-
-      @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
-      @replay_routers = options.replay_routers
-      @message_log = nil
-      @output_sleeper = Sleeper.new
-      @first_output = 0
-      @options = options
-
-      statusBar.showMessage("") # Show blank message to initialize status bar
-
-      initialize_actions()
-      initialize_menus()
-      initialize_central_widget()
-      Splash.execute(self) do |splash|
-        ConfigParser.splash = splash
-        process_server_messages(@options)
-        start(splash)
-        ConfigParser.splash = nil
-      end
-      complete_initialize()
-    end
-
-    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, false, @mode, @replay_routers)
-        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" 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
-        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('&Reload Configuration', self)
-      @file_reload.shortcut = Qt::KeySequence.new('Ctrl+Shift+R')
-      @file_reload.statusTip = 'Reload configuraton and reset'
-      @file_reload.connect(SIGNAL('triggered()')) do
-        CmdTlmServer.instance.reload()
-      end
-
-      # Edit actions
-      @edit_clear_counters = Qt::Action.new('&Clear Counters', self)
-      @edit_clear_counters.statusTip = 'Clear counters for all interfaces and targets'
-      @edit_clear_counters.connect(SIGNAL('triggered()')) { CmdTlmServer.clear_counters }
-    end
-
-    def initialize_menus
-      @file_menu = menuBar.addMenu('&File')
-      @file_menu.addAction(@file_reload)
-      @file_menu.addAction(@exit_action)
-
-      # Do not allow clear counters in production mode
-      unless @production
-        @edit_menu = menuBar.addMenu('&Edit')
-        @edit_menu.addAction(@edit_clear_counters)
-      end
-
-      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
-
-    def initialize_central_widget
-      # Create the central widget
-      @splitter = Qt::Splitter.new(Qt::Vertical, central_widget)
-      setCentralWidget(@splitter)
-
-      @tab_widget = Qt::TabWidget.new
-      connect(@tab_widget, SIGNAL('currentChanged(int)'), self, SLOT('handle_tab_change(int)'))
-      @splitter.addWidget(@tab_widget)
-
-      # Add the message output
-      @output = Qt::PlainTextEdit.new
-      @output.setReadOnly(true)
-      # Block count does NOT equal line numbers. Testing on Windows indicates
-      # 100 blocks equals a little over 27000 lines.
-      @output.setMaximumBlockCount(100)
-
-      @splitter.addWidget(@output)
-      # Set the stretch factor to give priority to the tab_widget (index 0) instead of the output (index 1)
-      @splitter.setStretchFactor(0, 1) # (index, stretch)
-
-      # Override stdout to the message window
-      # All code attempting to print into the GUI must use $stdout rather than STDOUT
-      @string_output = StringIO.new("", "r+")
-      $stdout = @string_output
-      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, (@mode == :REPLAY))
-      @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
-      CmdTlmServer.instance.replay_map_targets_to_interfaces
-      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
-        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') { @commands_tab.update }
-      when 3
-        handle_tab('Telemetry') { @telemetry_tab.update }
-      when 4
-        handle_tab('Routers') { @routers_tab.update }
-      when 5
-        if @mode == :CMD_TLM_SERVER
-          handle_tab('Logging') { @logging_tab.update }
-        else
-          handle_tab('Status') { @status_tab.update }
-        end
-      when 6
-        handle_tab('Status') { @status_tab.update }
-      end
-    end
-
-    # Cancel the tab sleeper and kill the tab thread so we can create a new one
-    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
-
-    # Wrapper method that starts a new thread and then loops. It ensures we are
-    # executing in the main thread and then yields to allow updates to the GUI.
-    # Finally it sleeps using a sleeper so it can be interrupted.
-    #
-    # @param name [String] Name of the tab
-    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 }
-            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")}
-        end
-      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
-    # dialog to warn them about the consequences and then gracefully shut
-    # everything down.
-    def closeEvent(event)
-      # Create are you sure dialog
-      if @no_prompt
-        continue = true
-      else
-        msg = Qt::MessageBox.new(self)
-        msg.setIcon(Qt::MessageBox::Question)
-        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
-        continue = true if msg.exec() == Qt::MessageBox::Yes
-        msg.dispose
-      end
-
-      if continue
-        stop_threads()
-        super(event)
-      else
-        event.ignore()
-      end
-    end
-
-    # Thread to process server messages. Uses handle_string_output to process
-    # the output.
-    def process_server_messages(options)
-      # Start thread to read server messages
-      @output_thread = Thread.new do
-        begin
-          while !@ready
-            sleep(1)
-          end
-          while true
-            handle_string_output()
-            break if @output_sleeper.sleep(1)
-          end
-        rescue Exception => error
-          Qt.execute_in_main_thread(true) do
-            ExceptionDialog.new(self, error, "#{options.title}: Messages Thread")
-          end
-        end
-      end
-    end
-
-    # Write any available messages to the output pane in the server GUI
-    # as well as to the server message log.
-    def handle_string_output
-      if @string_output.string[-1..-1] == "\n"
-        Qt.execute_in_main_thread(true) do
-          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; @output.add_formatted_text(out_line) }
-          @output.flush
-          if @first_output < 2
-            # Scroll to the bottom on the first two outputs for Linux
-            # Otherwise it does not stay at the bottom
-            @output.verticalScrollBar.value = @output.verticalScrollBar.maximum
-            @first_output += 1
-          end
-          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
-
-    # CmdTlmServer stop callback called by CmdTlmServer.stop. Ensures all the
-    # output is written to the message logs.
-    def stop_callback
-      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
-      # Just to avoid warning
-    end
-
-    def self.graceful_kill
-      # Just to avoid warning
-    end
-
-    def self.no_gui_handle_string_output
-      if @string_output.string[-1..-1] == "\n"
-        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 }
-        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
-
-    def self.no_gui_stop_callback
-      no_gui_handle_string_output()
-      @output_sleeper.cancel
-      Cosmos.kill_thread(self, @output_thread)
-      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, @options.replay_routers)
-
-      # 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
-        normalize_config_options(options)
-        
-        ["TERM", "INT"].each {|sig| Signal.trap(sig) {exit}}
-
-        begin
-          @output_sleeper = Sleeper.new
-          @string_output = StringIO.new("", "r+")
-          $stdout = @string_output
-          Logger.level = Logger::INFO
-          if options.replay
-            @mode = :REPLAY
-          else
-            @mode = :CMD_TLM_SERVER
-          end
-          cts = CmdTlmServer.new(options.config_file, options.production, false, @mode, options.replay_routers)
-
-          # 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()
-              break if @output_sleeper.sleep(1)
-            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 CmdTlmServer.instance
-            CmdTlmServer.instance.stop_logging('ALL') if @mode == :CMD_TLM_SERVER
-            CmdTlmServer.instance.stop
-          end
-        end
-        return false
-      else
-        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
-      end
-    end
-
-    # Entry point to the server application
-    def self.run(option_parser = nil, options = nil)
-      Cosmos.catch_fatal_exception do
-        unless option_parser and options
-          option_parser, options = create_default_options()
-          options.width = 800
-          options.height = 500
-          # Set the default title which can be overridden in the config file
-          options.title = TOOL_NAME
-          options.auto_size = false
-          options.production = false
-          options.no_prompt = false
-          options.no_gui = false
-          options.replay_routers = false
-          options.config_file = true # config_file is required
-          # Set config_dir because by default it would be config/tools/cmd_tlm_server_gui
-          options.config_dir = File.join(Cosmos::USERPATH, 'config', 'tools', 'cmd_tlm_server')
-
-          option_parser.separator "CTS Specific Options:"
-          option_parser.on("-p", "--production", "Run the server in production mode which disables the ability to stop logging.") do |arg|
-            options.production = true
-          end
-          option_parser.on("-n", "--no-prompt", "Don't prompt with Are You Sure dialog on close.") do |arg|
-            options.no_prompt = true
-          end
-          option_parser.on(nil, "--no-gui", "Run the server without a GUI") do |arg|
-            options.no_gui = true
-          end
-
-          if self.name == "Cosmos::Replay"
-            options.replay = true
-            options.title = "Replay"
-            option_parser.on(nil, "--routers", "Enable All Routers") do |arg|
-              options.replay_routers = true
-            end
-          else
-            options.replay = false
-          end
-        end
-
-        super(option_parser, options)
-      end
-    end
-  end
-end