openc3 6.9.2 → 6.10.0

data/lib/openc3/microservices/interface_decom_common.rb

@@ -76,5 +76,37 @@ module OpenC3
       end
       Topic.write_topic(ack_topic, msg_hash)
     end
+
+    def handle_get_tlm_buffer(get_tlm_buffer_json, msg_id)
+      get_tlm_buffer_hash = JSON.parse(get_tlm_buffer_json, allow_nan: true, create_additions: true)
+      target_name = get_tlm_buffer_hash['target_name']
+      packet_name = get_tlm_buffer_hash['packet_name']
+      ack_topic = "{#{@scope}__ACKCMD}TARGET__#{target_name}"
+      begin
+        packet = System.telemetry.packet(target_name, packet_name)
+        msg_hash = {
+          id: msg_id,
+          result: 'SUCCESS',
+          time: packet.packet_time.to_nsec_from_epoch,
+          received_time: packet.received_time.to_nsec_from_epoch,
+          target_name: packet.target_name,
+          packet_name: packet.packet_name,
+          received_count: packet.received_count,
+          stored: packet.stored.to_s,
+          buffer: packet.buffer(false)
+        }
+        msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
+
+      # If there is an error due to parameter out of range, etc, we rescue it so we can
+      # write the ACKCMD}TARGET topic and allow the source to return
+      rescue => error
+        msg_hash = {
+          id: msg_id,
+          result: 'ERROR',
+          message: error.message
+        }
+      end
+      Topic.write_topic(ack_topic, msg_hash)
+    end
   end
 end

data/lib/openc3/microservices/interface_microservice.rb

@@ -554,23 +554,7 @@ module OpenC3
         target = System.targets[target_name]
         target.interface = @interface
       end
-      @interface.tlm_target_names.each do |target_name|
-        # Initialize the target's packet counters based on the Topic stream
-        # Prevents packet count resetting to 0 when interface restarts
-        begin
-          System.telemetry.packets(target_name).each do |packet_name, packet|
-            topic = "#{@scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-            msg_id, msg_hash = Topic.get_newest_message(topic)
-            if msg_id
-              packet.received_count = msg_hash['received_count'].to_i
-            else
-              packet.received_count = 0
-            end
-          end
-        rescue
-          # Handle targets without telemetry
-        end
-      end
+      TargetModel.init_tlm_packet_counts(@interface.tlm_target_names, scope: @scope)
       if @interface.connect_on_startup
         @interface.state = 'ATTEMPTING'
       else
@@ -583,9 +567,6 @@ module OpenC3
       end
 
       @queued = false
-      @sync_packet_count_data = {}
-      @sync_packet_count_time = nil
-      @sync_packet_count_delay_seconds = 1.0 # Sync packet counts every second
       @interface.options.each do |option_name, option_values|
         if option_name.upcase == 'OPTIMIZE_THROUGHPUT'
           @queued = true
@@ -594,7 +575,7 @@ module OpenC3
           StoreQueued.instance.set_update_interval(update_interval)
         end
         if option_name.upcase == 'SYNC_PACKET_COUNT_DELAY_SECONDS'
-          @sync_packet_count_delay_seconds = option_values[0].to_f
+          TargetModel.sync_packet_count_delay_seconds = option_values[0].to_f
         end
       end
 
@@ -777,7 +758,7 @@ module OpenC3
 
       # Write to stream
       if @interface.tlm_target_enabled[packet.target_name]
-        sync_tlm_packet_counts(packet)
+        TargetModel.sync_tlm_packet_counts(packet, @interface.tlm_target_names, scope: @scope)
         TelemetryTopic.write_packet(packet, queued: @queued, scope: @scope)
       end
     end
@@ -912,59 +893,6 @@ module OpenC3
     def graceful_kill
       # Just to avoid warning
     end
-
-    def sync_tlm_packet_counts(packet)
-      if @sync_packet_count_delay_seconds <= 0 or $openc3_redis_cluster
-        # Perfect but slow method
-        packet.received_count = TargetModel.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
-        packet.received_count += 1
-
-        # 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|
-                TargetModel.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
-            @interface.tlm_target_names.each do |target_name|
-              TargetModel.get_all_telemetry_counts(target_name, scope: @scope)
-            end
-            TargetModel.get_all_telemetry_counts('UNKNOWN', scope: @scope)
-          end
-          @interface.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
   end
 end
 

data/lib/openc3/microservices/queue_microservice.rb

@@ -67,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}"

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.
@@ -87,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
@@ -209,7 +215,7 @@ module OpenC3
         # 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)

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

@@ -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
@@ -351,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,
@@ -402,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
@@ -442,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,
@@ -790,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
@@ -1365,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/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)