cosmos 3.1.1 → 3.1.2

data/lib/cosmos/gui/line_graph/line_graph_scaling.rb

@@ -275,14 +275,6 @@ module Cosmos
       @x_grid_lines = []
 
       @x_grid_line_scale = determine_grid_line_scale(@manual_x_grid_line_scale, @x_min, @x_max)
-      if @manual_x_grid_line_scale
-        @x_grid_line_scale = @manual_x_grid_line_scale
-      else
-        diff = @x_max - @x_min
-        @x_grid_line_scale = calculate_base(diff)
-      end
-      @x_grid_line_scale = 1.0 if @x_grid_line_scale < 1
-
       if @show_x_grid_lines
         states = @lines.single_line_with_x_states
         if states
@@ -451,7 +443,6 @@ module Cosmos
         diff = max - min
         scale = calculate_base(diff)
       end
-      scale = 1.0 if scale < 1
       return scale
     end
 

data/lib/cosmos/gui/qt.rb

@@ -670,44 +670,46 @@ end
 
 class Qt::Painter
   def addLineColor(x, y, w, h, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
+    setPenColor(color)
     drawLine(x,y,w,h)
   end
 
   def addRectColor(x, y, w, h, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
+    setPenColor(color)
     setBrush(nil)
     drawRect(x,y,w,h)
   end
 
   def addRectColorFill(x, y, w, h, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
+    setPenColor(color)
     setBrush(Cosmos.getBrush(color))
     drawRect(x,y,w,h)
   end
 
   def addSimpleTextAt(text, x, y, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
-    drawText(x, y, text)
+    setPenColor(color)
+    drawText(x,y,text)
   end
 
   def addEllipseColor(x, y, w, h, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
+    setPenColor(color)
     setBrush(nil)
     drawEllipse(x,y,w,h)
   end
 
   def addEllipseColorFill(x, y, w, h, color = Cosmos::BLACK)
-    color = Cosmos::getColor(color)
-    setPen(color)
+    setPenColor(color)
     setBrush(Cosmos.getBrush(color))
     drawEllipse(x,y,w,h)
   end
+
+  private
+
+  def setPenColor(color)
+    color = Cosmos::getColor(color)
+    setPen(color)
+  end
+
 end
 
 class Qt::MatrixLayout < Qt::GridLayout
@@ -720,15 +722,17 @@ class Qt::MatrixLayout < Qt::GridLayout
 
   def addWidget(widget)
     super(widget, @row, @col)
-    @col += 1 if @col < @num_columns
-    if @col == @num_columns
-      @row += 1
-      @col = 0
-    end
+    increment_row_col()
   end
 
   def addLayout(layout)
     super(layout, @row, @col)
+    increment_row_col()
+  end
+
+  private
+
+  def increment_row_col
     @col += 1 if @col < @num_columns
     if @col == @num_columns
       @row += 1

data/lib/cosmos/packet_logs/packet_log_writer.rb

@@ -278,8 +278,12 @@ module Cosmos
 
     def cycle_thread_body
       while true
-        if @logging_enabled and @cycle_time and (Time.now - @start_time) > @cycle_time
-          close_file()
+        # The check against start_time needs to be mutex protected to prevent a packet coming in between the check
+        # and closing the file
+        @mutex.synchronize do
+          if @logging_enabled and @cycle_time and (Time.now - @start_time) > @cycle_time
+            close_file(false)
+          end
         end
         # Only check whether to cycle at a set interval
         break if @cycle_sleeper.sleep(CYCLE_TIME_INTERVAL)

data/lib/cosmos/script/script.rb

@@ -926,7 +926,7 @@ module Cosmos
           tlm_viewer.clear(display_name)
           tlm_viewer.disconnect
         rescue DRb::DRbConnError
-          raise "Unable to Successfully Start Listening Telemetry Viewer: #{display_name} could not be displayed"
+          raise "Unable to Successfully Start Listening Telemetry Viewer: #{display_name} could not be cleared"
         rescue Errno::ENOENT
           raise "Display Screen File: #{display_name}.txt does not exist"
         end

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

@@ -108,7 +108,6 @@ 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
-            raise parser.error("Cannot use #{keyword} with target name substitutions: #{target.name} != #{target.original_name}") if target.name != target.original_name
             target_filename = params[1]
             target_filename = 'cmd_tlm_server.txt' unless target_filename
             target_filename = File.join(target.dir, target_filename)

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

@@ -10,9 +10,13 @@
 
 require 'cosmos'
 require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
+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/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'
 
@@ -28,8 +32,7 @@ module Cosmos
     RUNNING = 1
     ERROR = 2
 
-    CMD = "Command"
-    TLM = "Telemetry"
+    TOOL_NAME = "Command and Telemetry Server"
 
     # 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
@@ -55,17 +58,25 @@ module Cosmos
       @no_prompt = options.no_prompt
       @message_log = nil
       @output_sleeper = Sleeper.new
+      @interfaces_tab = InterfacesTab.new
+      @targets_tab = TargetsTab.new
+      @packets_tab = PacketsTab.new(self)
+      @logging_tab = LoggingTab.new(@production)
+      @status_tab = StatusTab.new
 
       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 #{CMD} and #{TLM} Server"
+        splash.message = "Initializing #{TOOL_NAME}"
 
         # Start the thread that will process server messages and add them to the output text
         process_server_messages(options)
@@ -81,19 +92,19 @@ module Cosmos
           # 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')
+          @interfaces_tab.populate_interfaces(@tab_widget)
           splash.progress = 100/7 * 1
-          populate_targets()
+          @targets_tab.populate(@tab_widget)
           splash.progress = 100/7 * 2
-          populate_packets(CMD)
+          @packets_tab.populate_commands(@tab_widget)
           splash.progress = 100/7 * 3
-          populate_packets(TLM)
+          @packets_tab.populate_telemetry(@tab_widget)
           splash.progress = 100/7 * 4
-          populate_interfaces('Routers')
+          @interfaces_tab.populate_routers(@tab_widget)
           splash.progress = 100/7 * 5
-          populate_logging()
+          @logging_tab.populate(@tab_widget)
           splash.progress = 100/7 * 6
-          populate_status()
+          @status_tab.populate(@tab_widget)
           splash.progress = 100
         end
         ConfigParser.splash = nil
@@ -106,7 +117,7 @@ module Cosmos
       # 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() }
+      @edit_clear_counters.connect(SIGNAL('triggered()')) { CmdTlmServer.clear_counters }
     end
 
     def initialize_menus
@@ -119,29 +130,20 @@ module Cosmos
         @edit_menu.addAction(@edit_clear_counters)
       end
 
-      @about_string = "#{CMD} and #{TLM} Server is the heart of the COSMOS system. "
+      @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."
 
       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)
+      @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
@@ -149,7 +151,7 @@ module Cosmos
       @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)
+      # 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
@@ -161,777 +163,83 @@ module Cosmos
       @tab_thread = nil
     end
 
-    def kill_tab_thread
-      @tab_sleeper ||= nil
-      @tab_sleeper.cancel if @tab_sleeper
-      Cosmos.kill_thread(self, @tab_thread)
-      @tab_thread = nil
-    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)
       kill_tab_thread()
       @tab_sleeper = Sleeper.new
+
       case index
       when 0
-        handle_interfaces_tab('Interfaces')
+        handle_tab('Interfaces') { @interfaces_tab.update(InterfacesTab::INTERFACES) }
       when 1
-        handle_targets_tab()
+        handle_tab('Targets') { @targets_tab.update }
       when 2
-        handle_packets_tab(CMD)
+        handle_tab('Packets') { @packets_tab.update(PacketsTab::COMMANDS) }
       when 3
-        handle_packets_tab(TLM)
+        handle_tab('Telemetry') { @packets_tab.update(PacketsTab::TELEMETRY) }
       when 4
-        handle_interfaces_tab('Routers')
+        handle_tab('Routers') { @interfaces_tab.update(InterfacesTab::ROUTERS) }
       when 5
-        handle_logging_tab()
+        handle_tab('Logging') { @logging_tab.update }
       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
-                Logger.info "User disconnecting router #{interface_name}"
-                CmdTlmServer.instance.disconnect_router(interface_name)
-              else
-                Logger.info "User connecting router #{interface_name}"
-                CmdTlmServer.instance.connect_router(interface_name)
-              end
-            end
-          else
-            button.connect(SIGNAL('clicked()')) do
-              if interface.thread
-                Logger.info "User disconnecting interface #{interface_name}"
-                CmdTlmServer.instance.disconnect_interface(interface_name)
-              else
-                Logger.info "User connecting interface #{interface_name}"
-                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
-              break if @tab_sleeper.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
-            break if @tab_sleeper.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
-              break if @tab_sleeper.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 create_log_layout(form_layout, log_writer, label_prefix)
-      label = Qt::Label.new(tr(log_writer.logging_enabled.to_s))
-      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
-      form_layout.addRow("#{label_prefix} Logging:", label)
-      label = Qt::Label.new(tr(log_writer.queue.size.to_s))
-      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
-      form_layout.addRow("#{label_prefix} Queue Size:", label)
-      label = Qt::Label.new(tr(log_writer.filename))
-      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
-      form_layout.addRow("#{label_prefix} Filename:", label)
-      file_size = 0
-      begin
-        file_size = File.size(log_writer.filename) if log_writer.filename
-      rescue Exception
-        # Do nothing on error
-      end
-      label = Qt::Label.new(tr(file_size.to_s))
-      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
-      form_layout.addRow("#{label_prefix} File Size:", label)
-    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
-        label = Qt::Label.new(tr(interfaces.join(", ")))
-        label.setTextInteractionFlags(Qt::TextSelectableByMouse)
-        form_layout.addRow("Interfaces:", label)
-        create_log_layout(form_layout, packet_log_writer_pair.cmd_log_writer, 'Cmd')
-        create_log_layout(form_layout, packet_log_writer_pair.tlm_log_writer, 'Tlm')
-
-        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
+    # 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
+      Cosmos.kill_thread(self, @tab_thread)
+      @tab_thread = nil
     end
 
-    def handle_logging_tab
+    # 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)
       @tab_thread = Thread.new do
         begin
           while true
-            Qt.execute_in_main_thread(true) do
-              update_filename_and_logging_state()
-            end
+            Qt.execute_in_main_thread(true) { yield }
             break if @tab_sleeper.sleep(1)
           end
         rescue Exception => error
-          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Logging Tab Thread")}
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : #{name} 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
-
+    # Update the status tab of the server
     def handle_status_tab
+      if CmdTlmServer.json_drb
+        previous_request_count = CmdTlmServer.json_drb.request_count
+      else
+        previous_request_count = 0
+      end
       @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
+            Qt.execute_in_main_thread(true) { @status_tab.update(previous_request_count) }
             total_time = Time.now - 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 : Settings Tab Thread")}
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Status Tab Thread")}
         end
       end
     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
@@ -957,34 +265,8 @@ module Cosmos
       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
-
+    # 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
@@ -1004,6 +286,8 @@ module Cosmos
       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
@@ -1017,6 +301,8 @@ module Cosmos
       end
     end
 
+    # 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
@@ -1028,6 +314,35 @@ module Cosmos
     def graceful_kill
       # Just to avoid warning
     end
-  end # class CmdTlmServerGui
 
+    # 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.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
+
+  end # class CmdTlmServerGui
 end # module Cosmos