cosmos 4.0.3-java → 4.1.0-java

data/lib/cosmos/tools/packet_viewer/packet_viewer.rb

@@ -102,6 +102,10 @@ module Cosmos
       @option_action.statusTip = tr('Application Options')
       connect(@option_action, SIGNAL('triggered()'), self, SLOT('file_options()'))
 
+      @replay_action = Qt::Action.new(tr('Toggle Replay Mode'), self)
+      @replay_action.statusTip = tr('Toggle Replay Mode')
+      @replay_action.connect(SIGNAL('triggered()')) { toggle_replay_mode() }
+
       @color_blind_action = Qt::Action.new(tr('Color&blind Mode'), self)
       @color_blind_keyseq = Qt::KeySequence.new(tr('Ctrl+B'))
       @color_blind_action.shortcut  = @color_blind_keyseq
@@ -180,6 +184,7 @@ module Cosmos
       file_menu.addAction(@edit_action)
       file_menu.addAction(@reset_action)
       file_menu.addAction(@option_action)
+      file_menu.addAction(@replay_action)
       file_menu.addSeparator()
       file_menu.addAction(@exit_action)
 
@@ -207,6 +212,11 @@ module Cosmos
       # Create the top level vertical layout
       top_layout = Qt::VBoxLayout.new(central_widget)
 
+      @replay_flag = Qt::Label.new("Replay Mode")
+      @replay_flag.setStyleSheet("background:green;color:white;padding:5px;font-weight:bold;")
+      top_layout.addWidget(@replay_flag)
+      @replay_flag.hide
+
       # Set the target combobox selection
       @target_select = Qt::ComboBox.new
       @target_select.setMaxVisibleItems(6)
@@ -265,6 +275,15 @@ module Cosmos
                                                 @polling_rate, 0, 1000, 1, nil)
     end
 
+    def toggle_replay_mode
+      set_replay_mode(!get_replay_mode())
+      if get_replay_mode()
+        @replay_flag.show
+      else
+        @replay_flag.hide
+      end
+    end
+
     def edit_definition
       # Grab all the cmd_tlm_files and processes them in reverse sort order
       # because typically we'll have cmd.txt and tlm.txt and we want to process

data/lib/cosmos/tools/replay/replay.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2017 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
@@ -9,509 +9,9 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos'
-Cosmos.catch_fatal_exception do
-  require 'cosmos/gui/qt_tool'
-  require 'cosmos/gui/dialogs/splash'
-  require 'cosmos/gui/dialogs/progress_dialog'
-  require 'cosmos/gui/dialogs/packet_log_dialog'
-  require 'cosmos/tools/replay/replay_server'
-  require 'cosmos/gui/choosers/string_chooser'
-end
+require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server_gui'
 
 module Cosmos
-
-  class Replay < QtTool
-    # The number of bytes to print when an UNKNOWN packet is received
-    UNKNOWN_BYTES_TO_PRINT = 36
-
-    def initialize(options)
-      # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
-      super(options)
-      Cosmos.load_cosmos_icon("replay.png")
-
-      initialize_actions()
-      initialize_menus()
-      initialize_central_widget()
-      complete_initialize()
-
-      @ready = false
-      Splash.execute(self) do |splash|
-        ConfigParser.splash = splash
-        splash.message = "Initializing Replay Server"
-
-        # Start the thread that will process server messages and add them to the output text
-        process_server_messages(options)
-
-        ReplayServer.new(options.config_file, false, false, false)
-        @ready = true
-
-        ConfigParser.splash = nil
-      end
-
-      # Initialize variables
-      @packet_log_reader = System.default_packet_log_reader.new(*System.default_packet_log_reader_params)
-      @log_directory = System.paths['LOGS']
-      @log_directory << '/' unless @log_directory[-1..-1] == '\\' or @log_directory[-1..-1] == '/'
-      @log_filename = nil
-      @playing = false
-      @playback_thread = nil
-      @playback_index = 0
-      @packet_offsets = []
-    end
-
-    def initialize_menus
-      # File Menu
-      @file_menu = menuBar.addMenu(tr('&File'))
-      @file_menu.addAction(@exit_action)
-
-      # Help Menu
-      @about_string = "Telemetry Viewer provides a view of every telemetry packet in the system."
-      @about_string << " Packets can be viewed in numerous represenations ranging from the raw data to formatted with units."
-
-      initialize_help_menu()
-    end
-
-    def initialize_central_widget
-      # Create the central widget
-      @central_widget = Qt::Widget.new
-      setCentralWidget(@central_widget)
-
-      @top_layout = Qt::VBoxLayout.new
-
-      @log_widget = Qt::Widget.new
-      @log_widget.setSizePolicy(Qt::SizePolicy::MinimumExpanding, Qt::SizePolicy::MinimumExpanding)
-      @log_layout = Qt::VBoxLayout.new()
-
-      # This widget goes inside the top layout so we want 0 contents margins
-      @log_layout.setContentsMargins(0,0,0,0)
-      @log_widget.setLayout(@log_layout)
-
-      # Create the log file GUI
-      @log_file_selection = Qt::GroupBox.new("Log File Selection")
-      @log_select = Qt::HBoxLayout.new(@log_file_selection)
-      @log_name = Qt::LineEdit.new
-      @log_name.setReadOnly(true)
-      @log_select.addWidget(@log_name)
-      @log_open = Qt::PushButton.new("Browse...")
-      @log_select.addWidget(@log_open)
-      @log_layout.addWidget(@log_file_selection)
-
-      @log_open.connect(SIGNAL('clicked()')) { select_log_file() }
-
-      # Create the operation buttons GUI
-      @op = Qt::GroupBox.new(tr("Playback Control"))
-      @op_layout = Qt::VBoxLayout.new(@op)
-      @op_button_layout = Qt::HBoxLayout.new
-      @move_start = Qt::PushButton.new(Cosmos.get_icon('skip_to_start-26.png'), '')
-      @move_start.connect(SIGNAL('clicked()')) { move_start() }
-      @op_button_layout.addWidget(@move_start)
-      @step_back = Qt::PushButton.new(Cosmos.get_icon('rewind-26.png'), '')
-      @step_back_timer = Qt::Timer.new
-      @step_back_timeout = 100
-      @step_back_timer.connect(SIGNAL('timeout()')) { step_back(); @step_back_timeout = (@step_back_timeout / 2).to_i; @step_back_timer.start(@step_back_timeout) }
-      @step_back.connect(SIGNAL('pressed()')) { step_back(); @step_back_timeout = 300; @step_back_timer.start(@step_back_timeout) }
-      @step_back.connect(SIGNAL('released()')) { @step_back_timer.stop }
-      @op_button_layout.addWidget(@step_back)
-      @reverse_play = Qt::PushButton.new(Cosmos.get_icon('reverse-play-26.png'), '')
-      @reverse_play.connect(SIGNAL('clicked()')) { reverse_play() }
-      @op_button_layout.addWidget(@reverse_play)
-      @stop = Qt::PushButton.new(Cosmos.get_icon('stop-26.png'), '')
-      @stop.connect(SIGNAL('clicked()')) { stop() }
-      @op_button_layout.addWidget(@stop)
-      @play = Qt::PushButton.new(Cosmos.get_icon('play-26.png'), '')
-      @play.connect(SIGNAL('clicked()')) { play() }
-      @op_button_layout.addWidget(@play)
-      @step_forward = Qt::PushButton.new(Cosmos.get_icon('fast_forward-26.png'), '')
-      @step_forward_timer = Qt::Timer.new
-      @step_forward_timeout = 100
-      @step_forward_timer.connect(SIGNAL('timeout()')) { step_forward(); @step_forward_timeout = (@step_forward_timeout / 2).to_i; @step_forward_timer.start(@step_forward_timeout) }
-      @step_forward.connect(SIGNAL('pressed()')) { step_forward(); @step_forward_timeout = 300; @step_forward_timer.start(@step_forward_timeout) }
-      @step_forward.connect(SIGNAL('released()')) { @step_forward_timer.stop }
-      @op_button_layout.addWidget(@step_forward)
-      @move_end = Qt::PushButton.new(Cosmos.get_icon('end-26.png'), '')
-      @move_end.connect(SIGNAL('clicked()')) { move_end() }
-      @op_button_layout.addWidget(@move_end)
-      @op_layout.addLayout(@op_button_layout)
-
-      # Speed Selection
-      @playback_delay = nil
-      @speed_select = Qt::ComboBox.new
-      @variants = []
-      @variants << Qt::Variant.new(nil)
-      @speed_select.addItem("No Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.001)
-      @speed_select.addItem("1ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.002)
-      @speed_select.addItem("2ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.005)
-      @speed_select.addItem("5ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.01)
-      @speed_select.addItem("10ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.05)
-      @speed_select.addItem("50ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.125)
-      @speed_select.addItem("125ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.25)
-      @speed_select.addItem("250ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(0.5)
-      @speed_select.addItem("500ms Delay", @variants[-1])
-      @variants << Qt::Variant.new(1.0)
-      @speed_select.addItem("1s Delay", @variants[-1])
-      @variants << Qt::Variant.new(-1.0)
-      @speed_select.addItem("Realtime", @variants[-1])
-      @speed_select.setMaxVisibleItems(11)
-      @speed_select.connect(SIGNAL('currentIndexChanged(int)')) do
-        @playback_delay = @speed_select.itemData(@speed_select.currentIndex).value
-      end
-      @speed_layout = Qt::FormLayout.new()
-      @speed_layout.addRow("&Delay:", @speed_select)
-      @status = Qt::LineEdit.new
-      @status.setReadOnly(true)
-      @status.setText('Stopped')
-      @speed_layout.addRow("&Status:", @status)
-      @op_layout.addLayout(@speed_layout)
-      @log_layout.addWidget(@op)
-
-      @file_pos = Qt::GroupBox.new(tr("File Position"))
-      @file_pos_layout = Qt::VBoxLayout.new(@file_pos)
-      @slider = Qt::Slider.new(Qt::Horizontal)
-      @slider.setRange(0, 10000)
-      @slider.setTickInterval(1000)
-      @slider.setTickPosition(Qt::Slider::TicksBothSides)
-      @slider.setTracking(false)
-      @slider.connect(SIGNAL('sliderReleased()')) { slider_released() }
-      @time_layout = Qt::HBoxLayout.new()
-      @start_time = StringChooser.new(self, 'Start:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
-      @end_time = StringChooser.new(self, 'End:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
-      @current_time = StringChooser.new(self, 'Current:', '', 200, true, true, Qt::AlignCenter | Qt::AlignVCenter)
-      @time_layout.addWidget(@start_time)
-      @time_layout.addWidget(@current_time)
-      @time_layout.addWidget(@end_time)
-      @file_pos_layout.addLayout(@time_layout)
-      @file_pos_layout.addWidget(@slider)
-      @log_layout.addWidget(@file_pos)
-      @top_layout.addWidget(@log_widget)
-
-      # Add the message output
-      @output = Qt::PlainTextEdit.new
-      @output.setReadOnly(true)
-      @output.setMaximumBlockCount(100)
-
-      @top_layout.addWidget(@output, 500)
-
-      # 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
-
-      @central_widget.setLayout(@top_layout)
-    end
-
-    def select_log_file
-      unless @playback_thread
-        packet_log_dialog = PacketLogDialog.new(
-          self, 'Select Log File', @log_directory, @packet_log_reader,
-          [], nil, false, false, true, Cosmos::TLM_FILE_PATTERN,
-          Cosmos::BIN_FILE_PATTERN, false
-        )
-        case packet_log_dialog.exec
-        when Qt::Dialog::Accepted
-          stop()
-          @packet_log_reader = packet_log_dialog.packet_log_reader
-          @log_filename = packet_log_dialog.filenames[0]
-          @log_directory = File.dirname(@log_filename)
-          @log_directory << '/' unless @log_directory[-1..-1] == '\\'
-          @log_name.text = @log_filename
-
-          System.telemetry.reset
-          @cancel = false
-          ProgressDialog.execute(self, 'Analyzing Log File', 500, 10, true, false, true, false, true) do |progress_dialog|
-            progress_dialog.append_text("Processing File: #{@log_filename}\n")
-            progress_dialog.set_overall_progress(0.0)
-            progress_dialog.cancel_callback = method(:cancel_callback)
-            progress_dialog.enable_cancel_button
-            Cosmos.check_log_configuration(@packet_log_reader, @log_filename)
-            @packet_offsets = @packet_log_reader.packet_offsets(@log_filename, lambda {|percentage| progress_dialog.set_overall_progress(percentage); @cancel})
-            @playback_index = 0
-            update_slider_and_current_time(nil)
-            @packet_log_reader.open(@log_filename)
-            progress_dialog.close_done
-          end
-
-          if ProgressDialog.canceled?
-            @packet_log_reader.close
-            @log_name.text = ''
-            @log_filename = nil
-            @packet_offsets = []
-            @playback_index = 0
-            @start_time.value = ''
-            @current_time.value = ''
-            @end_time.value = ''
-          else
-            move_end()
-            move_start()
-          end
-        end
-      end
-    end
-
-    def cancel_callback(progress_dialog = nil)
-      @cancel = true
-      return true, false
-    end
-
-    def move_start
-      if @log_filename and !@playback_thread
-        packet = read_at_index(0, :FORWARD)
-        @start_time.value = packet.received_time.formatted(true, 3, true) if packet and packet.received_time
-      else
-        stop()
-      end
-    end
-
-    def step_back
-      if @log_filename and !@playback_thread
-        @playback_index = @packet_offsets.length - 2 if @playback_index >= @packet_offsets.length
-        read_at_index(@playback_index, :BACKWARD)
-      else
-        stop()
-      end
-    end
-
-    def reverse_play
-      if @log_filename and !@playback_thread
-        @playback_index = @packet_offsets.length - 2 if @playback_index >= @packet_offsets.length
-        start_playback(:BACKWARD)
-      else
-        stop()
-      end
-    end
-
-    def stop
-      @playing = false
-    end
-
-    def play
-      if @log_filename and !@playback_thread
-        @playback_index = 1 if @playback_index < 0
-        start_playback(:FORWARD)
-      else
-        stop()
-      end
-    end
-
-    def step_forward
-      if @log_filename and !@playback_thread
-        @playback_index = 1 if @playback_index < 0
-        read_at_index(@playback_index, :FORWARD)
-      else
-        stop()
-      end
-    end
-
-    def move_end
-      if @log_filename and !@playback_thread
-        packet = read_at_index(@packet_offsets.length - 1, :FORWARD)
-        @end_time.value = packet.received_time.formatted(true, 3, true) if packet and packet.received_time
-      else
-        stop()
-      end
-    end
-
-    def slider_released
-      if @log_filename and !@playback_thread
-        read_at_index(((@slider.sliderPosition / 10000.0) * (@packet_offsets.length - 1)).to_i, :FORWARD)
-      end
-    end
-
-    def start_playback(direction)
-      @playback_thread = Thread.new do
-        error = nil
-        begin
-          @playing = true
-          Qt.execute_in_main_thread(true) do
-            @status.setText('Playing')
-          end
-          previous_packet = nil
-          while (@playing)
-            if @playback_delay
-              packet_start = Time.now.sys
-              packet = read_at_index(@playback_index, direction)
-              break unless packet
-              delay_time = 0.0
-              if @playback_delay > 0.0
-                delay_time = @playback_delay - (Time.now.sys - packet_start)
-              elsif previous_packet and packet.received_time and previous_packet.received_time
-                if direction == :FORWARD
-                  delay_time = packet.received_time - previous_packet.received_time - (Time.now.sys - packet_start)
-                else
-                  delay_time = previous_packet.received_time - packet.received_time - (Time.now.sys - packet_start)
-                end
-              end
-              sleep(delay_time) if delay_time > 0.0
-              previous_packet = packet
-            else
-              packet = read_at_index(@playback_index, direction)
-              break unless packet
-            end
-          end
-        rescue Exception => error
-          Qt.execute_in_main_thread(true) {|| ExceptionDialog.new(self, error, "Playback Thread")}
-        ensure
-          Qt.execute_in_main_thread(true) do
-            @status.setText('Stopped')
-          end
-          @playing = false
-          @playback_thread = nil
-        end
-      end
-    end
-
-    def read_at_index(index, direction)
-      packet_offset = nil
-      packet_offset = @packet_offsets[index] if index >= 0
-      if packet_offset
-        # Read the packet
-        packet = @packet_log_reader.read_at_offset(packet_offset, false)
-        handle_packet(packet)
-
-        # Adjust index for next read
-        if direction == :FORWARD
-          @playback_index = index + 1
-        else
-          @playback_index = index - 1
-        end
-        update_slider_and_current_time(packet)
-
-        return packet
-      else
-        return nil
-      end
-    end
-
-    def update_slider_and_current_time(packet)
-      Qt.execute_in_main_thread(false) do
-        value = (((@playback_index - 1) / @packet_offsets.length.to_f) * 10000).to_i
-        @slider.setSliderPosition(value)
-        @slider.setValue(value)
-        @current_time.value = packet.received_time.formatted(true, 3, true) if packet and packet.received_time
-      end
-    end
-
-    def handle_packet(packet)
-      # For replay we will try our best here but not crash on errors
-      begin
-        interface = nil
-
-        # Identify and update packet
-        if packet.identified?
-          # Preidentifed packet - place it into the current value table
-          identified_packet = System.telemetry.update!(packet.target_name,
-                                                       packet.packet_name,
-                                                       packet.buffer)
-        else
-          # Packet needs to be identified
-          identified_packet = System.telemetry.identify!(packet.buffer)
-        end
-
-        if identified_packet and packet.target_name != 'UNKNOWN'
-          identified_packet.received_time = packet.received_time
-          packet = identified_packet
-          target = System.targets[packet.target_name.upcase]
-          interface = target.interface if target
-        else
-          unknown_packet = System.telemetry.update!('UNKNOWN', 'UNKNOWN', packet.buffer)
-          unknown_packet.received_time = packet.received_time
-          packet = unknown_packet
-          data_length = packet.length
-          string = "Unknown #{data_length} byte packet starting: "
-          num_bytes_to_print = [UNKNOWN_BYTES_TO_PRINT, data_length].min
-          data_to_print = packet.buffer(false)[0..(num_bytes_to_print - 1)]
-          data_to_print.each_byte do |byte|
-            string << sprintf("%02X", byte)
-          end
-          time_string = ''
-          time_string = packet.received_time.formatted << '  ' if packet.received_time
-          puts "#{time_string}ERROR:  #{string}"
-        end
-
-        target = System.targets[packet.target_name]
-        target.tlm_cnt += 1 if target
-        packet.received_count += 1
-        packet.check_limits(System.limits_set)
-        ReplayServer.instance.post_packet(packet)
-
-        # Write to routers
-        if interface
-          interface.routers.each do |router|
-            begin
-              router.write(packet) if router.write_allowed? and router.connected?
-            rescue => err
-              Logger.error "Problem writing to router #{router.name} - #{err.class}:#{err.message}"
-            end
-          end
-        end
-      rescue Exception => err
-        Logger.error "Problem handling packet #{packet.target_name} #{packet.packet_name} - #{err.class}:#{err.message}"
-      end
-    end
-
-    def process_server_messages(options)
-      # Start thread to read server messages
-      @output_thread = Thread.new do
-        begin
-          while !@ready
-            sleep(1)
-          end
-          while true
-            if @string_output.string[-1..-1] == "\n"
-              Qt.execute_in_main_thread(true) do
-                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) }
-                @output.flush
-              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
-
-    def closeEvent(event)
-      Cosmos.kill_thread(self, @playback_thread)
-      super(event)
-    end
-
-    # Gracefully kill threads
-    def graceful_kill
-      stop()
-    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.title = 'Replay'
-          options.width = 800
-          options.height = 500
-          options.auto_size = false
-          options.config_file = CmdTlmServer::DEFAULT_CONFIG_FILE
-          option_parser.separator "Replay Specific Options:"
-          option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
-            options.config_file = arg
-          end
-        end
-
-        super(option_parser, options)
-      end
-    end
-
-  end # class Replay
-
-end # module Cosmos
+  class Replay < CmdTlmServerGui
+  end
+end