adams-visiona 1.0.0

data/lib/cosmos/tools/table_manager/table_manager_core.rb

@@ -0,0 +1,320 @@
+# 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/table_manager/table_config'
+
+module Cosmos
+  # Provides the low level Table Manager methods which do not require a GUI.
+  class TableManagerCore
+    # Generic error raised when a more specific error doesn't work
+    class CoreError < StandardError; end
+    # Raised when opening a file that is either larger or smaller than its definition
+    class MismatchError < CoreError; end
+    # Raised when there is no current table configuration
+    class NoConfigError < CoreError
+      # @return [String] Error message
+      def message
+        "No current table configuration"
+      end
+    end
+    # Raised when there is no table in the current configuration
+    class NoTableError < CoreError
+      # @return [String] Error message
+      def message
+        "Table does not exist in current configuration"
+      end
+    end
+
+    # @return [TableConfig] Configuration instance
+    attr_reader :config
+
+    # Create the instance
+    def initialize
+      reset()
+    end
+
+    # Clears the configuration
+    def reset
+      @config = nil
+    end
+
+    # @param filename [String] Create a new TableConfig instance and process the filename
+    def process_definition(filename)
+      @config = TableConfig.new()
+      @config.process_file(filename)
+    end
+
+    # @param def_path [String] Definition file to process
+    # @param output_dir [String] Output directory to create the new file
+    # @return [String] Binary file path
+    def file_new(def_path, output_dir)
+      process_definition(def_path)
+      yield 0.3 if block_given?
+
+      @config.table_names.each {|table_name| set_binary_data_to_default(table_name) }
+      yield 0.7 if block_given?
+
+      bin_path = File.join(output_dir, def_to_bin_filename(def_path))
+      file_save(bin_path)
+      bin_path
+    end
+
+    # @param bin_path [String] Binary file to open
+    # @param def_path [String] Definition file to use when opening
+    def file_open(bin_path, def_path)
+      process_definition(def_path)
+      open_and_load_binary_file(bin_path)
+    end
+
+    # Saves the current tables in the config instance to the given filename.
+    #
+    # @param filename [String] Filename to write, overwritten if it exists.
+    def file_save(filename)
+      raise NoConfigError unless @config
+      file_check()
+      File.open(filename, "wb") do |file|
+        @config.tables.each do |table_name, table|
+          file.write(table.buffer)
+        end
+      end
+      file_report(filename, @config.filename)
+    end
+
+    # @return [String] Success string if parameters all check. Raises
+    #   a CoreError if errors are found.
+    def file_check
+      raise NoConfigError unless @config
+      result = ""
+      @config.table_names.each do |name|
+        table_result = table_check(name)
+        unless table_result.empty?
+          result << "Errors in #{name}:\n" + table_result
+        end
+      end
+      raise CoreError, result unless result.empty?
+      "All parameters are within their constraints."
+    end
+
+    # Create a CSV report file based on the file contents.
+    #
+    # @param bin_path [String] Binary filename currently open. Used to generate the
+    #   report name such that it matches the binary filename.
+    # @param def_path [String] Definition filename currently open
+    # @return [String] Report filename path
+    def file_report(bin_path, def_path)
+      raise NoConfigError unless @config
+      file_check()
+
+      basename = File.basename(bin_path, ".dat")
+      report_path = File.join(File.dirname(bin_path), "#{basename}.csv")
+      File.open(report_path, 'w+') do |file|
+        file.write("File Definition, #{def_path}\n")
+        file.write("File Binary, #{bin_path}\n\n")
+        @config.tables.values.each do |table|
+          items = table.sorted_items
+          file.puts(table.table_name)
+
+          # Write the column headers
+          if table.type == :TWO_DIMENSIONAL
+            columns = ["Item"]
+            # Remove the '0' from the 'itemname0'
+            table.num_columns.times.each {|x| columns << items[x].name[0...-1] }
+            file.puts columns.join(", ")
+          else
+            file.puts "Label, Value"
+          end
+
+          # Write the table item values
+          (0...table.num_rows).each do |r|
+            if table.type == :TWO_DIMENSIONAL
+              rowtext = "#{r + 1}"
+            else
+              rowtext = items[r].name
+            end
+
+            file.write "#{rowtext}, "
+            (0...table.num_columns).each do |c|
+              if table.type == :TWO_DIMENSIONAL
+                table_item = items[c + r * table.num_columns]
+              else
+                table_item = items[r]
+              end
+
+              file.write "#{table.read(table_item.name, :FORMATTED).to_s}, "
+            end
+            file.write("\n") # newline after each row
+          end
+          file.write("\n") # newline after each table
+        end
+      end
+      report_path
+    end
+
+    # Create a hex formatted string of all the file data
+    def file_hex
+      raise NoConfigError unless @config
+      data = ""
+      @config.tables.values.each {|table| data << table.buffer }
+      "#{data.formatted}\n\nTotal Bytes Read: #{data.length}"
+    end
+
+    # @param table_name [String] Name of the table to check for out of range values
+    def table_check(table_name)
+      raise NoConfigError unless @config
+      table = @config.table(table_name)
+      raise NoTableError unless table
+
+      result = ""
+      table_items = table.sorted_items
+
+      # Check the ranges and constraints for each item in the table
+      # We go through it this way (by row and columns) so we can grab the actual
+      # user input when we display any errors found
+      (0...table.num_rows).each do |r|
+        (0...table.num_columns).each do |c|
+          # get the table item definition so we know how to save it
+          table_item = table_items[r * table.num_columns + c]
+
+          value = table.read(table_item.name)
+          unless table_item.range.nil?
+            # If the item has states which include the value, then convert
+            # the state back to the numeric value for range checking
+            if table_item.states && table_item.states.include?(value)
+              value = table_item.states[value]
+            end
+            # check to see if the value lies within its valid range
+            unless table_item.range.include?(value)
+              if table_item.format_string
+                value = table.read(table_item.name, :FORMATTED)
+                range_first = sprintf(table_item.format_string, table_item.range.first)
+                range_last = sprintf(table_item.format_string, table_item.range.last)
+              else
+                range_first = table_item.range.first
+                range_last = table_item.range.last
+              end
+              result << "  #{table_item.name}: #{value} outside valid range of #{range_first}..#{range_last}\n"
+            end
+          end
+        end # end each column
+      end # end each row
+      result
+    end
+
+    # @param table_name [String] Name of the table to revert all values to default
+    def table_default(table_name)
+      raise NoConfigError unless @config
+      set_binary_data_to_default(table_name)
+    end
+
+    # @param table_name [String] Create a hex formatted string of the given table data
+    def table_hex(table_name)
+      raise NoConfigError unless @config
+      table = @config.table(table_name)
+      raise NoTableError unless table
+      "#{table.buffer.formatted}\n\nTotal Bytes Read: #{table.buffer.length}"
+    end
+
+    # @param table_name [String] Table name to write as a stand alone file
+    # @param filename [String] Filename to write the table data to. Existing
+    #   files will be overwritten.
+    def table_save(table_name, filename)
+      raise NoConfigError unless @config
+      result = table_check(table_name)
+      raise CoreError, "Errors in #{table_name}:\n#{result}" unless result.empty?
+      File.open(filename, 'wb') {|file| file.write(@config.table(table_name).buffer) }
+    end
+
+    # Commit a table from the current configuration into a new binary
+    #
+    # @param table_name [String] Table name to commit to an existing binary
+    # @param bin_file [String] Binary file to open
+    # @param def_file [String] Definition file to use when opening
+    def table_commit(table_name, bin_file, def_file)
+      raise NoConfigError unless @config
+      save_table = @config.table(table_name)
+      raise NoTableError unless save_table
+
+      result = table_check(table_name)
+      raise CoreError, "Errors in #{table_name}:\n#{result}" unless result.empty?
+
+      config = TableConfig.new
+      begin
+        config.process_file(def_file)
+      rescue => err
+        raise CoreError, "The table definition file:#{def_file} has the following errors:\n#{err}"
+      end
+
+      if !config.table_names.include?(table_name.upcase)
+        raise NoTableError, "#{table_name} not found in #{def_file} table definition file."
+      end
+
+      saved_config = @config
+      @config = config
+      open_and_load_binary_file(bin_file)
+
+      # Store the saved table data in the new table definition
+      table = config.table(save_table.table_name)
+      table.buffer = save_table.buffer[0...table.length]
+      file_save(bin_file)
+      @config = saved_config
+    end
+
+    protected
+
+    # Set all the binary data in the table to the default values
+    def set_binary_data_to_default(table_name)
+      table = @config.table(table_name)
+      raise NoTableError unless table
+      table.restore_defaults
+    end
+
+    # Get the binary filename equivalent for the given definition filename
+    def def_to_bin_filename(def_path)
+      if File.basename(def_path) =~ /_def\.txt$/
+        # Remove _def.txt if present (should be)
+        basename = File.basename(def_path)[0...-8]
+      else
+        # Remove any extension if present
+        basename = File.basename(def_path, File.extname(def_path))
+      end
+      "#{basename}.dat"
+    end
+
+    # Opens the given binary file and populates the table definition.
+    # The filename parameter should be a properly formatted file path.
+    def open_and_load_binary_file(filename)
+      begin
+        data = nil
+        # read the binary file and store it into an array
+        File.open(filename, 'rb') do |file|
+          data = file.read
+        end
+      rescue => err
+        raise "Unable to open and load #{filename} due to #{err}."
+      end
+
+      binary_data_index = 0
+      total_table_length = 0
+      @config.tables.each {|table_name, table| total_table_length += table.length }
+      @config.tables.each do |table_name, table|
+        if binary_data_index + table.length > data.length
+          table.buffer = data[binary_data_index..-1]
+          raise MismatchError, "Binary size of #{data.length} not large enough to fully represent table definition of length #{total_table_length}. The remaining table definition (starting with byte #{data.length - binary_data_index} in #{table.table_name}) will be filled with 0."
+        end
+        table.buffer = data[binary_data_index...binary_data_index + table.length]
+        binary_data_index += table.length
+      end
+      if binary_data_index < data.length
+        raise MismatchError, "Binary size of #{data.length} larger than table definition of length #{total_table_length}. Discarding the remaing #{data.length - binary_data_index} bytes."
+      end
+    end
+  end
+end # module Cosmos

data/lib/cosmos/tools/table_manager/table_parser.rb

@@ -0,0 +1,75 @@
+# 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/tools/table_manager/table'
+
+module Cosmos
+  # Parses the TABLE keyword definition in table configuration files.
+  class TableParser < PacketParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param tables [Hash] Hash of the currently defined tables
+    # @param warnings [Array<String>] Any warning strings generated while
+    #   parsing this command will be appened to this array
+    def self.parse_table(parser, tables, warnings)
+      parser = TableParser.new(parser)
+      parser.verify_parameters()
+      parser.create_table(tables, warnings)
+    end
+
+    # Verify the correct number of arguments to the TABLE keyword
+    def verify_parameters
+      @usage = "TABLE <TABLE NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DISPLAY: ONE_DIMENSIONAL/TWO_DIMENSIONAL> <TWO_DIMENSIONAL TABLE ROWS> <DESCRIPTION (Optional)>"
+      @parser.verify_num_parameters(3, 5, @usage)
+    end
+
+    # @param tables [Array<Table>] All tables defined in the configuration
+    # @param warnings [String] List of warnings to append to
+    def create_table(tables, warnings)
+      params = @parser.parameters
+      table_name = params[0].to_s.upcase
+      endianness = params[1].to_s.upcase.to_sym
+      if endianness != :BIG_ENDIAN && endianness != :LITTLE_ENDIAN
+        raise @parser.error("Invalid endianness #{params[1]}. Must be BIG_ENDIAN or LITTLE_ENDIAN.", @usage)
+      end
+      type = params[2].to_s.upcase.to_sym
+      case type
+      when :ONE_DIMENSIONAL
+        @parser.verify_num_parameters(3, 4, @usage)
+        description = params[3].to_s
+      when :TWO_DIMENSIONAL
+        @parser.verify_num_parameters(4, 5, @usage)
+        num_rows = params[3].to_i
+        description = params[4].to_s
+      else
+        raise @parser.error("Invalid display type #{params[2]}. Must be ONE_DIMENSIONAL or TWO_DIMENSIONAL.", @usage)
+      end
+      table = Table.new(table_name, endianness, type, description, @parser.filename)
+      table.num_rows = num_rows if type == :TWO_DIMENSIONAL
+      TableParser.finish_create_table(table, tables, warnings)
+    end
+
+    protected
+
+    def self.check_for_duplicate(tables, table)
+      msg = nil
+      if tables[Table::TARGET][table.table_name]
+        msg = "Table #{table.table_name} redefined."
+        Logger.instance.warn msg
+      end
+      msg
+    end
+
+    def self.finish_create_table(table, tables, warnings)
+      warning = TableParser.check_for_duplicate(tables, table)
+      warnings << warning if warning
+      table
+    end
+  end
+end

data/lib/cosmos/tools/test_runner/results_writer.rb

@@ -0,0 +1,287 @@
+# 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/script'
+require 'zip'
+require 'cosmos/gui/dialogs/set_tlm_dialog'
+
+module Cosmos
+
+  class ResultsWriter
+    attr_reader :filename
+    attr_accessor :data_package
+    attr_accessor :metadata
+    attr_accessor :auto_cycle_logs
+
+    TIME_TOLERANCE = 5.0
+
+    def initialize
+      @filename = nil
+      @file = nil
+      @context = nil
+      @path = System.paths['LOGS']
+      @start_time = nil
+      @stop_time = nil
+      @results = nil
+      @settings = nil
+      @data_package = false
+      @canceled = false
+      @metadata = nil
+      @auto_cycle_logs = false
+    end
+
+    def start(test_type, test_suite_class, test_class = nil, test_case = nil, settings = nil)
+      @results = []
+      @start_time = Time.now.sys
+      @filename = File.join(@path, File.build_timestamped_filename(['testrunner', 'results']))
+      @data_package_filename = @filename[0..-5] + '.zip'
+      Cosmos.set_working_dir do
+        @file = File.new(@filename, 'w')
+      end
+      @settings = settings
+      @canceled = false
+
+      if test_case
+        # Executing a single test case
+        @context = "#{test_suite_class.name}:#{test_class.name}:#{test_case} #{test_type}"
+      elsif test_class
+        # Executing an entire test
+        @context = "#{test_suite_class.name}:#{test_class.name} #{test_type}"
+      else
+        # Executing a test suite
+        @context = "#{test_suite_class.name} #{test_type}"
+      end
+
+      cycle_logs() if @auto_cycle_logs
+
+      header()
+    end
+
+    # process_result can handle an array of CosmosTestResult objects
+    # or a single CosmosTestResult object
+    def process_result(results)
+      cosmos_lib = Regexp.new(File.join(Cosmos::PATH, 'lib'))
+      # If we were passed an array we concat it to the results global
+      if results.is_a? Array
+        @results.concat(results)
+      # A single result is appended and then turned into an array
+      else
+        @results << results
+        results = [results]
+      end
+      # Process all the results (may be just one)
+      results.each do |result|
+        self.puts("#{result.test}:#{result.test_case}:#{result.result}")
+        if result.message
+          result.message.each_line do |line|
+            if line =~ /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/
+              line.chomp!
+              line = line.inspect.remove_quotes
+            end
+            @file.puts '  ' + line
+          end
+          @file.flush
+        end
+        if result.exceptions
+          @file.puts "  Exceptions:"
+          result.exceptions.each_with_index do |error, index|
+            error.formatted(true).each_line do |line|
+              break if line =~ /test_runner\/test.rb/
+              next  if line =~ cosmos_lib
+              if line =~ /[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F-\xFF]/
+                line.chomp!
+                line = line.inspect.remove_quotes
+                line << "\n"
+              end
+              @file.print '    ' + line
+            end
+            @file.puts '' if index != (result.exceptions.length - 1)
+          end
+          @file.flush
+        end
+      end
+    end
+
+    def complete
+      @stop_time = Time.now.sys
+      cycle_logs() if @auto_cycle_logs
+      footer()
+    ensure
+      @file.close if @file and not @file.closed?
+      Cosmos.set_working_dir do
+        File.chmod(0444, @filename)
+      end
+    end
+
+    def header
+      @file.puts "--- Test Report ---"
+      @file.puts ''
+      @file.puts "Files:"
+      @file.puts "Report Filename: #{@filename}"
+      @file.puts "Detailed Test Output Logged to: #{get_scriptrunner_message_log_filename()}"
+      if @metadata
+        begin
+          items = get_tlm_packet('SYSTEM', 'META')
+          @file.puts ''
+          @file.puts "Metadata:"
+          items.each do |item_name, item_value, _|
+            next if SetTlmDialog::IGNORED_ITEMS.include?(item_name)
+            @file.puts "#{item_name} = #{item_value}"
+          end
+        rescue DRb::DRbConnError
+          # Oh well
+        end
+      end
+      if @settings
+        @file.puts ''
+        @file.puts "Settings:"
+        @settings.each { |setting_name, setting_value| @file.puts "#{setting_name} = #{setting_value}" }
+      end
+      @file.puts ''
+      @file.puts "Results:"
+      self.puts "Executing #{@context}"
+    end
+
+    def create_data_package(progress_dialog = nil)
+      if @data_package
+        progress_dialog.cancel_callback = method(:cancel_callback) if progress_dialog
+        progress_dialog.enable_cancel_button if progress_dialog
+
+        begin
+          Cosmos.set_working_dir do
+            file_list = data_package_files()
+            Zip::File.open(@data_package_filename, Zip::File::CREATE) do|zf|
+              count = 0
+              file_list.each do |file|
+                break if @canceled
+                count += 1
+                if File.exist?(file) and File.size(file) > 0
+                  zf.add(File.basename(file), file)
+                  progress_dialog.set_overall_progress(count / (file_list.length).to_f) if progress_dialog
+                end
+              end
+            end
+            File.chmod(0444, @data_package_filename)
+          end
+          progress_dialog.close_done if progress_dialog
+        rescue => error
+          progress_dialog.append_text("Error creating data package:\n#{error.formatted}\n") if progress_dialog
+        ensure
+          progress_dialog.set_overall_progress(1.0) if progress_dialog and !@canceled
+          progress_dialog.complete if progress_dialog
+        end
+      end
+    end
+
+    def data_package_files
+      # Grab data files that were created during test
+      file_list = []
+      Cosmos.set_working_dir do
+        if File.exist?(@path)
+          dir = Dir.new(@path)
+          dir.each do |file|
+            path = File.join(@path, file)
+            unless FileTest.directory?(path)
+              file_time = File.ctime(path)
+              if file_time >= (@start_time - TIME_TOLERANCE) and file_time <= (@stop_time + TIME_TOLERANCE)
+                file_list << path
+              end
+            end
+          end
+        end
+      end
+      file_list
+    end
+
+    # @param progress_dialog [ProgressDialog] The dialog that was canceled
+    def cancel_callback(progress_dialog = nil)
+      @canceled = true
+      return true, false
+    end
+
+    def footer
+      self.puts "Completed #{@context}"
+
+      @file.puts ''
+      @file.puts "--- Test Summary ---"
+      @file.puts ''
+
+      pass_count = 0
+      skip_count = 0
+      fail_count = 0
+      stopped    = false
+      @results.each do |result|
+        if result.result == :PASS
+          pass_count += 1
+        elsif result.result == :SKIP
+          skip_count += 1
+        elsif result.result == :FAIL
+          fail_count += 1
+        end
+
+        if result.stopped
+          stopped = true
+        end
+      end
+      run_time = Time.format_seconds(@stop_time - @start_time)
+      run_time << " (#{@stop_time - @start_time} seconds)" if @stop_time-@start_time > 60
+      @file.puts("Run Time : #{run_time}")
+      @file.puts("Total Tests : #{@results.length}")
+      @file.puts("Pass : #{pass_count}")
+      @file.puts("Skip : #{skip_count}")
+      @file.puts("Fail : #{fail_count}")
+      @file.puts('')
+      if stopped
+        @file.puts '*** Test was stopped prematurely ***'
+        @file.puts ''
+      end
+      @file.flush
+    end
+
+    def write(string)
+      @file.write(Time.now.sys.formatted + ': ' + string)
+      @file.flush
+    end
+
+    def puts(string)
+      @file.puts(Time.now.sys.formatted + ': ' + string)
+      @file.flush
+    end
+
+    def collect_metadata(parent = nil)
+      success = true
+      if @metadata
+        Qt.execute_in_main_thread(true) do
+          begin
+            success = SetTlmDialog.execute(parent, 'Enter Test Metadata', 'Start Test', 'Cancel Test', 'SYSTEM', 'META')
+          rescue DRb::DRbConnError
+            success = false
+            Qt::MessageBox.critical(parent, 'Error', 'Error Connecting to Command and Telemetry Server')
+          rescue Exception => err
+            Cosmos.handle_fatal_exception(err)
+          end
+        end
+      end
+      success
+    end
+
+    def cycle_logs
+      begin
+        start_new_server_message_log()
+        start_logging()
+      rescue DRb::DRbConnError
+        # Oh well - Probably running a test that does not use realtime data
+      end
+    end
+
+  end
+
+end # module Cosmos