openc3 6.9.1 → 6.10.0

data/lib/openc3/microservices/queue_microservice.rb

@@ -18,6 +18,7 @@
 
 require 'openc3/microservices/microservice'
 require 'openc3/topics/queue_topic'
+require 'openc3/models/queue_model'
 require 'openc3/utilities/authentication'
 require 'openc3/api/api'
 
@@ -66,7 +67,22 @@ module OpenC3
             # OPENC3_DEFAULT_QUEUE is set because commands would be re-queued to the default queue
             # NOTE: cmd() via script rescues hazardous errors and calls prompt_for_hazardous()
             # but we've overridden it to always return true and go straight to cmd_no_hazardous_check()
-            cmd(command['value'], queue: false, scope: @scope)
+
+            # Support both new format (target_name, cmd_name, cmd_params) and legacy format (command string)
+            if command['target_name'] && command['cmd_name']
+              # New format: use 3-parameter cmd() method
+              if command['cmd_params']
+                cmd_params = JSON.parse(command['cmd_params'], allow_nan: true, create_additions: true)
+              else
+                cmd_params = {}
+              end
+              cmd(command['target_name'], command['cmd_name'], cmd_params, queue: false, scope: @scope)
+            elsif command['value']
+              # Legacy format: use single string parameter for backwards compatibility
+              cmd(command['value'], queue: false, scope: @scope)
+            else
+              @logger.error "QueueProcessor: Invalid command format, missing required fields"
+            end
           end
         rescue StandardError => e
           @logger.error "QueueProcessor failed to process command from queue #{@name}\n#{e.message}"
@@ -90,15 +106,22 @@ module OpenC3
       @queue_name = @name.split('__')[2]
 
       initial_state = 'HOLD'
-      (@config['options'] || []).each do |option|
-        case option[0].upcase
-        when 'QUEUE_STATE'
-          initial_state = option[1]
-        else
-          @logger.error("Unknown option passed to microservice #{@name}: #{option}")
+      # See if the queue already exists to get its state
+      queue = OpenC3::QueueModel.get(name: @queue_name, scope: @scope)
+      if queue
+        initial_state = queue['state']
+      else
+        (@config['options'] || []).each do |option|
+          case option[0].upcase
+          when 'QUEUE_STATE'
+            initial_state = option[1]
+          else
+            @logger.error("Unknown option passed to microservice #{@name}: #{option}")
+          end
         end
       end
 
+      @logger.info "Creating QueueMicroservice in scope #{@scope} for queue #{@queue_name} with initial state #{initial_state}"
       @processor = QueueProcessor.new(name: @queue_name, state: initial_state, logger: @logger, scope: @scope)
       @processor_thread = nil
       @read_topic = true

data/lib/openc3/migrations/20251022000000_remove_unique_id.rb

@@ -0,0 +1,23 @@
+require 'openc3/utilities/migration'
+require 'openc3/models/scope_model'
+require 'openc3/models/microservice_model'
+
+module OpenC3
+  class RemoveUniqueId < Migration
+    def self.run
+      ScopeModel.get_all_models(scope: nil).each do |scope, scope_model|
+        target_models = TargetModel.all(scope: scope)
+        target_models.each do |name, target_model|
+          target_model.delete("cmd_unique_id_mode")
+          target_model.delete("tlm_unique_id_mode")
+          model = TargetModel.from_json(target_model, scope: scope)
+          model.update()
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::RemoveUniqueId.run
+end

data/lib/openc3/models/plugin_model.rb

@@ -41,6 +41,8 @@ require 'tempfile'
 require 'fileutils'
 
 module OpenC3
+  class EmptyGemFileError < StandardError; end
+
   # Represents a OpenC3 plugin that can consist of targets, interfaces, routers
   # microservices and tools. The PluginModel installs all these pieces as well
   # as destroys them all when the plugin is removed.
@@ -56,6 +58,13 @@ module OpenC3
     attr_accessor :plugin_txt_lines
     attr_accessor :needs_dependencies
     attr_accessor :store_id
+    attr_accessor :title
+    attr_accessor :description
+    attr_accessor :licenses
+    attr_accessor :homepage
+    attr_accessor :repository
+    attr_accessor :keywords
+    attr_accessor :img_path
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -80,6 +89,10 @@ module OpenC3
       tf = nil
       begin
         if File.exist?(gem_file_path)
+          if File.zero?(gem_file_path)
+            raise EmptyGemFileError, "Gem file is empty: #{gem_file_path}"
+          end
+
           # Load gem to internal gem server
           OpenC3::GemModel.put(gem_file_path, gem_install: false, scope: scope) unless validate_only
         else
@@ -179,11 +192,31 @@ module OpenC3
             raise "Invalid screen filename: #{filename}. Screen filenames must be lowercase."
           end
         end
+
+        # Process app store metadata
+        plugin_model.title = pkg.spec.metadata['openc3_store_title'] || pkg.spec.summary.strip
+        plugin_model.description = pkg.spec.metadata['openc3_store_description'] || pkg.spec.description.strip
+        plugin_model.licenses = pkg.spec.licenses
+        plugin_model.homepage = pkg.spec.homepage
+        plugin_model.repository = pkg.spec.metadata['source_code_uri'] # this key because it's in the official gemspec examples
+        plugin_model.keywords = pkg.spec.metadata['openc3_store_keywords']&.split(/, ?/)
+        img_path = pkg.spec.metadata['openc3_store_image']
+        unless img_path
+          default_img_path = 'public/store_img.png'
+          full_default_path = File.join(gem_path, default_img_path)
+          img_path = default_img_path if File.exist? full_default_path
+        end
+        plugin_model.img_path = File.join('gems', gem_name.split(".gem")[0], img_path) if img_path # convert this filesystem path to volumes mount path
+        plugin_model.update() unless validate_only
+
         needs_dependencies = pkg.spec.runtime_dependencies.length > 0
         needs_dependencies = true if Dir.exist?(File.join(gem_path, 'lib'))
 
-        # Handle python requirements.txt
-        if File.exist?(File.join(gem_path, 'requirements.txt'))
+        # Handle python dependencies (pyproject.toml or requirements.txt)
+        pyproject_path = File.join(gem_path, 'pyproject.toml')
+        requirements_path = File.join(gem_path, 'requirements.txt')
+
+        if File.exist?(pyproject_path) || File.exist?(requirements_path)
           begin
             pypi_url = get_setting('pypi_url', scope: scope)
             if pypi_url
@@ -202,11 +235,20 @@ module OpenC3
             end
           end
           unless validate_only
-            Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
-            if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
-              pip_args = "--no-warn-script-location -i #{pypi_url} -r #{File.join(gem_path, 'requirements.txt')}"
+            if File.exist?(pyproject_path)
+              Logger.info "Installing python packages from pyproject.toml with pypi_url=#{pypi_url}"
+              if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
+                pip_args = "--no-warn-script-location -i #{pypi_url} #{gem_path}"
+              else
+                pip_args = "--no-warn-script-location -i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} #{gem_path}"
+              end
             else
-              pip_args = "--no-warn-script-location -i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{File.join(gem_path, 'requirements.txt')}"
+              Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
+              if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
+                pip_args = "--no-warn-script-location -i #{pypi_url} -r #{requirements_path}"
+              else
+                pip_args = "--no-warn-script-location -i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{requirements_path}"
+              end
             end
             puts `/openc3/bin/pipinstall #{pip_args}`
           end
@@ -302,6 +344,13 @@ module OpenC3
       plugin_txt_lines: [],
       needs_dependencies: false,
       store_id: nil,
+      title: nil,
+      description: nil,
+      keywords: nil,
+      licenses: nil,
+      homepage: nil,
+      repository: nil,
+      img_path: nil,
       updated_at: nil,
       scope:
     )
@@ -310,6 +359,13 @@ module OpenC3
       @plugin_txt_lines = plugin_txt_lines
       @needs_dependencies = ConfigParser.handle_true_false(needs_dependencies)
       @store_id = store_id
+      @title = title
+      @description = description
+      @keywords = keywords
+      @licenses = licenses
+      @homepage = homepage
+      @repository = repository
+      @img_path = img_path
     end
 
     def create(update: false, force: false, queued: false)
@@ -329,6 +385,13 @@ module OpenC3
         'plugin_txt_lines' => @plugin_txt_lines,
         'needs_dependencies' => @needs_dependencies,
         'store_id' => @store_id,
+        'title' => @title,
+        'description' => @description,
+        'keywords' => @keywords,
+        'licenses' => @licenses,
+        'homepage' => @homepage,
+        'repository' => @repository,
+        'img_path' => @img_path,
         'updated_at' => @updated_at
       }
     end

data/lib/openc3/models/queue_model.rb

@@ -20,6 +20,7 @@ require 'openc3/models/model'
 require 'openc3/models/microservice_model'
 require 'openc3/topics/queue_topic'
 require 'openc3/utilities/logger'
+require 'openc3/io/json_rpc'
 
 module OpenC3
   class QueueError < StandardError; end
@@ -44,7 +45,7 @@ module OpenC3
     end
     # END NOTE
 
-    def self.queue_command(name, command:, username:, scope:)
+    def self.queue_command(name, command: nil, target_name: nil, cmd_name: nil, cmd_params: nil, username:, scope:)
       model = get_model(name: name, scope: scope)
       raise QueueError, "Queue '#{name}' not found in scope '#{scope}'" unless model
 
@@ -55,10 +56,26 @@ module OpenC3
         else
           id = result[0][1].to_f + 1
         end
-        Store.zadd("#{scope}:#{name}", id, { username: username, value: command, timestamp: Time.now.to_nsec_from_epoch }.to_json)
+
+        # Build command data with support for both formats
+        command_data = { username: username, timestamp: Time.now.to_nsec_from_epoch }
+        if target_name && cmd_name
+          # New format: store target_name, cmd_name, and cmd_params separately
+          command_data[:target_name] = target_name
+          command_data[:cmd_name] = cmd_name
+          command_data[:cmd_params] = JSON.generate(cmd_params.as_json, allow_nan: true) if cmd_params
+        elsif command
+          # Legacy format: store command string for backwards compatibility
+          command_data[:value] = command
+        else
+          raise QueueError, "Must provide either command string or target_name/cmd_name parameters"
+        end
+
+        Store.zadd("#{scope}:#{name}", id, command_data.to_json)
         model.notify(kind: 'command')
       else
-        raise QueueError, "Queue '#{name}' is disabled. Command '#{command}' not queued."
+        error_msg = command || "#{target_name} #{cmd_name}"
+        raise QueueError, "Queue '#{name}' is disabled. Command '#{error_msg}' not queued."
       end
     end
 
@@ -105,7 +122,12 @@ module OpenC3
 
     def insert_command(id, command_data)
       if @state == 'DISABLE'
-        raise QueueError, "Queue '#{@name}' is disabled. Command '#{command_data['value']}' not queued."
+        if command_data['value']
+          command_name = command_data['value']
+        else
+          command_name = "#{command_data['target_name']} #{command_data['cmd_name']}"
+        end
+        raise QueueError, "Queue '#{@name}' is disabled. Command '#{command_name}' not queued."
       end
 
       unless id
@@ -116,6 +138,11 @@ module OpenC3
           id = result[0][1].to_f + 1
         end
       end
+
+      # Convert cmd_params values to JSON-safe format if present
+      if command_data['cmd_params']
+        command_data['cmd_params'] = JSON.generate(command_data['cmd_params'].as_json, allow_nan: true)
+      end
       Store.zadd("#{@scope}:#{@name}", id, command_data.to_json)
       notify(kind: 'command')
     end
@@ -163,7 +190,7 @@ module OpenC3
         else
           score = result[0][1]
           Store.zremrangebyscore("#{@scope}:#{@name}", score, score)
-          command_data = JSON.parse(result[0][0])
+          command_data = JSON.parse(result[0][0], allow_nan: true)
           command_data['id'] = score.to_f
           notify(kind: 'command')
           return command_data

data/lib/openc3/models/reaction_model.rb

@@ -143,7 +143,7 @@ module OpenC3
       unless triggers.is_a?(Array)
         raise ReactionInputError.new "invalid triggers, must be array of hashes: #{triggers}"
       end
-      trigger_hash = Hash.new()
+      trigger_hash = {}
       triggers.each do | trigger |
         unless trigger.is_a?(Hash)
           raise ReactionInputError.new "invalid trigger, must be hash: #{trigger}"
@@ -183,20 +183,17 @@ module OpenC3
     end
 
     def verify_triggers
-      trigger_models = []
+      if @triggers.empty?
+        raise ReactionInputError.new "reaction must contain at least one valid trigger: #{@triggers}"
+      end
+
       @triggers.each do | trigger |
         model = TriggerModel.get(name: trigger['name'], group: trigger['group'], scope: @scope)
         if model.nil?
           raise ReactionInputError.new "failed to find trigger: #{trigger}"
         end
-        trigger_models << model
-      end
-      if trigger_models.empty?
-        raise ReactionInputError.new "reaction must contain at least one valid trigger: #{@triggers}"
-      end
-      trigger_models.each do | trigger_model |
-        trigger_model.update_dependents(dependent: @name)
-        trigger_model.update()
+        model.update_dependents(dependent: @name)
+        model.update()
       end
     end
 
@@ -211,6 +208,25 @@ module OpenC3
     end
 
     def update
+      old_reaction = ReactionModel.get(name: @name, scope: @scope)
+
+      if old_reaction
+        # Find triggers that are being removed (in old but not in new)
+        old_trigger_keys = old_reaction.triggers.map { |t| "#{t['group']}:#{t['name']}" }
+        new_trigger_keys = @triggers.map { |t| "#{t['group']}:#{t['name']}" }
+        removed_trigger_keys = old_trigger_keys - new_trigger_keys
+
+        # Remove this reaction from old triggers' dependents
+        removed_trigger_keys.each do |trigger_key|
+          group, name = trigger_key.split(':', 2)
+          trigger_model = TriggerModel.get(name: name, group: group, scope: @scope)
+          if trigger_model
+            trigger_model.update_dependents(dependent: @name, remove: true)
+            trigger_model.update()
+          end
+        end
+      end
+
       verify_triggers()
       @updated_at = Time.now.to_nsec_from_epoch
       Store.hset(@primary_key, @name, JSON.generate(as_json, allow_nan: true))

data/lib/openc3/models/target_model.rb

@@ -54,6 +54,9 @@ module OpenC3
     ERB_EXTENSIONS = %w(.txt .rb .py .json .yaml .yml)
     ITEM_MAP_CACHE_TIMEOUT = 10.0
     @@item_map_cache = {}
+    @@sync_packet_count_data = {}
+    @@sync_packet_count_time = nil
+    @@sync_packet_count_delay_seconds = 1.0 # Sync packet counts every second
 
     attr_accessor :folder_name
     attr_accessor :requires
@@ -61,8 +64,6 @@ module OpenC3
     attr_accessor :ignored_items
     attr_accessor :limits_groups
     attr_accessor :cmd_tlm_files
-    attr_accessor :cmd_unique_id_mode
-    attr_accessor :tlm_unique_id_mode
     attr_accessor :id
     attr_accessor :cmd_buffer_depth
     attr_accessor :cmd_log_cycle_time
@@ -166,10 +167,14 @@ module OpenC3
     end
 
     def self.download(target_name, scope:)
+      # Validate target_name to not allow directory traversal
+      if target_name.include?('..') || target_name.include?('/') || target_name.include?('\\')
+        raise ArgumentError, "Invalid target_name: #{target_name.inspect}"
+      end
       tmp_dir = Dir.mktmpdir
       zip_filename = File.join(tmp_dir, "#{target_name}.zip")
       Zip.continue_on_exists_proc = true
-      zip = Zip::File.open(zip_filename, Zip::File::CREATE)
+      zip = Zip::File.open(zip_filename, create: true)
 
       if ENV['OPENC3_LOCAL_MODE']
         OpenC3::LocalMode.zip_target(target_name, zip, scope: scope)
@@ -347,8 +352,6 @@ module OpenC3
       ignored_items: [],
       limits_groups: [],
       cmd_tlm_files: [],
-      cmd_unique_id_mode: false,
-      tlm_unique_id_mode: false,
       id: nil,
       updated_at: nil,
       plugin: nil,
@@ -398,8 +401,6 @@ module OpenC3
       @ignored_items = ignored_items
       @limits_groups = limits_groups
       @cmd_tlm_files = cmd_tlm_files
-      @cmd_unique_id_mode = cmd_unique_id_mode
-      @tlm_unique_id_mode = tlm_unique_id_mode
       @id = id
       @cmd_buffer_depth = cmd_buffer_depth
       @cmd_log_cycle_time = cmd_log_cycle_time
@@ -438,8 +439,6 @@ module OpenC3
         'ignored_items' => @ignored_items,
         'limits_groups' => @limits_groups,
         'cmd_tlm_files' => @cmd_tlm_files,
-        'cmd_unique_id_mode' => @cmd_unique_id_mode,
-        'tlm_unique_id_mode' => @tlm_unique_id_mode,
         'id' => @id,
         'updated_at' => @updated_at,
         'plugin' => @plugin,
@@ -756,7 +755,7 @@ module OpenC3
       prefix = File.dirname(target_folder) + '/'
       output_file = File.join(temp_dir, @name + '_' + @id + '.zip')
       Zip.continue_on_exists_proc = true
-      Zip::File.open(output_file, Zip::File::CREATE) do |zipfile|
+      Zip::File.open(output_file, create: true) do |zipfile|
         target_files.each do |target_file|
           zip_file_path = target_file.delete_prefix(prefix)
           if File.directory?(target_file)
@@ -786,8 +785,6 @@ module OpenC3
       @ignored_parameters = target.ignored_parameters
       @ignored_items = target.ignored_items
       @cmd_tlm_files = target.cmd_tlm_files
-      @cmd_unique_id_mode = target.cmd_unique_id_mode
-      @tlm_unique_id_mode = target.tlm_unique_id_mode
       @limits_groups = system.limits.groups.keys
       update()
     end
@@ -807,7 +804,7 @@ module OpenC3
             Logger.error("Invalid text present in #{target_name} #{packet_name} tlm packet")
             raise e
           end
-          json_hash = Hash.new
+          json_hash = {}
           packet.sorted_items.each do |item|
             json_hash[item.name] = nil
             TargetModel.add_to_target_allitems_list(target_name, item.name, scope: @scope)
@@ -1361,6 +1358,81 @@ module OpenC3
       return counts
     end
 
+    def self.sync_packet_count_delay_seconds=(value)
+      @@sync_packet_count_delay_seconds = value
+    end
+
+    def self.init_tlm_packet_counts(tlm_target_names, scope:)
+      @@sync_packet_count_time = Time.now
+
+      # Get all the packet counts with the global counters
+      tlm_target_names.each do |target_name|
+        get_all_telemetry_counts(target_name, scope: scope).each do |packet_name, count|
+          update_packet = System.telemetry.packet(target_name, packet_name)
+          update_packet.received_count = count.to_i
+        end
+      end
+      get_all_telemetry_counts('UNKNOWN', scope: scope).each do |packet_name, count|
+        update_packet = System.telemetry.packet('UNKNOWN', packet_name)
+        update_packet.received_count = count.to_i
+      end
+    end
+
+    def self.sync_tlm_packet_counts(packet, tlm_target_names, scope:)
+      if @@sync_packet_count_delay_seconds <= 0 or $openc3_redis_cluster
+        # Perfect but slow method
+        packet.received_count = increment_telemetry_count(packet.target_name, packet.packet_name, 1, scope: scope)
+      else
+        # Eventually consistent method
+        # Only sync every period (default 1 second) to avoid hammering Redis
+        # This is a trade off between speed and accuracy
+        # The packet count is eventually consistent
+        @@sync_packet_count_data[packet.target_name] ||= {}
+        @@sync_packet_count_data[packet.target_name][packet.packet_name] ||= 0
+        @@sync_packet_count_data[packet.target_name][packet.packet_name] += 1
+
+        # Ensures counters change between syncs
+        update_packet = System.telemetry.packet(packet.target_name, packet.packet_name)
+        update_packet.received_count += 1
+        packet.received_count = update_packet.received_count
+
+        # Check if we need to sync the packet counts
+        if @@sync_packet_count_time.nil? or (Time.now - @@sync_packet_count_time) > @@sync_packet_count_delay_seconds
+          @@sync_packet_count_time = Time.now
+
+          inc_count = 0
+          # Use pipeline to make this one transaction
+          result = Store.redis_pool.pipelined do
+            # Increment global counters for packets received
+            @@sync_packet_count_data.each do |target_name, packet_data|
+              packet_data.each do |packet_name, count|
+                increment_telemetry_count(target_name, packet_name, count, scope: scope)
+                inc_count += 1
+              end
+            end
+            @@sync_packet_count_data = {}
+
+            # Get all the packet counts with the global counters
+            tlm_target_names.each do |target_name|
+              get_all_telemetry_counts(target_name, scope: scope)
+            end
+            get_all_telemetry_counts('UNKNOWN', scope: scope)
+          end
+          tlm_target_names.each do |target_name|
+            result[inc_count].each do |packet_name, count|
+              update_packet = System.telemetry.packet(target_name, packet_name)
+              update_packet.received_count = count.to_i
+            end
+            inc_count += 1
+          end
+          result[inc_count].each do |packet_name, count|
+            update_packet = System.telemetry.packet('UNKNOWN', packet_name)
+            update_packet.received_count = count.to_i
+          end
+        end
+      end
+    end
+
     def self.increment_command_count(target_name, packet_name, count, scope:)
       result = Store.hincrby("#{scope}__COMMANDCNTS__{#{target_name}}", packet_name, count)
       if String === result

data/lib/openc3/models/trigger_model.rb

@@ -237,7 +237,7 @@ module OpenC3
 
     # ["#{@scope}__DECOM__{#{@target}}__#{@packet}"]
     def generate_topics
-      topics = Hash.new
+      topics = {}
       if @left['type'] == ITEM_TYPE
         topics["#{@scope}__DECOM__{#{left['target']}}__#{left['packet']}"] = 1
       end

data/lib/openc3/packets/commands.rb

@@ -105,7 +105,7 @@ module OpenC3
     #
     # @param (see #identify_tlm!)
     # @return (see #identify_tlm!)
-    def identify(packet_data, target_names = nil)
+    def identify(packet_data, target_names = nil, subpackets: false)
       identified_packet = nil
 
       target_names = target_names() unless target_names
@@ -120,21 +120,39 @@ module OpenC3
           next
         end
 
-        target = System.targets[target_name]
-        if target and target.cmd_unique_id_mode
+        if (not subpackets and System.commands.cmd_unique_id_mode(target_name)) or (subpackets and System.commands.cmd_subpacket_unique_id_mode(target_name))
           # Iterate through the packets and see if any represent the buffer
           target_packets.each do |_packet_name, packet|
-            if packet.identify?(packet_data)
+            if subpackets
+              next unless packet.subpacket
+            else
+              next if packet.subpacket
+            end
+            if packet.identify?(packet_data) # Handles virtual
               identified_packet = packet
               break
             end
           end
         else
           # Do a hash lookup to quickly identify the packet
-          if target_packets.length > 0
-            packet = target_packets.first[1]
+          packet = nil
+          target_packets.each do |_packet_name, target_packet|
+            next if target_packet.virtual
+            if subpackets
+              next unless target_packet.subpacket
+            else
+              next if target_packet.subpacket
+            end
+            packet = target_packet
+            break
+          end
+          if packet
             key = packet.read_id_values(packet_data)
-            hash = @config.cmd_id_value_hash[target_name]
+            if subpackets
+              hash = @config.cmd_subpacket_id_value_hash[target_name]
+            else
+              hash = @config.cmd_id_value_hash[target_name]
+            end
             identified_packet = hash[key]
             identified_packet = hash['CATCHALL'.freeze] unless identified_packet
           end
@@ -264,6 +282,14 @@ module OpenC3
       @config.dynamic_add_packet(packet, :COMMAND, affect_ids: affect_ids)
     end
 
+    def cmd_unique_id_mode(target_name)
+      return @config.cmd_unique_id_mode[target_name.upcase]
+    end
+
+    def cmd_subpacket_unique_id_mode(target_name)
+      return @config.cmd_subpacket_unique_id_mode[target_name.upcase]
+    end
+
     protected
 
     def set_parameters(command, params, range_checking)