cosmos 4.0.0-universal-java-1.8

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

@@ -0,0 +1,274 @@
+# 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/config/config_parser'
+require 'cosmos/interfaces'
+require 'cosmos/tools/cmd_tlm_server/interface_thread'
+require 'cosmos/packet_logs'
+require 'cosmos/io/raw_logger_pair'
+
+module Cosmos
+  # Reads an ascii file that defines the configuration settings used to
+  # configure the Command/Telemetry Server.
+  class CmdTlmServerConfig
+    # @return [Hash<String, Interface>] Interfaces hash
+    attr_accessor :interfaces
+    # @return [Hash<String, Interface>] Routers hash
+    attr_accessor :routers
+    # @return [Hash<String, PacketLogWriterPair>] Packet log writer hash. Each
+    #   pair encapsulates a command and telemetry log writer.
+    attr_accessor :packet_log_writer_pairs
+    # @return [Array<BackgroundTask>] Array of background tasks
+    attr_accessor :background_tasks
+    # @return [String] Command and Telemetry Server title
+    attr_accessor :title
+    # @return [Boolean] Flag indicating if meta data should be collected
+    attr_accessor :metadata
+
+    # Create a default pair of packet log writers and parses the
+    # configuration file.
+    #
+    # @param filename [String] The name of the configuration file to parse
+    def initialize(filename)
+      @interfaces = {}
+      @routers = {}
+      @packet_log_writer_pairs = {}
+      cmd_log_writer = System.default_packet_log_writer.new(:CMD, *System.default_packet_log_writer_params)
+      tlm_log_writer = System.default_packet_log_writer.new(:TLM, *System.default_packet_log_writer_params)
+      @packet_log_writer_pairs['DEFAULT'] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+      @background_tasks = []
+      @title = nil
+      @metadata = false
+      process_file(filename)
+    end
+
+    protected
+
+    # Processes a file and adds in the configuration defined in the file
+    #
+    # @param filename [String] The name of the configuration file to parse
+    # @param recursive [Boolean] Whether process_file is being called
+    #   recursively
+    def process_file(filename, recursive = false)
+      current_interface_or_router = nil
+      current_type = nil
+      current_interface_log_added = false
+
+      Logger.info "Processing CmdTlmServer configuration in file: #{File.expand_path(filename)}"
+
+      Cosmos.set_working_dir do
+        parser = ConfigParser.new("http://cosmosrb.com/docs/system/#command-and-telemetry-server-configuration")
+        parser.parse_file(filename) do |keyword, params|
+          case keyword
+          when 'TITLE'
+            raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+            parser.verify_num_parameters(1, 1, "#{keyword} <Title Text>")
+            @title = params[0]
+
+          when 'PACKET_LOG_WRITER'
+            usage = "PACKET_LOG_WRITER <Name> <Filename> <Specific Parameters>"
+            parser.verify_num_parameters(2, nil, usage)
+            packet_log_writer_name = params[0].upcase
+            packet_log_writer_class = Cosmos.require_class(params[1])
+
+            # Verify not overridding a packet log writer that is already associated with an interface
+            packet_log_writer_pair = @packet_log_writer_pairs[packet_log_writer_name]
+            if packet_log_writer_pair
+              @interfaces.each do |interface_name, interface|
+                if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+                  raise parser.error("Redefining Packet Log Writer #{packet_log_writer_name} not allowed after it is associated with an interface")
+                end
+              end
+            end
+
+            if params[2]
+              cmd_log_writer = packet_log_writer_class.new(:CMD, *params[2..-1])
+              tlm_log_writer = packet_log_writer_class.new(:TLM, *params[2..-1])
+              @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+            else
+              cmd_log_writer = packet_log_writer_class.new(:CMD)
+              tlm_log_writer = packet_log_writer_class.new(:TLM)
+              @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+            end
+
+          when 'AUTO_INTERFACE_TARGETS'
+            raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+            usage = "#{keyword}"
+            parser.verify_num_parameters(0, 0, usage)
+            System.targets.each do |target_name, target|
+              target_filename = File.join(target.dir, 'cmd_tlm_server.txt')
+              if File.exist?(target_filename)
+                raise parser.error("Cannot use #{keyword} with target name substitutions: #{target.name} != #{target.original_name}") if target.name != target.original_name
+                process_file(target_filename, true)
+              end
+            end
+
+          when 'INTERFACE_TARGET'
+            raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+            usage = "#{keyword} <Target Name> <Config File (defaults to cmd_tlm_server.txt)>"
+            parser.verify_num_parameters(1, 2, usage)
+            target = System.targets[params[0].upcase]
+            raise parser.error("Unknown target: #{params[0].upcase}") unless target
+            target_filename = params[1]
+            target_filename = 'cmd_tlm_server.txt' unless target_filename
+            target_filename = File.join(target.dir, target_filename)
+            if File.exist?(target_filename)
+              process_file(target_filename, true)
+            else
+              raise parser.error("#{target_filename} does not exist")
+            end
+
+          when 'INTERFACE'
+            usage = "INTERFACE <Name> <Filename> <Specific Parameters>"
+            parser.verify_num_parameters(2, nil, usage)
+            interface_name = params[0].upcase
+            raise parser.error("Interface '#{interface_name}' defined twice") if @interfaces[interface_name]
+            interface_class = Cosmos.require_class(params[1])
+            if params[2]
+              current_interface_or_router = interface_class.new(*params[2..-1])
+            else
+              current_interface_or_router = interface_class.new
+            end
+            current_type = :INTERFACE
+            current_interface_log_added = false
+            current_interface_or_router.packet_log_writer_pairs << @packet_log_writer_pairs['DEFAULT']
+            current_interface_or_router.name = interface_name
+            @interfaces[interface_name] = current_interface_or_router
+
+          when 'LOG', 'DONT_LOG', 'TARGET', 'PROTOCOL'
+            raise parser.error("No current interface for #{keyword}") unless current_interface_or_router and current_type == :INTERFACE
+
+            case keyword
+
+            when 'LOG'
+              parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
+              packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
+              raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
+              current_interface_or_router.packet_log_writer_pairs.delete(@packet_log_writer_pairs['DEFAULT']) unless current_interface_log_added
+              current_interface_log_added = true
+              current_interface_or_router.packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.packet_log_writer_pairs.include?(packet_log_writer_pair)
+
+            when 'DONT_LOG'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.packet_log_writer_pairs = []
+
+            when 'TARGET'
+              parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
+              target_name = params[0].upcase
+              target = System.targets[target_name]
+              if target
+                target.interface = current_interface_or_router
+                current_interface_or_router.target_names << target_name
+              else
+                raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface_or_router.name}")
+              end
+
+            when 'PROTOCOL'
+              usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+              parser.verify_num_parameters(2, nil, usage)
+              unless %w(READ WRITE READ_WRITE).include? params[0].upcase
+                raise parser.error("Invalid protocol type: #{params[0]}", usage)
+              end
+              begin
+                klass = Cosmos.require_class(params[1])
+                current_interface_or_router.add_protocol(klass, params[2..-1], params[0].upcase.intern)
+              rescue LoadError, StandardError => error
+                raise parser.error(error.message, usage)
+              end
+
+            end # end case keyword for all keywords that require a current interface
+
+          when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG_RAW', 'ROUTER_LOG_RAW', 'OPTION'
+            raise parser.error("No current interface or router for #{keyword}") unless current_interface_or_router
+
+            case keyword
+
+            when 'DONT_CONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.connect_on_startup = false
+
+            when 'DONT_RECONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.auto_reconnect = false
+
+            when 'RECONNECT_DELAY'
+              parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
+              current_interface_or_router.reconnect_delay = Float(params[0])
+
+            when 'DISABLE_DISCONNECT'
+              parser.verify_num_parameters(0, 0, "#{keyword}")
+              current_interface_or_router.disable_disconnect = true
+
+            # TODO: Deprecate ROUTER_LOG_RAW
+            when 'LOG_RAW', 'ROUTER_LOG_RAW'
+              parser.verify_num_parameters(0, nil, "#{keyword} <Raw Logger Class File (optional)> <Raw Logger Parameters (optional)>")
+              current_interface_or_router.raw_logger_pair = RawLoggerPair.new(current_interface_or_router.name, params)
+
+            when 'OPTION'
+              parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+              current_interface_or_router.set_option(params[0], params[1..-1])
+
+            end # end case keyword for all keywords that require a current interface or router
+
+          when 'ROUTER'
+            usage = "ROUTER <Name> <Filename> <Specific Parameters>"
+            parser.verify_num_parameters(2, nil, usage)
+            router_name = params[0].upcase
+            raise parser.error("Router '#{router_name}' defined twice") if @routers[router_name]
+            router_class = Cosmos.require_class(params[1])
+            if params[2]
+              current_interface_or_router = router_class.new(*params[2..-1])
+            else
+              current_interface_or_router = router_class.new
+            end
+            current_type = :ROUTER
+            current_interface_or_router.name = router_name
+            @routers[router_name] = current_interface_or_router
+
+          when 'ROUTE'
+            raise parser.error("No current router for #{keyword}") unless current_interface_or_router and current_type == :ROUTER
+            usage = "ROUTE <Interface Name>"
+            parser.verify_num_parameters(1, 1, usage)
+            interface_name = params[0].upcase
+            interface = @interfaces[interface_name]
+            raise parser.error("Unknown interface #{interface_name} mapped to router #{current_interface_or_router.name}") unless interface
+            unless current_interface_or_router.interfaces.include? interface
+              current_interface_or_router.interfaces << interface
+              interface.routers << current_interface_or_router
+            end
+
+          when 'BACKGROUND_TASK'
+            usage = "#{keyword} <Filename> <Specific Parameters>"
+            parser.verify_num_parameters(1, nil, usage)
+            background_task = Cosmos.require_class(params[0])
+            if params[1]
+              @background_tasks << background_task.new(*params[1..-1])
+            else
+              @background_tasks << background_task.new
+            end
+
+          when 'STOPPED'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            raise parser.error("No BACKGROUND_TASK defined") if @background_tasks.empty?
+            @background_tasks[-1].stopped = true
+
+          when 'COLLECT_METADATA'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            @metadata = true
+
+          else
+            # blank lines will have a nil keyword and should not raise an exception
+            raise parser.error("Unknown keyword: #{keyword}") unless keyword.nil?
+          end  # case
+        end  # loop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,480 @@
+# 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'
+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/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
+        option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
+          options.config_file = 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"
+
+    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
+      Cosmos.load_cosmos_icon("cts.png")
+
+      @production = options.production
+      @no_prompt = options.no_prompt
+      @message_log = nil
+      @output_sleeper = Sleeper.new
+      @first_output = 0
+      @interfaces_tab = InterfacesTab.new(self)
+      @targets_tab = TargetsTab.new
+      @packets_tab = PacketsTab.new(self)
+      @logging_tab = LoggingTab.new(@production)
+      @status_tab = StatusTab.new
+
+      statusBar.showMessage(tr("")) # Show blank message to initialize status bar
+
+      initialize_actions()
+      initialize_menus()
+      initialize_central_widget()
+      configure_tabs(options)
+      complete_initialize()
+    end
+
+    def configure_tabs(options)
+      Splash.execute(self) do |splash|
+        ConfigParser.splash = splash
+        splash.message = "Initializing #{TOOL_NAME}"
+
+        # 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)
+        cts = CmdTlmServer.new(options.config_file, @production)
+        cts.stop_callback = method(:stop_callback)
+        @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
+          @interfaces_tab.populate_interfaces(@tab_widget)
+          splash.progress = 100/7 * 1
+          @targets_tab.populate(@tab_widget)
+          splash.progress = 100/7 * 2
+          @packets_tab.populate_commands(@tab_widget)
+          splash.progress = 100/7 * 3
+          @packets_tab.populate_telemetry(@tab_widget)
+          splash.progress = 100/7 * 4
+          @interfaces_tab.populate_routers(@tab_widget)
+          splash.progress = 100/7 * 5
+          @logging_tab.populate(@tab_widget)
+          splash.progress = 100/7 * 6
+          @status_tab.populate(@tab_widget)
+          splash.progress = 100
+        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()')) { CmdTlmServer.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 = "#{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
+
+    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
+    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_tab('Interfaces') { @interfaces_tab.update(InterfacesTab::INTERFACES) }
+      when 1
+        handle_tab('Targets') { @targets_tab.update }
+      when 2
+        handle_tab('Commands') { @packets_tab.update(PacketsTab::COMMANDS) }
+      when 3
+        handle_tab('Telemetry') { @packets_tab.update(PacketsTab::TELEMETRY) }
+      when 4
+        handle_tab('Routers') { @interfaces_tab.update(InterfacesTab::ROUTERS) }
+      when 5
+        handle_tab('Logging') { @logging_tab.update }
+      when 6
+        handle_status_tab()
+      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
+      Qt::CoreApplication.instance.processEvents
+      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)
+      @tab_thread = Thread.new do
+        begin
+          while true
+            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 : #{name} Tab Thread")}
+        end
+      end
+    end
+
+    # Update the status tab of the server
+    def handle_status_tab
+      @tab_thread = Thread.new do
+        begin
+          while true
+            start_time = Time.now.sys
+            Qt.execute_in_main_thread(true) { @status_tab.update }
+            total_time = Time.now.sys - start_time
+            if total_time > 0.0 and total_time < 1.0
+              break if @tab_sleeper.sleep(1.0 - total_time)
+            end
+          end
+        rescue Exception => error
+          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "COSMOS CTS : Status Tab Thread")}
+        end
+      end
+    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)
+        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()
+        CmdTlmServer.instance.stop_logging('ALL')
+        CmdTlmServer.instance.stop
+        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 !@message_log
+            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| @output.add_formatted_text(out_line); lines_to_write << 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
+          @message_log.write(lines_to_write)
+        end
+      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
+      Qt::CoreApplication.processEvents()
+      Cosmos.kill_thread(self, @output_thread)
+      handle_string_output()
+    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 }
+        @message_log.write(lines_to_write)
+        STDOUT.print lines_to_write 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.post_options_parsed_hook(options)
+      if options.no_gui
+        ["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
+          cts = CmdTlmServer.new(options.config_file, options.production)
+          @message_log = CmdTlmServer.message_log
+          @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)
+          sleep # Sleep until waked by signal
+        ensure
+          if defined? cts and cts
+            cts.stop_logging('ALL')
+            cts.stop
+          end
+        end
+        return false
+      else
+        ["TERM", "INT"].each do |sig|
+          Signal.trap(sig) do
+            # No synchronization is allowed in trap context, so we have
+            # to spawn a thread here to send the close event.
+            Thread.new do
+              Qt.execute_in_main_thread(true) do
+                @@window.no_prompt = true
+                @@window.closeEvent(Qt::CloseEvent.new())
+                exit
+              end
+            end
+          end
+        end
+        return true
+      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.config_file = CmdTlmServer::DEFAULT_CONFIG_FILE
+          options.production = false
+          options.no_prompt = false
+          options.no_gui = 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
+          option_parser.on(nil, "--no-gui", "Run the server without a GUI") do |arg|
+            options.no_gui = true
+          end
+        end
+
+        super(option_parser, options)
+      end
+    end
+
+  end # class CmdTlmServerGui
+end # module Cosmos