cosmos 4.2.4 → 4.5.0

data/lib/cosmos/packets/packet_config.rb

@@ -60,6 +60,16 @@ module Cosmos
     #   packet is not.
     attr_reader :latest_data
 
+    # @return [Hash<String>=>Hash<Array>=>Packet] Hash keyed by target name
+    # that returns a hash keyed by an array of id values.  The id values resolve to the packet
+    # defined by that identification.  Command version
+    attr_reader :cmd_id_value_hash
+
+    # @return [Hash<String>=>Hash<Array>=>Packet] Hash keyed by target name
+    # that returns a hash keyed by an array of id values.  The id values resolve to the packet
+    # defined by that identification.  Telemetry version
+    attr_reader :tlm_id_value_hash
+
     COMMAND = "Command"
     TELEMETRY = "Telemetry"
 
@@ -73,6 +83,8 @@ module Cosmos
       # Returns an array of packets with that target and item.
       @latest_data = {}
       @warnings = []
+      @cmd_id_value_hash = {}
+      @tlm_id_value_hash = {}
 
       # Create unknown packets
       @commands['UNKNOWN'] = {}
@@ -91,7 +103,8 @@ module Cosmos
     # knowledge of the commands, telemetry, and limits groups.
     #
     # @param filename [String] The name of the configuration file
-    # @param process_target_name [String] The target name
+    # @param process_target_name [String] The target name. Pass nil when parsing
+    #   an xtce file to automatically determine the target name.
     def process_file(filename, process_target_name)
       # Handle .xtce files
       if File.extname(filename).to_s.downcase == ".xtce"
@@ -185,14 +198,22 @@ module Cosmos
           #######################################################################
           # All the following keywords must have a current packet defined
           #######################################################################
-          when 'SELECT_ITEM', 'SELECT_PARAMETER', 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER', 'MACRO_APPEND_START', 'MACRO_APPEND_END', 'ALLOW_SHORT', 'HAZARDOUS', 'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED'
+          when 'SELECT_ITEM', 'SELECT_PARAMETER', 'DELETE_ITEM', 'DELETE_PARAMETER', 'ITEM',\
+              'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM',\
+              'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM',\
+              'APPEND_ARRAY_PARAMETER', 'MACRO_APPEND_START', 'MACRO_APPEND_END', 'ALLOW_SHORT',\
+              'HAZARDOUS', 'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
             process_current_packet(parser, keyword, params)
 
           #######################################################################
           # All the following keywords must have a current item defined
           #######################################################################
-          when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION', 'POLY_READ_CONVERSION', 'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION', 'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED', 'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION', 'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW'
+          when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION', 'POLY_READ_CONVERSION',\
+              'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',\
+              'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED',\
+              'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',\
+              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP'
             raise parser.error("No current item for #{keyword}") unless @current_item
             process_current_item(parser, keyword, params)
 
@@ -274,8 +295,16 @@ module Cosmos
         if @current_cmd_or_tlm == COMMAND
           PacketParser.check_item_data_types(@current_packet)
           @commands[@current_packet.target_name][@current_packet.packet_name] = @current_packet
+          hash = @cmd_id_value_hash[@current_packet.target_name]
+          hash = {} unless hash
+          @cmd_id_value_hash[@current_packet.target_name] = hash
+          update_id_value_hash(hash)
         else
           @telemetry[@current_packet.target_name][@current_packet.packet_name] = @current_packet
+          hash = @tlm_id_value_hash[@current_packet.target_name]
+          hash = {} unless hash
+          @tlm_id_value_hash[@current_packet.target_name] = hash
+          update_id_value_hash(hash)
         end
         @current_packet = nil
         @current_item = nil
@@ -284,6 +313,18 @@ module Cosmos
 
     protected
 
+    def update_id_value_hash(hash)
+      if @current_packet.id_items.length > 0
+        key = []
+        @current_packet.id_items.each do |item|
+          key << item.id_value
+        end
+        hash[key] = @current_packet
+      else
+        hash['CATCHALL'.freeze] = @current_packet
+      end
+    end
+
     def reset_processing_variables
       @current_cmd_or_tlm = nil
       @current_packet = nil
@@ -294,25 +335,31 @@ module Cosmos
     def process_current_packet(parser, keyword, params)
       case keyword
 
-      # Select an item in the current telemetry packet for editing
-      when 'SELECT_PARAMETER', 'SELECT_ITEM'
+      # Select or delete an item in the current packet
+      when 'SELECT_PARAMETER', 'SELECT_ITEM', 'DELETE_PARAMETER', 'DELETE_ITEM'
         if (@current_cmd_or_tlm == COMMAND) && (keyword.split('_')[1] == 'ITEM')
-          raise parser.error("SELECT_ITEM only applies to telemetry packets")
+          raise parser.error("#{keyword} only applies to telemetry packets")
         end
         if (@current_cmd_or_tlm == TELEMETRY) && (keyword.split('_')[1] == 'PARAMETER')
-          raise parser.error("SELECT_PARAMETER only applies to command packets")
+          raise parser.error("#{keyword} only applies to command packets")
         end
         usage = "#{keyword} <#{keyword.split('_')[1]} NAME>"
         finish_item()
         parser.verify_num_parameters(1, 1, usage)
         begin
-          @current_item = @current_packet.get_item(params[0])
+          if keyword.include?("SELECT")
+            @current_item = @current_packet.get_item(params[0])
+          else # DELETE
+            @current_packet.delete_item(params[0])
+          end
         rescue # Rescue the default execption to provide a nicer error message
           raise parser.error("#{params[0]} not found in #{@current_cmd_or_tlm.downcase} packet #{@current_packet.target_name} #{@current_packet.packet_name}", usage)
         end
 
       # Start a new telemetry item in the current packet
-      when 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER'
+      when 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER',\
+          'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER',\
+          'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER'
         start_item(parser)
 
       # Start the creation of a macro-expanded list of items
@@ -472,7 +519,6 @@ module Cosmos
 
       # Define the units of the current telemetry item
       when 'UNITS'
-        raise parser.error("Items with STATE can't define UNITS") if @current_item.states
         usage = "UNITS <FULL UNITS NAME> <ABBREVIATED UNITS NAME>"
         parser.verify_num_parameters(2, 2, usage)
         @current_item.units_full = params[0]
@@ -538,6 +584,10 @@ module Cosmos
         parser.verify_num_parameters(1, 1, usage)
         @current_item.overflow = params[0].to_s.upcase.intern
 
+      when 'OVERLAP'
+        parser.verify_num_parameters(0, 0, 'OVERLAP')
+        @current_item.overlap = true
+
       end
     end
 

data/lib/cosmos/packets/parsers/format_string_parser.rb

@@ -14,7 +14,6 @@ module Cosmos
     # @param parser [ConfigParser] Configuration parser
     # @param item [Packet] The current item
     def self.parse(parser, item)
-      raise parser.error("Items with STATE can't define FORMAT_STRING") if item.states
       @parser = FormatStringParser.new(parser)
       @parser.verify_parameters()
       @parser.create_format_string(item)

data/lib/cosmos/packets/parsers/state_parser.rb

@@ -21,7 +21,6 @@ module Cosmos
     #   appended with any warnings found when parsing the limits
     def self.parse(parser, packet, cmd_or_tlm, item, warnings)
       raise parser.error("Items with LIMITS can't define STATE") if item.limits.values
-      raise parser.error("Items with FORMAT_STRING can't define STATE") if item.format_string
       raise parser.error("Items with UNITS can't define STATE") if item.units
       @parser = StateParser.new(parser)
       @parser.verify_parameters(cmd_or_tlm)

data/lib/cosmos/packets/parsers/xtce_converter.rb

@@ -295,6 +295,8 @@ module Cosmos
           xml['xtce'].IntegerDataEncoding(:sizeInBits => item.bit_size, :encoding => encoding)
           xml['xtce'].EnumerationList do
             item.states.each do |state_name, state_value|
+              # Skip the special COSMOS 'ANY' enumerated state
+              next if state_value == 'ANY'
               xml['xtce'].Enumeration(:value => state_value, :label => state_name)
             end
           end

data/lib/cosmos/packets/parsers/xtce_parser.rb

@@ -25,8 +25,8 @@ module Cosmos
     # @param warnings [Array<String>] Array of strings listing all the warnings
     #   that were created while parsing the configuration
     # @param filename [String] The name of the configuration file
-    # @param target_name [String] The target name
-    def self.process(commands, telemetry, warnings, filename, target_name)
+    # @param target_name [String] Override the target name found in the XTCE file
+    def self.process(commands, telemetry, warnings, filename, target_name = nil)
       XtceParser.new(commands, telemetry, warnings, filename, target_name)
     end
 
@@ -49,7 +49,7 @@ module Cosmos
 
     private
 
-    def initialize(commands, telemetry, warnings, filename, target_name)
+    def initialize(commands, telemetry, warnings, filename, target_name = nil)
       reset_processing_variables()
       @commands = commands
       @telemetry = telemetry
@@ -60,6 +60,7 @@ module Cosmos
 
     def parse(filename, target_name)
       doc = File.open(filename) { |f| Nokogiri::XML(f, nil, nil, Nokogiri::XML::ParseOptions::STRICT | Nokogiri::XML::ParseOptions::NOBLANKS) }
+      # Determine the @current_target_name
       xtce_process_element(doc.root)
       @current_target_name = target_name if target_name
       doc.root.children.each do |child|
@@ -650,7 +651,7 @@ module Cosmos
         if base_packet
           count = 0
           base_packet.sorted_items.each do |item|
-            unless ['RECEIVED_TIMESECONDS', 'RECEIVED_TIMEFORMATTED', 'RECEIVED_COUNT'].include?(item.name)
+            unless ['PACKET_TIMESECONDS', 'PACKET_TIMEFORMATTED', 'RECEIVED_TIMESECONDS', 'RECEIVED_TIMEFORMATTED', 'RECEIVED_COUNT'].include?(item.name)
               begin
                 @current_packet.get_item(item.name)
               rescue

data/lib/cosmos/packets/structure.rb

@@ -195,7 +195,7 @@ module Cosmos
         last_item = @sorted_items[-1]
         @sorted_items << item
         # If the current item or last item have a negative offset then we have
-        # to re-sort. We also re-sort if the current item is less than the less
+        # to re-sort. We also re-sort if the current item is less than the last
         # item because we are inserting.
         if last_item.bit_offset <= 0 or item.bit_offset <= 0 or item.bit_offset < last_item.bit_offset
           @sorted_items = @sorted_items.sort
@@ -303,6 +303,23 @@ module Cosmos
       end
     end
 
+    # @param name [String] Name of the item to delete in the items Hash
+    def delete_item(name)
+      item = @items[name.upcase]
+      raise ArgumentError, "Unknown item: #{name}" unless item
+
+      # Find the item to delete in the sorted_items array
+      item_index = nil
+      @sorted_items.each_with_index do |sorted_item, index|
+        if sorted_item.name == item.name
+          item_index = index
+          break
+        end
+      end
+      @sorted_items.delete_at(item_index)
+      @items.delete(name.upcase)
+    end
+
     # Write a value to the buffer based on the item definition
     #
     # @param item [StructureItem] Instance of StructureItem or one of its subclasses
@@ -370,12 +387,14 @@ module Cosmos
     #   parameter to check whether to perform conversions on the item.
     # @param indent [Integer] Amount to indent before printing the item name
     # @param buffer [String] The binary buffer to write the value to
+    # @param ignored [Array<String>] List of items to ignore when building the string
     # @return [String] String formatted with all the item names and values
-    def formatted(value_type = :RAW, indent = 0, buffer = @buffer)
+    def formatted(value_type = :RAW, indent = 0, buffer = @buffer, ignored = nil)
       indent_string = ' ' * indent
       string = ''
       synchronize_allow_reads(true) do
         @sorted_items.each do |item|
+          next if ignored && ignored.include?(item.name)
           if (item.data_type != :BLOCK) ||
              (item.data_type == :BLOCK and value_type != :RAW and
               item.respond_to? :read_conversion and item.read_conversion)
@@ -445,9 +464,18 @@ module Cosmos
 
     protected
 
+    MUTEX = Mutex.new
+
+    def setup_mutex
+      return if @mutex
+      MUTEX.synchronize do
+        @mutex ||= Mutex.new
+      end
+    end
+
     # Take the structure mutex to ensure the buffer does not change while you perform activities
     def synchronize
-      @mutex ||= Mutex.new
+      setup_mutex()
       @mutex.synchronize {|| yield}
     end
 
@@ -457,7 +485,7 @@ module Cosmos
     #      lower level calls to go forward without getting the mutex
     def synchronize_allow_reads(top = false)
       @mutex_allow_reads ||= false
-      @mutex ||= Mutex.new
+      setup_mutex()
       if top
         @mutex.synchronize do
           @mutex_allow_reads = Thread.current

data/lib/cosmos/packets/structure_item.rb

@@ -11,7 +11,6 @@
 require 'cosmos/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
 
 module Cosmos
-
   # Maintains knowledge of an item in a Structure. Multiple StructureItems
   # compose a Structure.
   class StructureItem
@@ -59,6 +58,9 @@ module Cosmos
     # @return [Symbol] {BinaryAccessor::OVERFLOW_TYPES}
     attr_reader :overflow
 
+    # @return [Boolean] Whether this structure item can overlap another item in the same packet
+    attr_accessor :overlap
+
     # A large buffer size in bits (1 Megabyte)
     LARGE_BUFFER_SIZE_BITS = 1024 * 1024 * 8
 
@@ -73,6 +75,7 @@ module Cosmos
     # @param endianness [Symbol] {BinaryAccessor::ENDIANNESS}
     # @param array_size [Integer, nil] Size of the array item in bits. For
     #   example, if the bit_size is 8, an array_size of 16 holds two values.
+    # @param overflow [Symbol] {BinaryAccessor::OVERFLOW_TYPES}
     def initialize(name, bit_offset, bit_size, data_type, endianness, array_size = nil, overflow = :ERROR)
       @structure_item_constructed = false
       # Assignment order matters due to verifications!
@@ -83,6 +86,7 @@ module Cosmos
       self.bit_size = bit_size
       self.array_size = array_size
       self.overflow = overflow
+      self.overlap = false
       @create_index = @@create_index
       @@create_index += 1
       @structure_item_constructed = true

data/lib/cosmos/packets/telemetry.rb

@@ -266,17 +266,33 @@ module Cosmos
       target_names = target_names() unless target_names
 
       target_names.each do |target_name|
+        target_name = target_name.to_s.upcase
+        
         target_packets = nil
         begin
           target_packets = packets(target_name)
+          #puts target_packets.length
         rescue RuntimeError
           # No telemetry for this target
           next
         end
 
-        # Iterate through the packets and see if any represent the buffer
-        target_packets.each do |packet_name, packet|
-          return packet if packet.identify?(packet_data)
+        target = System.targets[target_name]
+        if target and target.tlm_unique_id_mode
+          # Iterate through the packets and see if any represent the buffer
+          target_packets.each do |packet_name, packet|
+            return packet if packet.identify?(packet_data)
+          end
+        else
+          # Do a hash lookup to quickly identify the packet
+          if target_packets.length > 0
+            packet = target_packets.first[1]
+            key = packet.read_id_values(packet_data)
+            hash = @config.tlm_id_value_hash[target_name]
+            identified_packet = hash[key]
+            identified_packet = hash['CATCHALL'.freeze] unless identified_packet
+            return identified_packet if identified_packet
+          end
         end
       end
 
@@ -290,6 +306,8 @@ module Cosmos
         identified_packet = identified_packet.clone
         identified_packet.buffer = packet.buffer
         identified_packet.received_time = packet.received_time
+        identified_packet.stored = packet.stored
+        identified_packet.extra = packet.extra
         return identified_packet
       end
 
@@ -302,6 +320,8 @@ module Cosmos
         identified_packet = identified_packet.clone
         identified_packet.buffer = packet.buffer
         identified_packet.received_time = packet.received_time
+        identified_packet.stored = packet.stored
+        identified_packet.extra = packet.extra
         return identified_packet
       end
 
@@ -417,7 +437,13 @@ module Cosmos
           splash.progress = index / total
         end
 
-        ignored_items = System.targets[target_name].ignored_items
+        # Note: System only has declared target structures but telemetry may have more
+        system_target = System.targets[target_name]
+        if system_target
+          ignored_items = system_target.ignored_items
+        else
+          ignored_items = []
+        end
 
         packets(target_name).each do |packet_name, packet|
           # We don't audit against hidden or disabled packets

data/lib/cosmos/script/api_shared.rb

@@ -9,6 +9,13 @@
 # attribution addendums as found in the LICENSE.txt
 
 module Cosmos
+  # Error raised by the API when a check fails
+  class CheckError < RuntimeError; end
+  # Error raised when a Script should be stopped
+  class StopScript < StandardError; end
+  # Error raised when a TestCase should be skipped by TestRunner
+  class SkipTestCase < StandardError; end
+
   module ApiShared
     DEFAULT_TLM_POLLING_RATE = 0.25
 
@@ -477,7 +484,7 @@ module Cosmos
       path
     end
 
-    def check_file_cache_for_instrumented_script(path, md5)
+    def check_file_cache_for_instrumented_script(path, hash_string)
       file_text = nil
       instrumented_script = nil
       cached = true
@@ -498,8 +505,8 @@ module Cosmos
         if use_file_cache
           # Check file based instrumented cache
           flat_path = path.tr("/", "_").gsub("\\", "_").tr(":", "_").tr(" ", "_")
-          flat_path_with_md5 = flat_path + '_' + md5
-          cache_filename = File.join(cache_path, flat_path_with_md5)
+          flat_path_with_hash_string = flat_path + '_' + hash_string
+          cache_filename = File.join(cache_path, flat_path_with_hash_string)
         end
 
         begin
@@ -536,24 +543,27 @@ module Cosmos
       path = _get_procedure_path(procedure_name)
 
       if defined? ScriptRunnerFrame and ScriptRunnerFrame.instance
-        md5 = nil
+        hashing_sum = nil
         begin
-          md5 = Cosmos.md5_files([path]).hexdigest
+          hashing_result = Cosmos.hash_files([path], nil, System.hashing_algorithm)
+          hash_string = hashing_result.hexdigest
+          # Only use at most, 32 characters of the hex
+          hash_string = hash_string[-32..-1] if hash_string.length >= 32
         rescue Exception => error
-          raise "Error calculating md5 on procedure file : #{path}"
+          raise "Error calculating hash string on procedure file : #{path}"
         end
 
         # Check RAM based instrumented cache
         instrumented_cache = ScriptRunnerFrame.instrumented_cache[path]
         instrumented_script = nil
-        if instrumented_cache and md5 == instrumented_cache[1]
+        if instrumented_cache and hash_string == instrumented_cache[1]
           # Use cached instrumentation
           instrumented_script = instrumented_cache[0]
         else
-          file_text, instrumented_script, cached = check_file_cache_for_instrumented_script(path, md5)
+          file_text, instrumented_script, cached = check_file_cache_for_instrumented_script(path, hash_string)
           # Cache instrumentation into RAM
           ScriptRunnerFrame.file_cache[path] = file_text
-          ScriptRunnerFrame.instrumented_cache[path] = [instrumented_script, md5]
+          ScriptRunnerFrame.instrumented_cache[path] = [instrumented_script, hash_string]
         end
 
         Object.class_eval(instrumented_script, path, 1)
@@ -789,6 +799,8 @@ module Cosmos
     def cosmos_script_sleep(sleep_time = nil)
       return false if $disconnected_targets
       if defined? ScriptRunnerFrame and ScriptRunnerFrame.instance
+        ScriptRunnerFrame.instance.active_script_highlight('green')
+
         sleep_time = 30000000 unless sleep_time # Handle infinite wait
         if sleep_time > 0.0
           end_time = Time.now.sys + sleep_time
@@ -937,7 +949,7 @@ module Cosmos
     end
 
     def run_tlm_viewer(action, display_name = '')
-      tlm_viewer = JsonDRbObject.new System.connect_hosts['TLMVIEWER_API'], System.ports['TLMVIEWER_API']
+      tlm_viewer = JsonDRbObject.new System.connect_hosts['TLMVIEWER_API'], System.ports['TLMVIEWER_API'], 1.0, Cosmos::System.x_csrf_token
       begin
         yield tlm_viewer
         tlm_viewer.disconnect