openc3 7.1.1 → 7.2.1

data/lib/openc3/models/db_sharded_model.rb

@@ -79,7 +79,7 @@ module OpenC3
     end
 
     # DB_Shard-aware create: writes to the store instance for the given db_shard.
-    def _db_sharded_create(db_shard, update: false, force: false, queued: false, isoformat: false, expire_seconds: nil)
+    def _db_sharded_create(db_shard, update: false, force: false, queued: false, expire_seconds: nil)
       db_shard_store = self.class.store.instance(db_shard: db_shard)
       unless force
         existing = db_shard_store.hget(@primary_key, @name)
@@ -89,7 +89,7 @@ module OpenC3
           raise RuntimeError.new("#{@primary_key}:#{@name} doesn't exist at update") if update
         end
       end
-      @updated_at = isoformat ? Time.now.utc.iso8601 : Time.now.utc.to_nsec_from_epoch
+      @updated_at = Time.now.utc.to_nsec_from_epoch
 
       if queued
         store = self.class.store_queued.instance(db_shard: db_shard)

data/lib/openc3/models/interface_model.rb

@@ -444,9 +444,11 @@ module OpenC3
       microservice
     end
 
-    # Looks up the deployed MicroserviceModel and destroy the microservice model
-    # should should trigger the operator to kill the microservice that in turn
-    # will destroy the InterfaceStatusModel when a stop is called.
+    # Destroys the deployed MicroserviceModel which triggers the operator to kill
+    # the microservice. Also directly destroys the Interface/RouterStatusModel in
+    # an ensure block. The microservice stop() no longer recreates the status
+    # model once cancel_thread is set, so undeploy must clean it up itself to
+    # avoid leaving an orphaned status model behind.
     def undeploy
       type = self.class._get_type
       name = "#{@scope}__#{type}__#{@name}"
@@ -455,15 +457,19 @@ module OpenC3
         model.destroy
         ConfigTopic.write({ kind: 'deleted', type: type.downcase, name: @name, plugin: @plugin }, scope: @scope)
       end
-
-      if type == 'INTERFACE'
-        status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
-      else
-        status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
-      end
-      status_model.destroy if status_model
     rescue Exception => error
       Logger.error("Error undeploying interface/router model #{@name} in scope #{@scope} due to #{error}")
+    ensure
+      begin
+        if type == 'INTERFACE'
+          status_model = InterfaceStatusModel.get_model(name: @name, scope: @scope)
+        else
+          status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
+        end
+        status_model.destroy if status_model
+      rescue Exception => error
+        Logger.error("Error destroying #{type&.downcase || 'unknown'} status model #{@name} in scope #{@scope} due to #{error}")
+      end
     end
 
     def unmap_target(target_name, cmd_only: false, tlm_only: false)

data/lib/openc3/models/interface_status_model.rb

@@ -118,8 +118,8 @@ module OpenC3
       @rxcnt = rxcnt
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false)
-      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued, isoformat: isoformat)
+    def create(update: false, force: false, queued: false)
+      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued)
     end
 
     def destroy

data/lib/openc3/models/metric_model.rb

@@ -77,8 +77,8 @@ module OpenC3
       @db_shard = db_shard.to_i
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false, expire_seconds: nil)
-      _db_sharded_create(@db_shard, update: update, force: force, queued: queued, isoformat: isoformat, expire_seconds: expire_seconds)
+    def create(update: false, force: false, queued: false, expire_seconds: nil)
+      _db_sharded_create(@db_shard, update: update, force: force, queued: queued, expire_seconds: expire_seconds)
     end
 
     def destroy

data/lib/openc3/models/microservice_status_model.rb

@@ -76,8 +76,8 @@ module OpenC3
       @custom = custom
     end
 
-    def create(update: false, force: false, queued: false, isoformat: false)
-      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued, isoformat: isoformat)
+    def create(update: false, force: false, queued: false)
+      _db_sharded_create(self.class._db_shard_for_name(@name, scope: @scope, use_cache: true), update: update, force: force, queued: queued)
     end
 
     def destroy

data/lib/openc3/models/model.rb

@@ -134,7 +134,7 @@ module OpenC3
 
     # Update the Redis hash at primary_key and set the field "name"
     # to the JSON generated via calling as_json
-    def create(update: false, force: false, queued: false, isoformat: false)
+    def create(update: false, force: false, queued: false)
       unless force
         existing = self.class.store.hget(@primary_key, @name)
         if existing
@@ -143,11 +143,7 @@ module OpenC3
           raise "#{@primary_key}:#{@name} doesn't exist at update" if update
         end
       end
-      if isoformat
-        @updated_at = Time.now.utc.iso8601
-      else
-        @updated_at = Time.now.utc.to_nsec_from_epoch
-      end
+      @updated_at = Time.now.utc.to_nsec_from_epoch
 
       if queued
         write_store = self.class.store_queued

data/lib/openc3/models/plugin_model.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2022 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
@@ -31,9 +31,11 @@ require 'openc3/models/tool_model'
 require 'openc3/models/widget_model'
 require 'openc3/models/microservice_model'
 require 'openc3/api/api'
+require 'openc3/utilities/pypi_url'
 require 'tmpdir'
 require 'tempfile'
 require 'fileutils'
+require 'open3'
 
 module OpenC3
   class EmptyGemFileError < StandardError; end
@@ -262,32 +264,31 @@ module OpenC3
               if pypi_url
                 pypi_url += '/simple'
               end
-              pypi_url ||= 'https://pypi.org/simple'
+              pypi_url ||= PypiUrl::DEFAULT
             end
           end
+          pypi_url = PypiUrl.validate(pypi_url)
           unless validate_only
+            # Build the pip arguments as an argv array and run pipinstall without a
+            # shell. pypi_url comes from a user-writable setting, so interpolating it
+            # into a shell command line allowed OS command injection. An argv array
+            # passes each argument verbatim with no shell metacharacter interpretation.
+            pip_args = ["-i", pypi_url]
+            pip_args += ["--trusted-host", URI.parse(pypi_url).host] unless ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
             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 = "-i #{pypi_url} #{gem_path}"
-              else
-                pip_args = "-i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} #{gem_path}"
-              end
+              pip_args << gem_path
             else
               Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
-              if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
-                pip_args = "-i #{pypi_url} -r #{requirements_path}"
-              else
-                pip_args = "-i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{requirements_path}"
-              end
+              pip_args += ["-r", requirements_path]
             end
             # Capture output and check exit code so failures surface as a warning
             # rather than silently succeeding. pipinstall is non-fatal: the plugin
             # continues to install even if Python packages fail so that non-Python
             # functionality still works.
-            output = `/openc3/bin/pipinstall #{pip_args}`
+            output, status = Open3.capture2e("/openc3/bin/pipinstall", *pip_args)
             puts output
-            unless $?.success?
+            unless status.success?
               Logger.warn "Python package installation failed. Plugin Python microservices may not function correctly."
             end
           end

data/lib/openc3/models/python_package_model.rb

@@ -13,6 +13,7 @@
 
 require 'fileutils'
 require 'openc3/utilities/process_manager'
+require 'openc3/utilities/pypi_url'
 require 'openc3/api/api'
 require 'pathname'
 
@@ -83,9 +84,10 @@ module OpenC3
           if pypi_url
             pypi_url += '/simple'
           end
-          pypi_url ||= 'https://pypi.org/simple'
+          pypi_url ||= PypiUrl::DEFAULT
         end
       end
+      pypi_url = PypiUrl.validate(pypi_url)
       Logger.info "Installing python package: #{name_or_path}"
       if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
         pip_args = ["-i", pypi_url, package_file_path]

data/lib/openc3/models/reingest_job_model.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.

data/lib/openc3/models/script_status_model.rb

@@ -62,48 +62,83 @@ module OpenC3
     end
 
     def self.all(scope:, offset: 0, limit: 10, type: "running")
-      if type == "running"
-        keys = self.store.zrevrange("#{RUNNING_PRIMARY_KEY}__#{scope}__LIST", offset.to_i, offset.to_i + limit.to_i - 1)
-        return [] if keys.empty?
-        result = []
-        result = self.store.redis_pool.pipelined do
-          keys.each do |key|
-            self.store.hget("#{RUNNING_PRIMARY_KEY}__#{scope}", key)
-          end
-        end
-        result = result.map do |r|
-          if r.nil?
-            nil
-          else
-            JSON.parse(r, allow_nan: true, create_additions: true)
-          end
-        end
-        return result
-      else
-        keys = self.store.zrevrange("#{COMPLETED_PRIMARY_KEY}__#{scope}__LIST", offset.to_i, offset.to_i + limit.to_i - 1)
-        return [] if keys.empty?
-        result = []
-        result = self.store.redis_pool.pipelined do
-          keys.each do |key|
-            self.store.hget("#{COMPLETED_PRIMARY_KEY}__#{scope}", key)
-          end
+      primary_key = (type == "running") ? RUNNING_PRIMARY_KEY : COMPLETED_PRIMARY_KEY
+      keys = self.store.zrevrange("#{primary_key}__#{scope}__LIST", offset.to_i, offset.to_i + limit.to_i - 1)
+      return [] if keys.empty?
+
+      result = self.store.redis_pool.pipelined do
+        keys.each do |key|
+          self.store.hget("#{primary_key}__#{scope}", key)
         end
-        result = result.map do |r|
-          if r.nil?
-            nil
-          else
-            JSON.parse(r, allow_nan: true, create_additions: true)
-          end
+      end
+      result = result.map do |r|
+        if r.nil?
+          nil
+        else
+          JSON.parse(r, allow_nan: true, create_additions: true)
         end
-        return result
       end
+      return result
     end
 
     def self.count(scope:, type: "running")
-      if type == "running"
-        return self.store.zcount("#{RUNNING_PRIMARY_KEY}__#{scope}__LIST", 0, Float::INFINITY)
+      primary_key = (type == "running") ? RUNNING_PRIMARY_KEY : COMPLETED_PRIMARY_KEY
+      return self.store.zcount("#{primary_key}__#{scope}__LIST", 0, Float::INFINITY)
+    end
+
+    # Fields that a search term is matched against (case-insensitive substring)
+    SEARCH_FIELDS = ['name', 'filename', 'username', 'user_full_name', 'state']
+
+    # Return a single page of items along with the total count of matching items.
+    # When searching, this fetches, parses, and filters the full list only once
+    # (instead of doing that work separately for the page and the count).
+    # Returns [page_items, total]
+    def self.page(scope:, offset: 0, limit: 10, type: "running", search: nil)
+      primary_key = (type == "running") ? RUNNING_PRIMARY_KEY : COMPLETED_PRIMARY_KEY
+      if search and !search.to_s.empty?
+        items = self.filter_by_search(self.fetch_all(primary_key, scope), search)
+        return [items[offset.to_i, limit.to_i] || [], items.length]
       else
-        return self.store.zcount("#{COMPLETED_PRIMARY_KEY}__#{scope}__LIST", 0, Float::INFINITY)
+        total = self.store.zcount("#{primary_key}__#{scope}__LIST", 0, Float::INFINITY)
+        keys = self.store.zrevrange("#{primary_key}__#{scope}__LIST", offset.to_i, offset.to_i + limit.to_i - 1)
+        page_items = keys.empty? ? [] : self.fetch(primary_key, scope, keys)
+        return [page_items, total]
+      end
+    end
+
+    # Fetch and parse the hash values for the given keys, preserving their order
+    def self.fetch(primary_key, scope, keys)
+      result = self.store.redis_pool.pipelined do
+        keys.each do |key|
+          self.store.hget("#{primary_key}__#{scope}", key)
+        end
+      end
+      result.map do |r|
+        # NOTE: create_additions is intentionally omitted here. ScriptStatusModel
+        # records are written via JSON.generate of as_json (plain hashes/arrays/
+        # primitives) and never contain a "json_class" marker, so create_additions
+        # has nothing to reconstruct. Enabling it disables the parser's fast path
+        # and makes this parse ~3x slower - costly since this runs over every
+        # record when listing/searching.
+        r.nil? ? nil : JSON.parse(r, allow_nan: true)
+      end
+    end
+
+    # Fetch and parse every item for the type, in list order (most recent first)
+    def self.fetch_all(primary_key, scope)
+      keys = self.store.zrevrange("#{primary_key}__#{scope}__LIST", 0, -1)
+      return [] if keys.empty?
+
+      self.fetch(primary_key, scope, keys).compact
+    end
+
+    # Select items where any SEARCH_FIELDS value contains the search term (case-insensitive)
+    def self.filter_by_search(items, search)
+      search = search.to_s.downcase
+      items.select do |item|
+        next false if item.nil?
+
+        SEARCH_FIELDS.any? { |field| item[field].to_s.downcase.include?(search) }
       end
     end
 
@@ -175,7 +210,7 @@ module OpenC3
 
     # Update the Redis hash at primary_key and set the field "name"
     # to the JSON generated via calling as_json
-    def create(update: false, force: false, queued: false, isoformat: true)
+    def create(update: false, force: false, queued: false)
       @updated_at = Time.now.utc.to_nsec_from_epoch
 
       if queued
@@ -198,9 +233,9 @@ module OpenC3
 
         # Move to completed
         @primary_key = "#{COMPLETED_PRIMARY_KEY}__#{@scope}"
-        create(update: false, force: force, queued: queued, isoformat: true)
+        create(update: false, force: force, queued: queued)
       else
-        create(update: true, force: force, queued: queued, isoformat: true)
+        create(update: true, force: force, queued: queued)
       end
     end
 

data/lib/openc3/models/target_model.rb

@@ -63,6 +63,7 @@ module OpenC3
     attr_accessor :ignored_parameters
     attr_accessor :ignored_items
     attr_accessor :limits_groups
+    attr_accessor :stored_limits_mode
     attr_accessor :cmd_tlm_files
     attr_accessor :id
     attr_accessor :cmd_buffer_depth
@@ -384,6 +385,7 @@ module OpenC3
       ignored_parameters: [],
       ignored_items: [],
       limits_groups: [],
+      stored_limits_mode: 'PROCESS',
       cmd_tlm_files: [],
       id: nil,
       updated_at: nil,
@@ -412,6 +414,8 @@ module OpenC3
       @ignored_parameters = ignored_parameters
       @ignored_items = ignored_items
       @limits_groups = limits_groups
+      @stored_limits_mode = stored_limits_mode.to_s.upcase
+      @stored_limits_mode = 'PROCESS' unless %w(PROCESS LOG DISABLE).include?(@stored_limits_mode)
       @cmd_tlm_files = cmd_tlm_files
       @id = id
       @cmd_buffer_depth = cmd_buffer_depth
@@ -442,6 +446,7 @@ module OpenC3
         'ignored_parameters' => @ignored_parameters,
         'ignored_items' => @ignored_items,
         'limits_groups' => @limits_groups,
+        'stored_limits_mode' => @stored_limits_mode,
         'cmd_tlm_files' => @cmd_tlm_files,
         'id' => @id,
         'updated_at' => @updated_at,
@@ -557,6 +562,14 @@ module OpenC3
         parser.verify_num_parameters(1, 1, "#{keyword} <Shard Number Starting from 0>")
         @db_shard = Integer(parameters[0])
 
+      when 'STORED_LIMITS_MODE'
+        parser.verify_num_parameters(1, 1, "#{keyword} <PROCESS, LOG, or DISABLE>")
+        mode = parameters[0].to_s.upcase
+        unless %w(PROCESS LOG DISABLE).include?(mode)
+          raise ConfigParser::Error.new(parser, "STORED_LIMITS_MODE must be one of PROCESS, LOG, or DISABLE")
+        end
+        @stored_limits_mode = mode
+
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Target: #{keyword} #{parameters.join(" ")}")
       end

data/lib/openc3/operators/operator.rb

@@ -238,6 +238,11 @@ module OpenC3
 
       OperatorProcess.setup()
       @cycle_time = (ENV['OPERATOR_CYCLE_TIME'] and ENV['OPERATOR_CYCLE_TIME'].to_f) || CYCLE_TIME # time in seconds
+      # Maximum number of new microservices to start per cycle. This spreads a
+      # large startup burst (e.g. installing a plugin with many targets) across
+      # multiple cycles so the shared services (object store, redis) aren't
+      # stampeded by every microservice connecting at once. 0 = no limit.
+      @max_start_per_cycle = (ENV['OPENC3_OPERATOR_MAX_START_PER_CYCLE'] || 5).to_i
 
       @ruby_process_name = ENV['OPENC3_RUBY']
       if RUBY_ENGINE != 'ruby'
@@ -262,10 +267,17 @@ module OpenC3
     def start_new
       @mutex.synchronize do
         if @new_processes.length > 0
-          # Start all the processes
-          Logger.info("#{self.class} starting each new process...")
-          @new_processes.each { |_name, p| p.start }
-          @new_processes = {}
+          # Start at most @max_start_per_cycle processes this cycle; any
+          # remaining stay queued in @new_processes and start on later cycles.
+          # This avoids a startup stampede when many microservices appear at
+          # once (e.g. a plugin install) overwhelming the object store / redis.
+          start_names = @new_processes.keys
+          start_names = start_names[0...@max_start_per_cycle] if @max_start_per_cycle > 0
+          Logger.info("#{self.class} starting #{start_names.length} of #{@new_processes.length} new process(es)...")
+          start_names.each do |name|
+            @new_processes[name].start
+            @new_processes.delete(name)
+          end
         end
       end
     end
@@ -273,12 +285,22 @@ module OpenC3
     def respawn_changed
       @mutex.synchronize do
         if @changed_processes.length > 0
-          Logger.info("Cycling #{@changed_processes.length} changed microservices...")
-          shutdown_processes(@changed_processes)
+          # Cycle at most @max_start_per_cycle changed microservices this cycle;
+          # any remaining stay queued in @changed_processes and are cycled on
+          # later cycles. This avoids a restart stampede when many microservices
+          # change at once (e.g. a configmap change) overwhelming shared
+          # services. Processes not yet cycled keep running until their turn.
+          cycle_names = @changed_processes.keys
+          cycle_names = cycle_names[0...@max_start_per_cycle] if @max_start_per_cycle > 0
+          cycle = @changed_processes.slice(*cycle_names)
+          Logger.info("Cycling #{cycle.length} of #{@changed_processes.length} changed microservices...")
+          shutdown_processes(cycle)
           break if @shutdown
 
-          @changed_processes.each { |_name, p| p.start }
-          @changed_processes = {}
+          cycle_names.each do |name|
+            @changed_processes[name].start
+            @changed_processes.delete(name)
+          end
         end
       end
     end
@@ -295,8 +317,11 @@ module OpenC3
 
     def respawn_dead
       @mutex.synchronize do
-        @processes.each do |_name, p|
+        @processes.each do |name, p|
           break if @shutdown
+          # Skip processes still queued by the per-cycle start limit; they
+          # haven't been started yet so they aren't "dead" to be respawned.
+          next if @new_processes[name]
           p.output_increment
           unless p.alive?
             # Respawn process
@@ -356,11 +381,21 @@ module OpenC3
       # Monitor processes and respawn if died
       Logger.info("#{self.class} Monitoring processes every #{@cycle_time} sec...")
       loop do
-        update()
-        remove_old()
-        respawn_changed()
-        start_new()
-        respawn_dead()
+        # A single cycle must never be able to take down the operator process.
+        # update() in particular hits Redis every cycle and a transient network
+        # error (the kind that also makes targets reconnect) would otherwise
+        # unwind run() and exit the process, which in the container looks like a
+        # full operator restart. Catch, log, and keep cycling so the next cycle
+        # can recover once Redis is reachable again.
+        begin
+          update()
+          remove_old()
+          respawn_changed()
+          start_new()
+          respawn_dead()
+        rescue => e
+          Logger.error("#{self.class} cycle error, continuing: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
+        end
         break if @shutdown
 
         sleep(@cycle_time)

data/lib/openc3/packets/commands.rb

@@ -325,10 +325,10 @@ module OpenC3
               unless item.states.values.include?(value)
                 if command.raw
                   # Raw commands report missing value maps
-                  raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.values.join(', ')}"
+                  raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.values.join(', ')}"
                 else
                   # Normal commands report missing state maps
-                  raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.keys.join(', ')}"
+                  raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.keys.join(', ')}"
                 end
               end
             end
@@ -340,7 +340,7 @@ module OpenC3
             # Perform Range Check on command parameter
             if not range.include?(range_check_value)
               range_check_value = "'#{range_check_value}'" if String === range_check_value
-              raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{range_check_value} not in valid range of #{range.first} to #{range.last}"
+              raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{range_check_value} not in valid range of #{range.first} to #{range.last}"
             end
           end
         end

data/lib/openc3/packets/limits.rb

@@ -153,6 +153,29 @@ module OpenC3
       return [limits_set, limits.persistence_setting, limits.enabled, limits_for_set[0], limits_for_set[1], limits_for_set[2], limits_for_set[3], limits_for_set[4], limits_for_set[5]]
     end
 
+    # Set the color for a telemetry item state
+    #
+    # @param target_name [String] Target Name
+    # @param packet_name [String] Packet Name
+    # @param item_name [String] Item Name
+    # @param state_name [String] State Name (e.g. 'CONNECTED')
+    # @param color [String or Symbol] New color: GREEN, YELLOW, or RED
+    # @return [Symbol] The color that was set
+    def set_state_color(target_name, packet_name, item_name, state_name, color)
+      packet = _get_packet(target_name, packet_name)
+      item = packet.get_item(item_name)
+      raise "Item #{target_name} #{packet_name} #{item_name} does not have any states" unless item.states
+      state_name = state_name.to_s.upcase
+      raise "State #{state_name} does not exist for #{target_name} #{packet_name} #{item_name}" unless item.states.key?(state_name)
+      color = color.to_s.upcase.intern
+      raise "Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}." unless PacketItem::STATE_COLORS.include?(color)
+      item.state_colors ||= {}
+      item.state_colors[state_name] = color
+      item.limits.enabled = true
+      packet.update_limits_items_cache(item)
+      return color
+    end
+
     protected
 
     def _get_packet(target_name, packet_name)

data/lib/openc3/packets/packet.rb

@@ -1285,7 +1285,7 @@ module OpenC3
       config
     end
 
-    def decom
+    def decom(include_limits_states: true)
       # Read all the RAW at once because this could be optimized by the accessor
       json_hash = read_items(@sorted_items)
 
@@ -1301,7 +1301,9 @@ module OpenC3
           if item.format_string or item.units
             json_hash["#{item.name}__F"] = read_item(item, :FORMATTED, @buffer, given_raw)
           end
-          limits_state = item.limits.state
+          if include_limits_states
+            limits_state = item.limits.state
+          end
           if limits_state
             json_hash["#{item.name}__L"] = limits_state
           end
@@ -1551,4 +1553,4 @@ module OpenC3
       item
     end
   end
-end
+end

data/lib/openc3/packets/packet_config.rb

@@ -161,7 +161,11 @@ module OpenC3
       process_target_name = process_target_name.upcase
       parser = ConfigParser.new("https://docs.openc3.com/docs")
       parser.instance_variable_set(:@target_name, process_target_name)
-      parser.parse_file(filename) do |keyword, params|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy), before files are written to the targets bucket. The
+      # targets_modified overlay (e.g. dynamically created packets) is never ERB
+      # rendered, so it is treated as data here rather than executed as code.
+      parser.parse_file(filename, false, true, false) do |keyword, params|
         if @building_generic_conversion
           case keyword
           # Complete a generic conversion
@@ -437,12 +441,25 @@ module OpenC3
       if packet.id_items.length > 0
         key = []
         id_signature = ""
-        # Accessor class is part of the signature so packets in the same target
-        # with different accessors trigger unique_id_mode (different accessors
-        # decode the buffer differently, so the hash-lookup path is unsafe).
+        # Accessor class AND args are part of the signature so packets in the
+        # same target with different accessors -- or the same accessor class
+        # configured with different args -- trigger unique_id_mode. Different
+        # accessors (or same accessor, different args) decode the buffer
+        # differently, so the shared hash-lookup path is unsafe.
         packet.id_items.each do |item|
           key << item.id_value
-          id_signature << "__#{item.key}__#{item.bit_offset}__#{item.bit_size}__#{item.data_type}__#{packet.accessor.class.to_s}"
+          id_signature << "__#{item.key}__#{item.bit_offset}__#{item.bit_size}__#{item.data_type}__#{packet.accessor.class.to_s}__#{packet.accessor.args.inspect}"
+          # STRUCTURE-derived id_items are decoded by the parent's structure
+          # accessor (see Accessor#read_item), so include that accessor's class
+          # and args in the signature too.
+          if item.parent_item
+            parent = packet.get_item(item.parent_item)
+            structure = parent.structure
+            if structure
+              structure_accessor = structure.accessor
+              id_signature << "__#{structure_accessor.class.to_s}__#{structure_accessor.args.inspect}"
+            end
+          end
         end
         target_id_value_hash[key] = packet
         target_id_signature = id_signature_hash[packet.target_name]

data/lib/openc3/packets/structure.rb

@@ -604,19 +604,23 @@ module OpenC3
       if item.variable_bit_size
         # Bit size is determined by length field
         length_value = self.read(item.variable_bit_size['length_item_name'], :CONVERTED)
-        if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
-          case length_value
-          when 0
-            return 6
-          when 1
-            return 14
-          when 2
-            return 30
+        if length_value
+          if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
+            case length_value
+            when 0
+              return 6
+            when 1
+              return 14
+            when 2
+              return 30
+            else
+              return 62
+            end
           else
-            return 62
+            return (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
           end
         else
-          return (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
+          raise "Length value #{item.variable_bit_size['length_item_name']} for item #{item.name} is nil"
         end
       elsif item.original_bit_size <= 0
         # Bit size is full packet length - bits before item + negative bits saved at end