cosmos 4.3.0-java → 4.4.0-java

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|

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
@@ -370,12 +370,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)

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
 

data/lib/cosmos/script/api_shared.rb

@@ -477,7 +477,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 +498,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 +536,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)

data/lib/cosmos/script/scripting.rb

@@ -56,20 +56,20 @@ module Cosmos
       return value
     end
 
-    def prompt(string)
-      prompt_to_continue(string)
+    def prompt(string, **options)
+      prompt_to_continue(string, options)
     end
 
-    def message_box(string, *buttons)
-      prompt_message_box(string, buttons)
+    def message_box(string, *buttons, **options)
+      prompt_message_box(string, buttons, options)
     end
 
-    def vertical_message_box(string, *buttons)
-      prompt_vertical_message_box(string, buttons)
+    def vertical_message_box(string, *buttons, **options)
+      prompt_vertical_message_box(string, buttons, options)
     end
 
-    def combo_box(string, *options)
-      prompt_combo_box(string, options)
+    def combo_box(string, *items, **options)
+      prompt_combo_box(string, items, options)
     end
 
     def _file_dialog(message, directory, filter, select_files = true)
@@ -123,22 +123,24 @@ module Cosmos
       end
     end
 
-    def prompt_to_continue(string)
+    def prompt_to_continue(string, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string}: "
+      print "Details: #{details}\n" if details
       gets.chomp
     end
 
-    def prompt_message_box(string, buttons)
+    def prompt_message_box(string, buttons, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string} (#{buttons.join(", ")}): "
+      print "Details: #{details}\n" if details
       gets.chomp
     end
 
-    def prompt_vertical_message_box(string, options)
-      prompt_message_box(string, options)
+    def prompt_vertical_message_box(string, buttons, options)
+      prompt_message_box(string, buttons, options)
     end
 
-    def prompt_combo_box(string, options)
-      prompt_message_box(string, options)
+    def prompt_combo_box(string, items, options)
+      prompt_message_box(string, items, options)
     end
   end
 end

data/lib/cosmos/system/system.rb

@@ -29,7 +29,7 @@ module Cosmos
   # #targets variable provides access to all the targets defined by the system.
   # Its primary responsibily is to load the system configuration file and
   # create all the Target instances. It also saves and restores configurations
-  # using a MD5 checksum over the entire configuration to detect changes.
+  # using a hashing checksum over the entire configuration to detect changes.
   class System
     # @return [Hash<String,Fixnum>] Hash of all the known ports and their values
     instance_attr_reader :ports
@@ -67,12 +67,14 @@ module Cosmos
     instance_attr_reader :limits_set
     # @return [Boolean] Whether to use UTC or local times
     instance_attr_reader :use_utc
-    # @return [Array<String>] List of files that are to be included in the MD5
+    # @return [Array<String>] List of files that are to be included in the hashing
     #   calculation in addition to the cmd/tlm definition files that are
     #   automatically included
-    instance_attr_reader :additional_md5_files
+    instance_attr_reader :additional_hashing_files
     # @return [Hash<String,String>] Hash of the text/color to use for the classificaiton banner
     instance_attr_reader :classificiation_banner
+    # @return [String] Which hashing algorithm is in use
+    instance_attr_reader :hashing_algorithm
 
     # Known COSMOS ports
     KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
@@ -80,6 +82,8 @@ module Cosmos
     KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
     # Known COSMOS paths
     KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES', 'SEQUENCES', 'DART_DATA', 'DART_LOGS']
+    # Supported hashing algorithms
+    SUPPORTED_HASHING_ALGORITHMS = ['MD5', 'RMD160', 'SHA1', 'SHA256', 'SHA384', 'SHA512']
 
     @@instance = nil
     @@instance_mutex = Mutex.new
@@ -195,7 +199,7 @@ module Cosmos
       acl_list = []
       all_allowed = false
       first_procedures_path = true
-      @additional_md5_files = []
+      @additional_hashing_files = []
 
       Cosmos.set_working_dir do
         parser = ConfigParser.new("http://cosmosrb.com/docs/system")
@@ -329,16 +333,25 @@ module Cosmos
             parser.verify_num_parameters(0, 0, "#{keyword}")
             @use_utc = true
 
-          when 'ADD_MD5_FILE'
+          when 'ADD_HASH_FILE', 'ADD_MD5_FILE' # MD5 is here for backwards compatibility
             parser.verify_num_parameters(1, 1, "#{keyword} <Filename>")
             if File.file?(parameters[0])
-              @additional_md5_files << File.expand_path(parameters[0])
+              @additional_hashing_files << File.expand_path(parameters[0])
             elsif File.file?(File.join(Cosmos::USERPATH, parameters[0]))
-              @additional_md5_files << File.expand_path(File.join(Cosmos::USERPATH, parameters[0]))
+              @additional_hashing_files << File.expand_path(File.join(Cosmos::USERPATH, parameters[0]))
             else
               raise "Missing expected file: #{parameters[0]}"
             end
 
+          when 'HASHING_ALGORITHM'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Hashing Algorithm>")
+            if SUPPORTED_HASHING_ALGORITHMS.include? parameters[0]
+              @hashing_algorithm = parameters[0]
+            else
+              Logger.error "Unrecognized hashing algorithm: #{parameters[0]}, using default algorithm MD5"
+              @hashing_algorithm = 'MD5'
+            end
+
           when 'CLASSIFICATION'
             parser.verify_num_parameters(2, 4, "#{keyword} <Display_Text> <Color Name|Red> <Green> <Blue>")
             # Determine if the COSMOS color already exists, otherwise create a new one
@@ -413,13 +426,8 @@ module Cosmos
               end
             end
           end
-
           auto_detect_gem_based_targets()
 
-          # Make sure SYSTEM target is always present and added last
-          target = Target.new('SYSTEM')
-          @targets[target.name] = target
-
         when 'DECLARE_TARGET'
           usage = "#{keyword} <TARGET NAME> <SUBSTITUTE TARGET NAME (Optional)> <TARGET FILENAME (Optional - defaults to target.txt)>"
           parser.verify_num_parameters(1, 3, usage)
@@ -452,13 +460,19 @@ module Cosmos
 
         end # case keyword
       end # parser.parse_file
+
+      # Make sure SYSTEM target is always present and added last
+      unless @targets.key?('SYSTEM')
+        target = Target.new('SYSTEM')
+        @targets[target.name] = target
+      end
     end
 
     # Load the specified configuration by iterating through the SAVED_CONFIG
-    # directory looking for a matching MD5 sum. Updates the internal state so
+    # directory looking for a matching hashing sum. Updates the internal state so
     # subsequent commands and telemetry methods return the new configuration.
     #
-    # @param name [String] MD5 string which identifies the
+    # @param name [String] hash string which identifies the
     #   configuration. Pass nil to load the default configuration.
     # @return [String, Exception/nil] The actual configuration loaded
     def load_configuration(name = nil)
@@ -531,8 +545,9 @@ module Cosmos
       @staleness_seconds = 30
       @limits_set = :DEFAULT
       @use_utc = false
-      @additional_md5_files = []
+      @additional_hashing_files = []
       @meta_init_filename = nil
+      @hashing_algorithm = 'MD5'
 
       @ports = {}
       @ports['CTS_API'] = 7777
@@ -750,11 +765,12 @@ module Cosmos
     end
 
     def load_packets(configuration_name = nil)
-      # Determine MD5 over all targets cmd_tlm files
+      # Determine hashing over all targets cmd_tlm files
       cmd_tlm_files = []
       additional_data = ''
       @targets.each do |target_name, target|
         cmd_tlm_files << target.filename if File.exist?(target.filename)
+        cmd_tlm_files.concat(target.requires)
         cmd_tlm_files.concat(target.cmd_tlm_files)
         if target.substitute
           additional_data << target.original_name
@@ -764,11 +780,14 @@ module Cosmos
         end
       end
 
-      md5 = Cosmos.md5_files(cmd_tlm_files + @additional_md5_files, additional_data)
-      md5_string = md5.hexdigest
+      hashing_result = Cosmos.hash_files(cmd_tlm_files + @additional_hashing_files, additional_data, @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
+
 
       # Build filename for marshal file
-      marshal_filename = File.join(@paths['TMP'], 'marshal_' << md5_string << '.bin')
+      marshal_filename = File.join(@paths['TMP'], 'marshal_' << hash_string << '.bin')
 
       # Attempt to load marshal file
       config = Cosmos.marshal_load(marshal_filename)
@@ -801,7 +820,7 @@ module Cosmos
         if configuration_name
           @config.name = configuration_name
         else
-          @config.name = md5_string
+          @config.name = hash_string
         end
 
         Cosmos.marshal_dump(marshal_filename, @config)

data/lib/cosmos/system/target.rb

@@ -9,9 +9,9 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/config/config_parser'
+require 'pathname'
 
 module Cosmos
-
   # Target encapsulates the information about a COSMOS target. Targets are
   # accessed through interfaces and have command and telemetry definition files
   # which define their access.
@@ -66,6 +66,12 @@ module Cosmos
     # @return [Integer] The number of telemetry packets received from this target
     attr_accessor :tlm_cnt
 
+    # @return [Boolean] Indicates if all command packets identify using different fields
+    attr_accessor :cmd_unique_id_mode
+
+    # @return [Boolean] Indicates if telemetry packets identify using different fields
+    attr_accessor :tlm_unique_id_mode
+
     # Creates a new target by processing the target.txt file in the directory
     # given by the path joined with the target_name. Records all the command
     # and telemetry definition files found in the targets cmd_tlm directory.
@@ -90,6 +96,8 @@ module Cosmos
       @routers = []
       @cmd_cnt = 0
       @tlm_cnt = 0
+      @cmd_unique_id_mode = false
+      @tlm_unique_id_mode = false
 
       # Determine the target name using substitution if given
       @original_name = target_name.clone.upcase.freeze
@@ -123,16 +131,18 @@ module Cosmos
         when 'REQUIRE'
           usage = "#{keyword} <FILENAME>"
           parser.verify_num_parameters(1, 1, usage)
+          filename = File.join(@dir, 'lib', parameters[0])
           begin
-            # Require absolute path to file in target lib folder.  Prevents name
+            # Require absolute path to file in target lib folder. Prevents name
             # conflicts at the require step
             Cosmos.disable_warnings do
-              Cosmos.require_file(File.join(@dir, 'lib', parameters[0]), false)
+              Cosmos.require_file(filename, false)
             end
           rescue LoadError
             begin
               # If we couldn't load at the target/lib level check everywhere
               Cosmos.disable_warnings do
+                filename = parameters[0]
                 Cosmos.require_file(parameters[0])
               end
             rescue Exception => err
@@ -141,7 +151,19 @@ module Cosmos
           rescue Exception => err
             raise parser.error(err.message)
           end
-          @requires << parameters[0]
+          
+          # This code resolves any relative paths to absolute before putting into the @requires array
+          unless Pathname.new(filename).absolute?
+            $:.each do |search_path|
+              test_filename = File.join(search_path, filename).gsub("\\", "/")
+              if File.exist?(test_filename)
+                filename = test_filename
+                break
+              end
+            end
+          end
+          
+          @requires << filename
 
         when 'IGNORE_PARAMETER', 'IGNORE_ITEM'
           usage = "#{keyword} <#{keyword.split('_')[1]} NAME>"
@@ -161,6 +183,16 @@ module Cosmos
           parser.verify_num_parameters(0, 0, usage)
           @auto_screen_substitute = true
 
+        when 'CMD_UNIQUE_ID_MODE'
+          usage = "#{keyword}"
+          parser.verify_num_parameters(0, 0, usage)
+          @cmd_unique_id_mode = true
+
+        when 'TLM_UNIQUE_ID_MODE'
+          usage = "#{keyword}"
+          parser.verify_num_parameters(0, 0, usage)
+          @tlm_unique_id_mode = true
+
         else
           # blank lines will have a nil keyword and should not raise an exception
           raise parser.error("Unknown keyword '#{keyword}'") if keyword
@@ -213,7 +245,7 @@ module Cosmos
       cmd_tlm_files.sort!
     end
 
-    # Make sure all partials are included in the cmd_tlm list for the MD5 calculation
+    # Make sure all partials are included in the cmd_tlm list for the hashing sum calculation
     def add_cmd_tlm_partials(dir)
       partial_files = []
       if Dir.exist?(File.join(dir, 'cmd_tlm'))
@@ -226,7 +258,5 @@ module Cosmos
       @cmd_tlm_files.concat(partial_files)
       @cmd_tlm_files.uniq!
     end
-
-  end # class Target
-
-end # module Cosmos
+  end
+end