cosmos 3.0.0

data/lib/cosmos/tools/tlm_viewer/tlm_viewer.rb

@@ -0,0 +1,544 @@
+# 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'
+Cosmos.catch_fatal_exception do
+  require 'cosmos/script'
+  require 'cosmos/tools/tlm_viewer/screen'
+  require 'cosmos/gui/qt_tool'
+  require 'cosmos/gui/dialogs/splash'
+  require 'cosmos/gui/dialogs/progress_dialog'
+  require 'cosmos/gui/dialogs/select_dialog'
+  require 'cosmos/gui/widgets/full_text_search_line_edit'
+  require 'cosmos/tools/tlm_viewer/tlm_viewer_config'
+  require 'find'
+end
+
+module Cosmos
+  Cosmos.disable_warnings do
+    module Script
+      private
+
+      def display(display_name, x_pos = nil, y_pos = nil)
+        TlmViewer.instance.display(display_name, x_pos, y_pos)
+      end
+
+      def clear(display_name)
+        TlmViewer.instance.clear(display_name)
+      end
+    end
+  end
+end # module Cosmos
+
+module Cosmos
+
+  # The Telemetry Viewer Application provides a frameword for user defined
+  # 'screens'. Screens can contain telemetry items but also command senders,
+  # graphs, and any other user defined widgets. The TlmViewer class itself is
+  # responsible for reading the tlm_viewer.txt file and building the list of
+  # screens. The actual rendering of the screen is defered to the various
+  # widget classes.
+  class TlmViewer < QtTool
+    @@instance = nil
+
+    def self.instance
+      @@instance
+    end
+
+    def self.load_config(filename)
+      # Determine MD5 over main config file and all screens
+      tlmviewer_files = [filename, System.initial_filename]
+      additional_data = ''
+      System.targets.each do |target_name, target|
+        tlmviewer_files << target.filename if File.exist?(target.filename)
+        screen_dir = File.join(Cosmos::USERPATH, 'config', 'targets', target.original_name, 'screens')
+        if File.exist?(screen_dir)
+          if target.substitute
+            additional_data << target.original_name
+            additional_data << target.name
+          else
+            additional_data << target.original_name
+          end
+          Dir.new(screen_dir).each do |screen_dir_filename|
+            if screen_dir_filename[0..0] != '.'
+              tlmviewer_files << File.join(screen_dir, screen_dir_filename)
+            end
+          end
+        end
+      end
+
+      md5 = Cosmos.md5_files(tlmviewer_files, additional_data)
+      md5_string = md5.hexdigest
+
+      # Build filename for marshal file
+      marshal_filename = File.join(System.paths['TMP'], 'tlmviewer_' << md5_string << '.bin')
+
+      # Attempt to load marshal file
+      config = Cosmos.marshal_load(marshal_filename)
+      unless config
+        # Marshal file load failed - Manually load configuration
+        config = TlmViewerConfig.new(filename)
+
+        # Create marshal file for next time
+        Cosmos.marshal_dump(marshal_filename, config)
+      end
+
+      return config
+    end
+
+    def initialize(options)
+      # MUST BE FIRST - All code before super is executed twice in RubyQt Based classes
+      super(options)
+      Cosmos.load_cosmos_icon("tlm_viewer.png")
+      setMinimumWidth(300)
+      @@instance = self
+
+      # Get Params from Config File
+      if options.config_file
+        filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'tlm_viewer', options.config_file)
+      else
+        filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'tlm_viewer', 'tlm_viewer.txt')
+      end
+
+      Splash.execute(self, true) do |splash|
+        ConfigParser.splash = splash
+        splash.message = "Starting TlmViewer"
+        System.telemetry
+        @tlm_viewer_config = self.class.load_config(filename)
+        ConfigParser.splash = nil
+      end
+
+      initialize_actions()
+      initialize_menus(options)
+      initialize_central_widget(options)
+      complete_initialize()
+
+      Splash.execute(self) do |splash|
+        ConfigParser.splash = splash
+        splash.message = "Displaying requested screens"
+
+        # Startup desired screens once we're running
+        @tlm_viewer_config.screen_infos.each do |screen_full_name, screen_info|
+          if screen_info.show_on_startup
+            display(screen_full_name, screen_info.x_pos, screen_info.y_pos)
+          end
+        end
+
+        if options.listen
+          # Start DRb with access control
+          @json_drb = JsonDRb.new
+          port = System.ports['TLMVIEWER_API']
+          acl = ACL.new(['allow', '127.0.0.1'], ACL::ALLOW_DENY)
+          @json_drb.acl = acl
+          whitelist = [
+            'display',
+            'clear']
+          @json_drb.method_whitelist = whitelist
+          begin
+            @json_drb.start_service "localhost", port, self
+          rescue Exception
+            raise FatalError.new("Error starting JsonDRb on port #{port}.\nPerhaps a Telemetry Viewer is already running?")
+          end
+        else
+          @json_drb = nil
+        end
+
+        @all_telemetry = System.telemetry.all_item_strings(false, splash)
+
+        Qt.execute_in_main_thread(true) do
+          @search_box.completion_list = @tlm_viewer_config.completion_list
+          @search_box.callback = lambda do |tlm|
+            mapping = @tlm_viewer_config.tlm_to_screen_mapping[tlm]
+            if mapping
+              mapping.each do |screen_name|
+                display(screen_name)
+              end
+            end
+          end
+        end
+
+        ConfigParser.splash = nil
+      end
+    end
+
+    def initialize_actions
+      super()
+
+      # File actions
+      @file_save = Qt::Action.new(Cosmos.get_icon('save.png'), tr('&Save Configuration'), self)
+      @file_save_keyseq = Qt::KeySequence.new(tr('Ctrl+S'))
+      @file_save.shortcut = @file_save_keyseq
+      @file_save.statusTip = tr('Save all screen positions')
+      @file_save.connect(SIGNAL('triggered()')) { file_save() }
+
+      @file_generate = Qt::Action.new(tr('&Generate Screens'), self)
+      @file_generate_keyseq = Qt::KeySequence.new(tr('Ctrl+G'))
+      @file_generate.shortcut = @file_generate_keyseq
+      @file_generate.statusTip = tr('Generate screen definition files')
+      @file_generate.connect(SIGNAL('triggered()')) { file_generate() }
+
+      @file_audit = Qt::Action.new(tr('Audi&t Screens vs Tlm'), self)
+      @file_audit_keyseq = Qt::KeySequence.new(tr('Ctrl+T'))
+      @file_audit.shortcut = @file_audit_keyseq
+      @file_audit.statusTip = tr('Create a report listing which telemetry points are not on screens')
+      @file_audit.connect(SIGNAL('triggered()')) { file_audit() }
+    end
+
+    def initialize_menus(options)
+      # File Menu
+      @file_menu = menuBar.addMenu(tr('&File'))
+      @file_menu.addAction(@file_save)
+      @file_menu.addAction(@file_generate)
+      @file_menu.addAction(@file_audit)
+      @file_menu.addSeparator()
+      @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 representations ranging from the raw data to formatted with units."
+
+      initialize_help_menu()
+    end
+
+    def initialize_central_widget(options)
+      # Create the central widget
+      @central_widget = Qt::Widget.new
+      setCentralWidget(@central_widget)
+      @top_layout = Qt::VBoxLayout.new
+
+      # Create Search box
+      @search_layout = Qt::HBoxLayout.new
+      @search_box = FullTextSearchLineEdit.new(self)
+      @search_box.setStyleSheet("padding-right: 20px;padding-left: 5px;background: url(#{File.join(Cosmos::PATH, 'data', 'search-14.png')});background-position: right;background-repeat: no-repeat;")
+      @search_layout.addWidget(@search_box)
+      @top_layout.addLayout(@search_layout)
+
+      # Create Screen Drop Down Lists
+      @selection_pane = Qt::HBoxLayout.new
+      @top_layout.addLayout(@selection_pane)
+      @column_widgets = []
+      @tlm_viewer_config.columns.each_with_index do |target_screen_infos, column_index|
+        @column_widgets[column_index] = {}
+        if column_index != 0
+          # Separator before editor
+          @column_widgets[column_index][:sep1] = Qt::Frame.new(@central_widget)
+          @column_widgets[column_index][:sep1].setFrameStyle(Qt::Frame::VLine | Qt::Frame::Sunken)
+          @selection_pane.addWidget(@column_widgets[column_index][:sep1])
+        end
+        @column_widgets[column_index][:grid] = Qt::GridLayout.new
+        @selection_pane.addLayout(@column_widgets[column_index][:grid])
+        row = 0
+        @column_widgets[column_index][:rows] = []
+        target_screen_infos.each do |target_name, screen_infos|
+          @column_widgets[column_index][:rows][row] = {}
+
+          # Create Label for Category
+          @column_widgets[column_index][:rows][row][:label] = Qt::Label.new("#{target_name}:")
+          @column_widgets[column_index][:grid].addWidget(@column_widgets[column_index][:rows][row][:label], row, 0)
+
+          # Create Drop Down Menu for Category
+          @column_widgets[column_index][:rows][row][:screen_select] = Qt::ComboBox.new
+          @variants = []
+          screen_infos.each do |screen_name, screen_info|
+            @variants <<  Qt::Variant.new(screen_info.full_name)
+            @column_widgets[column_index][:rows][row][:screen_select].addItem(screen_info.name, @variants[-1])
+          end
+          if screen_infos.length >= 20
+            @column_widgets[column_index][:rows][row][:screen_select].setMaxVisibleItems(20)
+          else
+            @column_widgets[column_index][:rows][row][:screen_select].setMaxVisibleItems(screen_infos.length)
+          end
+          my_row = row
+          handler = lambda do
+            screen_full_name = @column_widgets[column_index][:rows][my_row][:screen_select].itemData(@column_widgets[column_index][:rows][my_row][:screen_select].currentIndex)
+            display(screen_full_name.value)
+          end
+          @column_widgets[column_index][:rows][row][:screen_select].connect(SIGNAL('activated(int)')) { handler.call }
+          @column_widgets[column_index][:grid].addWidget(@column_widgets[column_index][:rows][row][:screen_select], row, 1)
+
+          @column_widgets[column_index][:rows][row][:show_screen] = Qt::PushButton.new("Show Screen")
+          @column_widgets[column_index][:rows][row][:show_screen].connect(SIGNAL('clicked(bool)')) { handler.call }
+          @column_widgets[column_index][:grid].addWidget(@column_widgets[column_index][:rows][row][:show_screen], row, 2)
+
+          row += 1
+        end
+      end
+
+      @central_widget.setLayout(@top_layout)
+    end
+
+    # Handles saving the current configuration to a file
+    def file_save
+      filename = Qt::FileDialog.getSaveFileName(self, "Save Configuration", @tlm_viewer_config.filename, "Config Files (*.txt);;All Files (*)")
+      if filename and not filename.empty?
+        # Update config with open screen positions and show on startup
+        Screen.open_screens.clone.each do |screen|
+          @tlm_viewer_config.screen_infos.each do |screen_full_name, screen_info|
+            if screen_full_name == screen.full_name
+              begin
+                screen_info.x_pos = screen.window.x
+                screen_info.y_pos = screen.window.y
+                screen_info.show_on_startup = true
+              rescue
+                # Screen probably already closed - continue
+              end
+              break
+            end
+          end
+        end
+
+        filename << '.txt' if File.extname(filename).empty?
+        @tlm_viewer_config.save(filename)
+      end
+    end # def on_file_save_config
+
+    def generate_target(target_name)
+      target = System.targets[target_name]
+
+      results = ''
+      screen_dir = File.join(USERPATH, 'config', 'targets', target.original_name, 'screens')
+      Dir.mkdir(screen_dir, 0777) unless File.exist?(screen_dir)
+
+      System.telemetry.packets(target.name).each do |packet_name, packet|
+        filename = File.join(screen_dir, packet_name.downcase + '.txt')
+        unless File.exist?(filename)
+          results << "Creating #{filename}...\n"
+          File.open(filename, 'w') do |file|
+            items = packet.sorted_items
+            if items.length > 34
+              file.puts "SCREEN 250 800 1.0"
+              file.puts ""
+              file.puts "SCROLLWINDOW"
+            else
+              file.puts "SCREEN AUTO AUTO 1.0"
+            end
+            file.puts ""
+            file.puts "  VERTICALBOX"
+            items.each do |item|
+              file.puts "    LABELVALUE #{target.original_name} #{packet_name} #{item.name} # #{item.description}"
+            end
+            file.puts "  END"
+            file.puts ""
+            file.puts "END" if items.length > 34
+          end
+        else
+          results << "Skipping #{filename}... already exists\n"
+        end
+      end
+
+      return results
+    end
+
+    def file_generate
+      target_names = System.telemetry.target_names
+      target_names.delete('UNKNOWN')
+      target_names.unshift('ALL')
+
+      dialog = SelectDialog.new(self, 'Target Name:', target_names, 'Select Target Name to Generate Screens')
+      target_name = dialog.result
+      if target_name
+        ProgressDialog.execute(self, 'Generating Telemetry Screens', 500, 10, false, false, true, true, false) do |progress_dialog|
+          if target_name == 'ALL'
+            System.telemetry.target_names.each do |my_target_name|
+              next if my_target_name == 'UNKNOWN'
+              progress_dialog.append_text(generate_target(my_target_name))
+            end
+          else
+            progress_dialog.append_text(generate_target(target_name))
+          end
+          progress_dialog.complete
+        end
+      end
+    end
+
+    def file_audit
+      output_filename = ''
+      all_telemetry = @all_telemetry.clone
+
+      # Open a progress dialog with out a step progress
+      ProgressDialog.execute(self, 'Audit Progress', 650, 400, true, false) do |progress|
+        progress.enable_cancel_button
+        begin
+          index = 1
+          @tlm_viewer_config.screen_infos.each do |name, info|
+            progress.append_text("Processing screen #{name}")
+            screen_text = File.read(info.filename).upcase
+            found = []
+            all_telemetry.each do |tlm|
+              found << tlm if screen_text.include? tlm
+            end
+            all_telemetry -= found
+
+            progress.set_overall_progress(index.to_f / @tlm_viewer_config.screen_infos.length.to_f)
+            index += 1
+          end
+
+          output_filename = File.join(System.paths['LOGS'],
+                                      File.build_timestamped_filename(['screen','audit'], '.txt'))
+          File.open(output_filename, 'w') do |file|
+            file.puts "Telemetry Viewer audit created on #{Time.now.formatted}.\n"
+            if all_telemetry.empty?
+              msg = "\nAll telemetry points accounted for in screens."
+              progress.append_text(msg)
+              file.puts msg
+            else
+              progress.append_text("\nThere were #{all_telemetry.length} telemetry points not accounted for.")
+              file.puts "\nThe following telemetry points were not on any screens:"
+              all_telemetry.map {|item| file.puts item }
+            end
+          end
+        rescue => error
+          progress.append_text("Error processing:\n#{error.formatted}\n")
+        ensure
+          progress.append_text("\nWriting audit to #{output_filename}")
+          progress.set_overall_progress(1.0)
+          progress.complete
+        end
+      end
+      # Open the file as a convenience
+      Cosmos.open_in_text_editor(output_filename) if output_filename
+    end
+
+    # Method called by screens to notify that they have been closed
+    def notify(closed_screen)
+      screen_full_name = closed_screen.full_name
+      begin
+        screen_info = find_screen_info(screen_full_name)
+        screen_info.screen = nil
+      rescue
+        # Oh well
+      end
+    end
+
+    def closeEvent(event)
+      # Are you sure if any screens are open
+      if Screen.open_screens.length > 0
+        result = Qt::MessageBox.warning(self, "Confirm Close",
+          "Are you sure? All Open Telemetry Screens will be Closed.",
+          Qt::MessageBox::Yes | Qt::MessageBox::No)
+        if result != Qt::MessageBox::Yes
+          event.ignore()
+        else
+          # Close any open screens
+          Screen.close_all_screens(self)
+          shutdown_cmd_tlm()
+          @json_drb.stop_service if @json_drb
+          super(event)
+        end
+      end
+    end
+
+    def find_screen_info(screen_full_name)
+      screen_info = @tlm_viewer_config.screen_infos[screen_full_name.upcase]
+      raise "Unknown screen: #{screen_full_name.upcase}" unless screen_info
+      screen_info
+    end
+
+    def display(screen_full_name, x_pos = nil, y_pos = nil)
+      return unless screen_full_name
+      # Find the specified screen
+      screen_info = find_screen_info(screen_full_name)
+
+      # Raise Screens that are already open
+      if screen_info.screen
+        success = false
+        Qt.execute_in_main_thread(true) do
+          begin
+            screen_info.screen.window.raise
+            screen_info.screen.window.showNormal
+            success = true
+          rescue
+            # Screen probably was closed - continue
+            screen_info.screen = nil
+          end
+        end
+        return if success
+      end
+
+      # Create screens that are not open yet
+      Qt.execute_in_main_thread(true) do
+        if x_pos and y_pos
+          screen_info.screen = Screen.new(screen_info.full_name, screen_info.filename, self, :REALTIME, x_pos, y_pos, screen_info.original_target_name, screen_info.substitute, screen_info.force_substitute)
+        else
+          screen_info.screen = Screen.new(screen_info.full_name, screen_info.filename, self, :REALTIME, screen_info.x_pos, screen_info.y_pos, screen_info.original_target_name, screen_info.substitute, screen_info.force_substitute)
+        end
+      end
+    end
+
+    # Close the specified screen
+    def clear(screen_full_name)
+      # Find the specified screen
+      screen_info = find_screen_info(screen_full_name)
+
+      # Close the screen
+      Qt.execute_in_main_thread(true) do
+        begin
+          screen_info.screen.window.close if screen_info.screen
+        ensure
+          screen_info.screen = nil
+        end
+      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.title = 'Telemetry Viewer'
+          options.screen = nil
+          options.listen = true
+          options.config_file = nil
+          options.restore_size = false
+
+          option_parser.separator "Telemetry Viewer Specific Options:"
+          option_parser.on("-c", "--config FILE", "Use the specified config file") { |arg| options.config_file = arg }
+          option_parser.on("-s", "--screen FILE", "Start up the specified screen") { |arg| options.screen = arg }
+          option_parser.on("-n", "--nolisten", "Don't listen for requests") do
+            options.listen = false
+            options.title += ' : Not Listening'
+          end
+          option_parser.parse!(ARGV)
+        end
+
+        if options.screen
+          application = nil
+          begin
+            QtTool.redirect_io
+            System.telemetry
+            application = Qt::Application.new(ARGV)
+            application.addLibraryPath(Qt::PLUGIN_PATH) if Kernel.is_windows?
+            if options.config_file
+              filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'tlm_viewer', options.config_file)
+            else
+              filename = File.join(::Cosmos::USERPATH, 'config', 'tools', 'tlm_viewer', 'tlm_viewer.txt')
+            end
+            tlm_viewer_config = load_config(filename)
+            screen_info = tlm_viewer_config.screen_infos[options.screen.upcase]
+            raise "Unknown screen: #{options.screen.upcase}" unless screen_info
+            if not options.auto_position
+              screen_info.screen = Screen.new(screen_info.full_name, screen_info.filename, nil, :REALTIME, options.x, options.y, screen_info.original_target_name, screen_info.substitute, screen_info.force_substitute, true)
+            else
+              screen_info.screen = Screen.new(screen_info.full_name, screen_info.filename, nil, :REALTIME, screen_info.x_pos, screen_info.y_pos, screen_info.original_target_name, screen_info.substitute, screen_info.force_substitute, true)
+            end
+            application.exec
+          rescue Exception => error
+            unless error.class == SystemExit or error.class == Interrupt
+              Cosmos.handle_fatal_exception(error, false)
+            end
+          end
+        else
+          super(option_parser, options)
+        end
+      end
+    end
+
+  end # class TlmViewer
+
+end # module Cosmos