cosmos 3.0.0

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

@@ -0,0 +1,1008 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 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'
+require 'cosmos/gui/qt_tool'
+require 'cosmos/gui/dialogs/splash'
+require 'cosmos/gui/dialogs/cmd_tlm_raw_dialog'
+require 'cosmos/gui/dialogs/exception_dialog'
+require 'cosmos/gui/dialogs/set_tlm_dialog'
+
+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
+
+    CMD = "Command"
+    TLM = "Telemetry"
+
+    # 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
+
+    def meta_callback(meta_target_name, meta_packet_name)
+      Qt.execute_in_main_thread(true) do
+        result = SetTlmDialog.execute(self, 'Enter Metadata', 'Set Metadata', 'Cancel', meta_target_name, meta_packet_name)
+        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
+      Cosmos.load_cosmos_icon("cts.png")
+
+      @production = options.production
+      @no_prompt = options.no_prompt
+      @message_log = nil
+
+      statusBar.showMessage(tr("")) # Show blank message to initialize status bar
+
+      initialize_actions()
+      initialize_menus()
+      initialize_central_widget()
+      complete_initialize()
+
+      Splash.execute(self) do |splash|
+        ConfigParser.splash = splash
+        splash.message = "Initializing #{CMD} and #{TLM} Server"
+
+        # Start the thread that will process server messages and add them to the output text
+        process_server_messages(options)
+
+        CmdTlmServer.meta_callback = method(:meta_callback)
+        CmdTlmServer.new(options.config_file, @production)
+        @message_log = CmdTlmServer.message_log
+
+        # 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
+          populate_interfaces('Interfaces')
+          splash.progress = 100/7 * 1
+          populate_targets()
+          splash.progress = 100/7 * 2
+          populate_packets(CMD)
+          splash.progress = 100/7 * 3
+          populate_packets(TLM)
+          splash.progress = 100/7 * 4
+          populate_interfaces('Routers')
+          splash.progress = 100/7 * 5
+          populate_logging()
+          splash.progress = 100/7 * 6
+          populate_status()
+          splash.progress = 100
+          handle_tab_change(0)
+        end
+        ConfigParser.splash = nil
+      end
+    end
+
+    def initialize_actions
+      super()
+
+      # Edit actions
+      @edit_clear_counters = Qt::Action.new(tr('&Clear Counters'), self)
+      @edit_clear_counters.statusTip = tr('Clear counters for all interfaces and targets')
+      @edit_clear_counters.connect(SIGNAL('triggered()')) { edit_clear_counters() }
+    end
+
+    def initialize_menus
+      @file_menu = menuBar.addMenu(tr('&File'))
+      @file_menu.addAction(@exit_action)
+
+      # Do not allow clear counters in production mode
+      unless @production
+        @edit_menu = menuBar.addMenu(tr('&Edit'))
+        @edit_menu.addAction(@edit_clear_counters)
+      end
+
+      @about_string = "#{CMD} and #{TLM} Server is the heart of the COSMOS system. "
+      @about_string << "It connects to the target and processes command and telemetry requests from other tools."
+
+      initialize_help_menu()
+    end
+
+    ###########################################
+    # Edit Menu Options
+    ###########################################
+
+    # Edit->Clear Counters
+    def edit_clear_counters
+      CmdTlmServer.clear_counters
+    end
+
+    def initialize_central_widget
+      # Create the central widget
+      @splitter = Qt::Splitter.new(Qt::Vertical, central_widget)
+      setCentralWidget(@splitter)
+
+      @tabbook = Qt::TabWidget.new
+      connect(@tabbook, SIGNAL('currentChanged(int)'), self, SLOT('handle_tab_change(int)'))
+      @splitter.addWidget(@tabbook)
+
+      # Add the message output
+      @output = Qt::PlainTextEdit.new
+      @output.setReadOnly(true)
+      @output.setMaximumBlockCount(10000) # 10000 lines of history will be displayed
+
+      @splitter.addWidget(@output)
+      # Set the stretch factor to give priority to the tabbook (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
+    end
+
+    def kill_tab_thread
+      if @tab_thread != nil
+        @tab_thread.kill()
+        @tab_thread = nil
+      end
+    end
+
+    def handle_tab_change(index)
+      kill_tab_thread()
+      case index
+      when 0
+        handle_interfaces_tab('Interfaces')
+      when 1
+        handle_targets_tab()
+      when 2
+        handle_packets_tab(CMD)
+      when 3
+        handle_packets_tab(TLM)
+      when 4
+        handle_interfaces_tab('Routers')
+      when 5
+        handle_logging_tab()
+      when 6
+        handle_status_tab()
+      end
+    end
+
+    def populate_interfaces(name)
+      @interfaces_table ||= {}
+
+      if name == 'Routers'
+        interfaces = CmdTlmServer.routers
+      else
+        interfaces = CmdTlmServer.interfaces
+      end
+
+      num_interfaces = interfaces.names.length
+      if interfaces.names.length > 0
+        scroll = Qt::ScrollArea.new
+        scroll.setMinimumSize(800, 150)
+        widget = Qt::Widget.new
+        layout = Qt::VBoxLayout.new(widget)
+        # Since the layout will be inside a scroll area make sure it respects the sizes we set
+        layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+
+        interfaces_table = Qt::TableWidget.new()
+        interfaces_table.verticalHeader.hide()
+        interfaces_table.setRowCount(num_interfaces)
+        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  "])
+        else
+          interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts  "])
+        end
+
+        row = 0
+        interfaces.all.each do |interface_name, interface|
+          item = Qt::TableWidgetItem.new(tr(interface_name))
+          item.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 0, item)
+
+          if interface.connected?
+            button_text = 'Disconnect'
+          elsif interface.thread.nil?
+            button_text = 'Connect'
+          else
+            button_text = 'Cancel Connect'
+          end
+          button = Qt::PushButton.new(button_text)
+          if name == 'Routers'
+            button.connect(SIGNAL('clicked()')) do
+              if interface.thread
+                CmdTlmServer.instance.disconnect_router(interface_name)
+              else
+                CmdTlmServer.instance.connect_router(interface_name)
+              end
+            end
+          else
+            button.connect(SIGNAL('clicked()')) do
+              if interface.thread
+                CmdTlmServer.instance.disconnect_interface(interface_name)
+              else
+                CmdTlmServer.instance.connect_interface(interface_name)
+              end
+            end
+          end
+          button.setDisabled(true) if interface.disable_disconnect
+          interfaces_table.setCellWidget(row, 1, button)
+
+          state = Qt::TableWidgetItem.new
+          if interface.connected?
+            state.setText('true')
+            state.textColor = Cosmos::GREEN
+          elsif interface.thread
+            state.setText('attempting')
+            state.textColor = Cosmos::YELLOW
+          else
+            state.setText('false')
+            state.textColor = Cosmos::BLACK
+          end
+          state.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 2, state)
+
+          num_clients = Qt::TableWidgetItem.new(tr(interface.num_clients.to_s))
+          num_clients.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 3, num_clients)
+
+          write_queue_size = Qt::TableWidgetItem.new(tr(interface.write_queue_size.to_s))
+          write_queue_size.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 4, write_queue_size)
+
+          read_queue_size = Qt::TableWidgetItem.new(tr(interface.read_queue_size.to_s))
+          read_queue_size.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 5, read_queue_size)
+
+          bytes_written = Qt::TableWidgetItem.new(tr(interface.bytes_written.to_s))
+          bytes_written.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 6, bytes_written)
+
+          bytes_read = Qt::TableWidgetItem.new(tr(interface.bytes_read.to_s))
+          bytes_read.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 7, bytes_read)
+
+          write_count = Qt::TableWidgetItem.new(tr(interface.write_count.to_s))
+          write_count.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 8, write_count)
+
+          read_count = Qt::TableWidgetItem.new(tr(interface.read_count.to_s))
+          read_count.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, 9, read_count)
+
+          row += 1
+        end
+        interfaces_table.displayFullSize
+
+        layout.addWidget(interfaces_table)
+        scroll.setWidget(widget)
+        if name == 'Routers'
+          @tabbook.addTab(scroll, "Routers")
+          @interfaces_table['Routers'] = interfaces_table
+        else
+          @tabbook.addTab(scroll, "Interfaces")
+          @interfaces_table['Interfaces'] = interfaces_table
+        end
+      end
+    end
+
+    def handle_interfaces_tab(name)
+      @tab_thread = Thread.new do
+        if @interfaces_table[name]
+          begin
+            while true
+              Qt.execute_in_main_thread(true) do
+                row = 0
+                if name == 'Routers'
+                  interfaces = CmdTlmServer.routers
+                else
+                  interfaces = CmdTlmServer.interfaces
+                end
+                interfaces.all.each do |interface_name, interface|
+                  button = @interfaces_table[name].cellWidget(row,1)
+                  state = @interfaces_table[name].item(row,2)
+                  if interface.connected?
+                    button.setText('Disconnect')
+                    button.setDisabled(true) if interface.disable_disconnect
+                    state.setText('true')
+                    state.textColor = Cosmos::GREEN
+                  elsif interface.thread
+                    button.text = 'Cancel Connect'
+                    button.setDisabled(false)
+                    state.text = 'attempting'
+                    state.textColor = Cosmos::RED
+                  else
+                    button.setText('Connect')
+                    button.setDisabled(false)
+                    state.setText('false')
+                    state.textColor = Cosmos::BLACK
+                  end
+                  @interfaces_table[name].item(row,3).setText(interface.num_clients.to_s)
+                  @interfaces_table[name].item(row,4).setText(interface.write_queue_size.to_s)
+                  @interfaces_table[name].item(row,5).setText(interface.read_queue_size.to_s)
+                  @interfaces_table[name].item(row,6).setText(interface.bytes_written.to_s)
+                  @interfaces_table[name].item(row,7).setText(interface.bytes_read.to_s)
+                  if name == 'Routers'
+                    @interfaces_table[name].item(row,8).setText(interface.read_count.to_s)
+                    @interfaces_table[name].item(row,9).setText(interface.write_count.to_s)
+                  else
+                    @interfaces_table[name].item(row,8).setText(interface.write_count.to_s)
+                    @interfaces_table[name].item(row,9).setText(interface.read_count.to_s)
+                  end
+                  row += 1
+                end
+              end
+              sleep(1)
+            end
+          rescue Exception => error
+            Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : #{name} Tab Thread")}
+          end
+        end
+      end
+    end
+
+    def populate_targets
+      num_targets = System.targets.length
+      if num_targets > 0
+        return if num_targets == 1 and System.targets['SYSTEM']
+        num_targets -= 1 if System.targets['SYSTEM']
+
+        scroll = Qt::ScrollArea.new
+        widget = Qt::Widget.new
+        layout = Qt::VBoxLayout.new(widget)
+        # Since the layout will be inside a scroll area make sure it respects the sizes we set
+        layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+
+        @targets_table = Qt::TableWidget.new()
+        @targets_table.verticalHeader.hide()
+        @targets_table.setRowCount(num_targets)
+        @targets_table.setColumnCount(4)
+        @targets_table.setHorizontalHeaderLabels(["Target Name", "Interface", "#{CMD} Count", "#{TLM} Count"])
+
+        row = 0
+        System.targets.sort.each do |target_name, target|
+          next if target_name == 'SYSTEM'
+          target_name_widget = Qt::TableWidgetItem.new(tr(target_name))
+          target_name_widget.setTextAlignment(Qt::AlignCenter)
+          @targets_table.setItem(row, 0, target_name_widget)
+          if target.interface
+            interface_name_widget = Qt::TableWidgetItem.new(tr(target.interface.name.to_s))
+          else
+            interface_name_widget = Qt::TableWidgetItem.new(tr(''))
+          end
+          interface_name_widget.setTextAlignment(Qt::AlignCenter)
+          @targets_table.setItem(row, 1, interface_name_widget)
+          cmd_cnt = Qt::TableWidgetItem.new(tr(target.cmd_cnt.to_s))
+          cmd_cnt.setTextAlignment(Qt::AlignCenter)
+          @targets_table.setItem(row, 2, cmd_cnt)
+
+          tlm_cnt = Qt::TableWidgetItem.new(tr(target.tlm_cnt.to_s))
+          tlm_cnt.setTextAlignment(Qt::AlignCenter)
+          @targets_table.setItem(row, 3, tlm_cnt)
+
+          row += 1
+        end
+        @targets_table.displayFullSize
+
+        layout.addWidget(@targets_table)
+        scroll.setWidget(widget)
+        @tabbook.addTab(scroll, "Targets")
+      end
+    end
+
+    def handle_targets_tab
+      @tab_thread = Thread.new do
+        begin
+          while true
+            Qt.execute_in_main_thread(true) do
+              row = 0
+              System.targets.sort.each do |target_name, target|
+                next if target_name == 'SYSTEM'
+                @targets_table.item(row,2).setText(target.cmd_cnt.to_s)
+                @targets_table.item(row,3).setText(target.tlm_cnt.to_s)
+                row += 1
+              end
+            end
+            sleep(1)
+          end
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Targets Tab Thread")}
+        end
+      end
+    end
+
+    def get_cmd_tlm_def(name)
+      case name
+        when CMD
+          return System.commands
+        when TLM
+          return System.telemetry
+      end
+    end
+
+    def populate_packets(name)
+      cmd_tlm = get_cmd_tlm_def(name)
+
+      unless cmd_tlm.target_names.empty?
+        count = 0
+        cmd_tlm.target_names.sort.each do |target_name|
+          packets = cmd_tlm.packets(target_name)
+          packets.each do |packet_name, packet|
+            count += 1 unless packet.hidden
+          end
+        end
+
+        scroll = Qt::ScrollArea.new
+        widget = Qt::Widget.new
+        layout = Qt::VBoxLayout.new(widget)
+        # Since the layout will be inside a scroll area
+        # make sure it respects the sizes we set
+        layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+
+        table = Qt::TableWidget.new()
+        table.verticalHeader.hide()
+        table.setRowCount(count)
+        column_cnt = 4
+        column_cnt += 1 if name == TLM
+        table.setColumnCount(column_cnt)
+        # Force the last section to fill all available space in the frame
+        #~ table.horizontalHeader.setStretchLastSection(true)
+        headers = ["Target Name", "Packet Name", "Packet Count", "View Raw"]
+        headers << "View in Packet Viewer" if name == TLM
+        table.setHorizontalHeaderLabels(headers)
+
+        row = 0
+        cmd_tlm.target_names.sort.each do |target_name|
+          packets = cmd_tlm.packets(target_name)
+          packets.sort.each do |packet_name, packet|
+            packet.received_count ||= 0
+            next if packet.hidden
+            target_name_widget = Qt::TableWidgetItem.new(tr(target_name))
+            target_name_widget.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+            table.setItem(row, 0, target_name_widget)
+            table.setItem(row, 1, Qt::TableWidgetItem.new(tr(packet_name)))
+            packet_count = Qt::TableWidgetItem.new(tr(packet.received_count.to_s))
+            packet_count.setTextAlignment(Qt::AlignCenter)
+            table.setItem(row, 2, packet_count)
+            view_raw = Qt::PushButton.new("View Raw")
+            view_raw.connect(SIGNAL('clicked()')) do
+              @raw_dialogs ||= []
+              @raw_dialogs << CmdRawDialog.new(self, target_name, packet_name) if name == CMD
+              @raw_dialogs << TlmRawDialog.new(self, target_name, packet_name) if name == TLM
+            end
+            table.setCellWidget(row, 3, view_raw)
+
+            if name == TLM
+              if target_name != 'UNKNOWN' and packet_name != 'UNKNOWN'
+                view_pv = Qt::PushButton.new("View in Packet Viewer")
+                view_pv.connect(SIGNAL('clicked()')) do
+                  if Kernel.is_windows?
+                    Cosmos.run_process("rubyw tools/PacketViewer -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                  elsif Kernel.is_mac? and File.exist?("tools/mac/PacketViewer.app")
+                    Cosmos.run_process("open tools/mac/PacketViewer.app --args -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                  else
+                    Cosmos.run_process("ruby tools/PacketViewer -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                  end
+                end
+                table.setCellWidget(row, 4, view_pv)
+              else
+                table_widget = Qt::TableWidgetItem.new(tr('N/A'))
+                table_widget.setTextAlignment(Qt::AlignCenter)
+                table.setItem(row, 4, table_widget)
+              end
+            end
+
+            row += 1
+          end
+        end
+        table.displayFullSize
+
+        layout.addWidget(table)
+        scroll.setWidget(widget)
+        tab_name = "Cmd Packets" if name == CMD
+        tab_name = "Tlm Packets" if name == TLM
+        @tabbook.addTab(scroll, tab_name)
+
+        @packets_table ||= {}
+        @packets_table[name] = table
+      end
+    end
+
+    def handle_packets_tab(name)
+      cmd_tlm = get_cmd_tlm_def(name)
+
+      @tab_thread = Thread.new do
+        begin
+          unless cmd_tlm.target_names.empty?
+            while true
+              Qt.execute_in_main_thread(true) do
+                row = 0
+                cmd_tlm.target_names.sort.each do |target_name|
+                  packets = cmd_tlm.packets(target_name)
+                  packets.sort.each do |packet_name, packet|
+                    next if packet.hidden
+                    @packets_table[name].item(row, 2).setText(packet.received_count.to_s)
+                    row += 1
+                  end
+                end
+              end
+              sleep(1)
+            end
+          end
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : #{name} Packets Tab Thread")}
+        end
+      end
+    end
+
+    def populate_logging_actions(layout)
+      # Add all the action buttons
+      actions = Qt::GroupBox.new(tr("Actions"))
+      actions_layout = Qt::VBoxLayout.new(actions)
+      button_layout = Qt::GridLayout.new
+
+      log_buttons = [
+        ["Start Logging on All", [0,0], :start_logging],
+        ["Stop Logging on All", [0,1], :stop_logging],
+        ["Start #{TLM} Logging on All", [1,0], :start_tlm_log],
+        ["Stop #{TLM} Logging on All", [1,1], :stop_tlm_log],
+        ["Start #{CMD} Logging on All", [2,0], :start_cmd_log],
+        ["Stop #{CMD} Logging on All", [2,1], :stop_cmd_log]
+      ]
+
+      log_buttons.each do |text, location, method|
+        next if text =~ /Stop/ and @production
+        button = Qt::PushButton.new(tr(text))
+        button_layout.addWidget(button, location[0], location[1])
+        button.connect(SIGNAL('clicked()')) do
+          begin
+            CmdTlmServer.instance.send(method, 'ALL')
+          rescue Exception => error
+            statusBar.showMessage(tr(error.message))
+          end
+        end
+      end
+
+      actions_layout.addLayout(button_layout)
+
+      layout.addWidget(actions)
+    end
+
+    def populate_log_file_info(layout)
+      CmdTlmServer.packet_logging.all.sort.each do |packet_log_writer_pair_name, packet_log_writer_pair|
+        log = Qt::GroupBox.new("#{packet_log_writer_pair_name} Packet Log Writer")
+        log_layout = Qt::VBoxLayout.new(log)
+        interfaces = []
+        CmdTlmServer.interfaces.all.each do |interface_name, interface|
+          if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+            interfaces << interface.name
+          end
+        end
+
+        form_layout = Qt::FormLayout.new
+        @logging_layouts[packet_log_writer_pair_name] = form_layout
+        form_layout.addRow("Interfaces:", Qt::Label.new(tr(interfaces.join(", "))))
+
+        form_layout.addRow("Cmd Logging:", Qt::Label.new(tr(packet_log_writer_pair.cmd_log_writer.logging_enabled.to_s)))
+        form_layout.addRow("Cmd Queue Size:", Qt::Label.new(tr(packet_log_writer_pair.cmd_log_writer.queue.size.to_s)))
+        form_layout.addRow("Cmd Filename:", Qt::Label.new(tr(packet_log_writer_pair.cmd_log_writer.filename)))
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.cmd_log_writer.filename) if packet_log_writer_pair.cmd_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        form_layout.addRow("Cmd File Size:", Qt::Label.new(tr(file_size.to_s)))
+
+        form_layout.addRow("Tlm Logging:", Qt::Label.new(tr(packet_log_writer_pair.tlm_log_writer.logging_enabled.to_s)))
+        form_layout.addRow("Tlm Queue Size:", Qt::Label.new(tr(packet_log_writer_pair.tlm_log_writer.queue.size.to_s)))
+        form_layout.addRow("Tlm Filename:", Qt::Label.new(tr(packet_log_writer_pair.tlm_log_writer.filename)))
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.tlm_log_writer.filename) if packet_log_writer_pair.tlm_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        form_layout.addRow("Tlm File Size:", Qt::Label.new(tr(file_size.to_s)))
+
+        button_layout = Qt::HBoxLayout.new
+        start_button = Qt::PushButton.new(tr('Start Cmd Logging'))
+        button_layout.addWidget(start_button)
+        start_button.connect(SIGNAL('clicked()')) do
+          CmdTlmServer.instance.start_cmd_log(packet_log_writer_pair_name)
+        end
+        start_button = Qt::PushButton.new(tr('Start Tlm Logging'))
+        button_layout.addWidget(start_button)
+        start_button.connect(SIGNAL('clicked()')) do
+          CmdTlmServer.instance.start_tlm_log(packet_log_writer_pair_name)
+        end
+        if @production == false
+          stop_button = Qt::PushButton.new(tr('Stop Cmd Logging'))
+          button_layout.addWidget(stop_button)
+          stop_button.connect(SIGNAL('clicked()')) do
+            CmdTlmServer.instance.stop_cmd_log(packet_log_writer_pair_name)
+          end
+          stop_button = Qt::PushButton.new(tr('Stop Tlm Logging'))
+          button_layout.addWidget(stop_button)
+          stop_button.connect(SIGNAL('clicked()')) do
+            CmdTlmServer.instance.stop_tlm_log(packet_log_writer_pair_name)
+          end
+        end
+        form_layout.addRow("Actions:", button_layout)
+        log_layout.addLayout(form_layout)
+        layout.addWidget(log)
+      end
+      layout.addWidget(Qt::Label.new(tr("Note: Buffered IO operations cause file size to not reflect total logged data size until the log file is closed.")))
+    end
+
+    def populate_logging
+      scroll = Qt::ScrollArea.new
+      widget = Qt::Widget.new
+      layout = Qt::VBoxLayout.new(widget)
+      # Since the layout will be inside a scroll area
+      # make sure it respects the sizes we set
+      layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
+
+      populate_logging_actions(layout)
+
+      # Create the hash which will hold the logging layouts
+      @logging_layouts = {}
+
+      # Add the cmd/tlm log files information
+      populate_log_file_info(layout)
+
+      # Set the scroll area widget last now that all the items have been layed out
+      scroll.setWidget(widget)
+      @tabbook.addTab(scroll, "Logging")
+    end
+
+    def update_filename_and_logging_state
+      CmdTlmServer.packet_logging.all.each do |packet_log_writer_pair_name, packet_log_writer_pair|
+        @logging_layouts[packet_log_writer_pair_name].itemAt(1, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.logging_enabled.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(2, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.queue.size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(3, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.filename)
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.cmd_log_writer.filename) if packet_log_writer_pair.cmd_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        @logging_layouts[packet_log_writer_pair_name].itemAt(4, Qt::FormLayout::FieldRole).widget.setText(file_size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(5, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.logging_enabled.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(6, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.queue.size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(7, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.filename)
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.tlm_log_writer.filename) if packet_log_writer_pair.tlm_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        @logging_layouts[packet_log_writer_pair_name].itemAt(8, Qt::FormLayout::FieldRole).widget.setText(file_size.to_s)
+      end
+    end
+
+    def handle_logging_tab
+      @tab_thread = Thread.new do
+        begin
+          while true
+            Qt.execute_in_main_thread(true) do
+              update_filename_and_logging_state()
+            end
+            sleep(1)
+          end
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Logging Tab Thread")}
+        end
+      end
+    end
+
+    def populate_status
+      scroll = Qt::ScrollArea.new
+      widget = Qt::Widget.new
+      layout = Qt::VBoxLayout.new(widget)
+
+      limits = Qt::GroupBox.new(tr("Limits Status"))
+      limits_layout = Qt::FormLayout.new(limits)
+      current_limits_set = System.limits_set.to_s
+
+      known_limits_sets = System.limits.sets
+      known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
+      current_index = known_limits_sets.index(current_limits_set.to_s)
+
+      @limits_set_combo = Qt::ComboBox.new
+      limits_layout.addRow("Limits Set:", @limits_set_combo)
+      layout.addWidget(limits)
+
+      known_limits_sets.sort.each do |limits_set|
+        @limits_set_combo.addItem(limits_set.to_s)
+      end
+      @limits_set_combo.setMaxVisibleItems(6)
+      @limits_set_combo.setCurrentIndex(current_index)
+      # Only connect to the signal that is sent when the user chooses an item.
+      # If the limits set is changed programatically the code in
+      # handle_status_tab will pick up the change.
+      @limits_set_combo.connect(SIGNAL('activated(int)')) do
+        selected_limits_set = @limits_set_combo.currentText
+        if selected_limits_set
+          System.limits_set = selected_limits_set.intern if System.limits_set != selected_limits_set.intern
+        end
+      end
+
+      api = Qt::GroupBox.new(tr("API Status"))
+      api_layout = Qt::VBoxLayout.new(api)
+      @api_table = Qt::TableWidget.new()
+      @api_table.verticalHeader.hide()
+      @api_table.setRowCount(1)
+      @api_table.setColumnCount(6)
+      @api_table.setHorizontalHeaderLabels(["Port", "Num Clients", "Requests", "Requests/Sec", "Avg Request Time", "Estimated Utilization"])
+
+      @api_table.setItem(0, 0, Qt::TableWidgetItem.new(tr(System.ports['CTS_API'].to_s)))
+      item0 = Qt::TableWidgetItem.new(tr(CmdTlmServer.json_drb.num_clients.to_s))
+      item0.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 1, item0)
+      item = Qt::TableWidgetItem.new(tr(CmdTlmServer.json_drb.request_count.to_s))
+      item.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 2, item)
+      item2 = Qt::TableWidgetItem.new("0.0")
+      item2.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 3, item2)
+      item3 = Qt::TableWidgetItem.new("0.0")
+      item3.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 4, item3)
+      item4 = Qt::TableWidgetItem.new("0.0")
+      item4.setTextAlignment(Qt::AlignCenter)
+      @api_table.setItem(0, 5, item4)
+      @api_table.displayFullSize
+      api_layout.addWidget(@api_table)
+      layout.addWidget(api)
+
+      system = Qt::GroupBox.new(tr("System Status"))
+      system_layout = Qt::VBoxLayout.new(system)
+      @system_table = Qt::TableWidget.new()
+      @system_table.verticalHeader.hide()
+      @system_table.setRowCount(1)
+      @system_table.setColumnCount(4)
+      @system_table.setHorizontalHeaderLabels(["Threads", "Total Objs", "Free Objs", "Allocated Objs"])
+
+      item0 = Qt::TableWidgetItem.new("0")
+      item0.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 0, item0)
+      item1 = Qt::TableWidgetItem.new("0.0")
+      item1.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 1, item1)
+      item2 = Qt::TableWidgetItem.new("0.0")
+      item2.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 2, item2)
+      item3 = Qt::TableWidgetItem.new("0.0")
+      item3.setTextAlignment(Qt::AlignCenter)
+      @system_table.setItem(0, 3, item3)
+      @system_table.displayFullSize
+      system_layout.addWidget(@system_table)
+      layout.addWidget(system)
+
+      background_tasks_groupbox = Qt::GroupBox.new(tr("Background Tasks"))
+      background_tasks_layout = Qt::VBoxLayout.new(background_tasks_groupbox)
+      @background_tasks_table = Qt::TableWidget.new()
+      @background_tasks_table.verticalHeader.hide()
+      @background_tasks_table.setRowCount(CmdTlmServer.background_tasks.all.length)
+      @background_tasks_table.setColumnCount(3)
+      @background_tasks_table.setHorizontalHeaderLabels(["Name", "State", "Status"])
+
+      background_tasks = CmdTlmServer.background_tasks.all
+      if background_tasks.length > 0
+        row = 0
+        background_tasks.each_with_index do |background_task, index|
+          background_task_name = background_task.name
+          background_task_name = "Background Task ##{index + 1}" unless background_task_name
+          background_task_name_widget = Qt::TableWidgetItem.new(background_task_name)
+          background_task_name_widget.setTextAlignment(Qt::AlignCenter)
+          @background_tasks_table.setItem(row, 0, background_task_name_widget)
+          if background_task.thread
+            status = background_task.thread.status
+            status = 'complete' if status == false
+            background_task_state_widget = Qt::TableWidgetItem.new(status.to_s)
+          else
+            background_task_state_widget = Qt::TableWidgetItem.new('no thread')
+          end
+          background_task_state_widget.setTextAlignment(Qt::AlignCenter)
+          background_task_state_widget.setSizeHint(Qt::Size.new(80, 30))
+          @background_tasks_table.setItem(row, 1, background_task_state_widget)
+          background_task_status_widget = Qt::TableWidgetItem.new(background_task.status.to_s)
+          background_task_status_widget.setTextAlignment(Qt::AlignCenter)
+          background_task_status_widget.setSizeHint(Qt::Size.new(500, 30))
+          @background_tasks_table.setItem(row, 2, background_task_status_widget)
+
+          row += 1
+        end
+      end
+      @background_tasks_table.displayFullSize
+      background_tasks_layout.addWidget(@background_tasks_table)
+      layout.addWidget(background_tasks_groupbox)
+
+      # Set the scroll area widget last now that all the items have been layed out
+      scroll.setWidget(widget)
+      @tabbook.addTab(scroll, "Status")
+    end
+
+    def handle_status_tab
+      @tab_thread = Thread.new do
+        begin
+          if CmdTlmServer.json_drb
+            previous_request_count = CmdTlmServer.json_drb.request_count
+          else
+            previous_request_count = 0
+          end
+          while true
+            start_time = Time.now
+            Qt.execute_in_main_thread(true) do
+              # Update limits set
+              current_limits_set = System.limits_set.to_s
+              if @limits_set_combo.currentText != current_limits_set
+                known_limits_sets = System.limits.sets
+                known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
+                current_index = known_limits_sets.index(current_limits_set.to_s)
+                @limits_set_combo.clear
+                known_limits_sets.sort.each do |limits_set|
+                  @limits_set_combo.addItem(limits_set.to_s)
+                end
+                @limits_set_combo.setCurrentIndex(current_index)
+              end
+
+              # Update API status
+              if CmdTlmServer.json_drb
+                @api_table.item(0,1).setText(CmdTlmServer.json_drb.num_clients.to_s)
+                @api_table.item(0,2).setText(CmdTlmServer.json_drb.request_count.to_s)
+                request_count = CmdTlmServer.json_drb.request_count
+                requests_per_second = request_count - previous_request_count
+                @api_table.item(0,3).setText(requests_per_second.to_s)
+                previous_request_count = request_count
+                average_request_time = CmdTlmServer.json_drb.average_request_time
+                @api_table.item(0,4).setText(sprintf("%0.6f s", average_request_time))
+                estimated_utilization = requests_per_second * average_request_time * 100.0
+                @api_table.item(0,5).setText(sprintf("%0.2f %", estimated_utilization))
+              end
+
+              # Update system status
+              @system_table.item(0,0).setText(Thread.list.length.to_s)
+              objs = ObjectSpace.count_objects
+              @system_table.item(0,1).setText(objs[:TOTAL].to_s)
+              @system_table.item(0,2).setText(objs[:FREE].to_s)
+              total = 0
+              objs.each do |key, val|
+                next if key == :TOTAL || key == :FREE
+                total += val
+              end
+              @system_table.item(0,3).setText(total.to_s)
+
+              # Update background task status
+              background_tasks = CmdTlmServer.background_tasks.all
+              if background_tasks.length > 0
+                row = 0
+                background_tasks.each_with_index do |background_task, index|
+                  if background_task.thread
+                    status = background_task.thread.status
+                    status = 'complete' if status == false
+                    @background_tasks_table.item(row, 1).setText(status.to_s)
+                  else
+                    @background_tasks_table.item(row, 1).setText('no thread')
+                  end
+                  @background_tasks_table.item(row, 2).setText(background_task.status.to_s)
+                  row += 1
+                end
+              end
+            end
+            total_time = Time.now - start_time
+            sleep(1.0 - total_time) if total_time > 0.0 and total_time < 1.0
+          end
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Settings Tab Thread")}
+        end
+      end
+    end
+
+    def closeEvent(event)
+      # Create are you sure dialog
+      if @no_prompt
+        continue = true
+      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.")
+        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
+        kill_tab_thread()
+        @output_thread.kill()
+        @message_log.stop
+        CmdTlmServer.instance.stop_logging('ALL')
+        CmdTlmServer.instance.stop
+        super(event)
+      else
+        event.ignore()
+      end
+    end
+
+    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 = "#{CMD} and #{TLM} Server"
+          options.auto_size = false
+          options.config_file = CmdTlmServer::DEFAULT_CONFIG_FILE
+          options.production = false
+          options.no_prompt = false
+          option_parser.separator "CTS Specific Options:"
+          option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
+            options.config_file = arg
+          end
+          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
+        end
+
+        super(option_parser, options)
+      end
+    end
+
+    def process_server_messages(options)
+      # Start thread to read server messages
+      @output_thread = Thread.new do
+        begin
+          while !@message_log
+            sleep(1)
+          end
+          while true
+            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| @output.add_formatted_text(out_line); lines_to_write += out_line }
+                @output.flush
+                @message_log.write(lines_to_write)
+              end
+            end
+            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
+  end # class CmdTlmServerGui
+
+end # module Cosmos