openc3 7.0.1 → 7.1.0

data/lib/openc3/system/system.rb

@@ -77,7 +77,8 @@ module OpenC3
       end
     end
 
-    def self.setup_targets(target_names, base_dir, scope:)
+    # target_version can also be the actual hash used in the target_archives folder
+    def self.setup_targets(target_names, base_dir, target_version: 'current', scope:)
       # Nothing to do if there are no targets
       return if target_names.nil? or target_names.length == 0
       if @@instance.nil?
@@ -85,10 +86,15 @@ module OpenC3
         FileUtils.mkdir_p(targets_path)
         bucket = Bucket.getClient()
         target_names.each do |target_name|
+          # Remove any prior extraction so re-running setup_targets (e.g. after
+          # reset_instance! during reingest) starts from a clean slate. Without
+          # this, Zip::File#extract fails on files left behind by a previous run.
+          FileUtils.rm_rf("#{targets_path}/#{target_name}")
+
           # Retrieve bucket/targets/target_name/<TARGET>_current.zip
-          zip_path = "#{targets_path}/#{target_name}_current.zip"
+          zip_path = "#{targets_path}/#{target_name}_#{target_version}.zip"
           FileUtils.mkdir_p(File.dirname(zip_path))
-          bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_current.zip"
+          bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_#{target_version}.zip"
           Logger.info("Retrieving #{bucket_key} from targets bucket")
           bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: zip_path)
           Zip::File.open(zip_path) do |zip_file|
@@ -116,6 +122,17 @@ module OpenC3
       end
     end
 
+    # Clears the System singleton so the next call to setup_targets or
+    # instance rebuilds it. Intended for admin flows (e.g. reingest) that
+    # need to load a specific target_version distinct from whatever is
+    # currently loaded. Callers must hold an external lock if they need to
+    # protect other threads from observing a nil @@instance briefly.
+    def self.reset_instance!
+      @@instance_mutex.synchronize do
+        @@instance = nil
+      end
+    end
+
     # Get the singleton instance of System
     #
     # @param target_names [Array of target_names]

data/lib/openc3/topics/command_decom_topic.rb

@@ -42,11 +42,13 @@ module OpenC3
       end
       msg_hash['json_data'] = JSON.generate(json_hash.as_json, allow_nan: true)
       msg_hash['extra'] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
-      EphemeralStoreQueued.write_topic(topic, msg_hash)
+      db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
     end
 
     def self.get_cmd_item(target_name, packet_name, param_name, type: :FORMATTED, scope: $openc3_scope)
-      msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
+      msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}", db_shard: db_shard)
       if msg_id
         if param_name == 'RECEIVED_COUNT'
           msg_hash['received_count'].to_i

data/lib/openc3/topics/command_topic.rb

@@ -33,7 +33,8 @@ module OpenC3
                    received_count: packet.received_count,
                    stored: packet.stored.to_s,
                    buffer: packet.buffer(false) }
-      EphemeralStoreQueued.write_topic(topic, msg_hash)
+      db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+      EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
     end
 
     # @param command [Hash] Command hash structure read to be written to a topic
@@ -45,20 +46,22 @@ module OpenC3
       command['cmd_params'] = JSON.generate(command['cmd_params'].as_json, allow_nan: true)
       OpenC3.inject_context(command)
 
+      db_shard = Store.db_shard_for_target(command['target_name'], scope: scope)
+
       # Fire-and-forget mode: skip ACK waiting when timeout <= 0
       if timeout <= 0
-        Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100, db_shard: db_shard)
         command["cmd_params"] = cmd_params # Restore the original cmd_params Hash
         return command
       end
 
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{command['target_name']}"
-      Topic.update_topic_offsets([ack_topic])
-      cmd_id = Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100, db_shard: db_shard)
       command["cmd_params"] = cmd_params # Restore the original cmd_params Hash
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == cmd_id
             if msg_hash["result"] == "SUCCESS"
               return command

data/lib/openc3/topics/decom_interface_topic.rb

@@ -26,13 +26,14 @@ module OpenC3
       # DecomMicroservice is listening to the DECOMINTERFACE topic and is responsible
       # for actually building the command. This was deliberate to allow this to work
       # with or without an interface.
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
       decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'build_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+          { 'build_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == decom_id
             if msg_hash["result"] == "SUCCESS"
               return msg_hash
@@ -45,19 +46,22 @@ module OpenC3
       raise "Timeout of #{timeout}s waiting for cmd ack. Does target '#{target_name}' exist?"
     end
 
-    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, timeout: 5, scope:)
+    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, timeout: 5, scope:)
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['packet_name'] = packet_name.to_s.upcase
       data['item_hash'] = item_hash
       data['type'] = type
+
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
+      data['stored'] = stored
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
       decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+          { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == decom_id
             if msg_hash["result"] == "SUCCESS"
               return
@@ -76,13 +80,14 @@ module OpenC3
       data['packet_name'] = packet_name.to_s.upcase
       # DecomMicroservice is listening to the DECOMINTERFACE topic and has
       # the most recent decommed packets including subpackets
+      db_shard = Store.db_shard_for_target(target_name, scope: scope)
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
       decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
-          { 'get_tlm_buffer' => JSON.generate(data, allow_nan: true) }, '*', 100)
+          { 'get_tlm_buffer' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == decom_id
             if msg_hash["result"] == "SUCCESS"
               msg_hash["stored"] = ConfigParser.handle_true_false(msg_hash["stored"])

data/lib/openc3/topics/interface_topic.rb

@@ -21,6 +21,12 @@ module OpenC3
   class InterfaceTopic < Topic
     COMMAND_ACK_TIMEOUT_S = 30
 
+    # Look up db_shard from Interface
+    def self._db_shard_for_interface(interface_name, scope:)
+      json = Store.hget("#{scope}__openc3_interfaces", interface_name)
+      json ? (JSON.parse(json, allow_nan: true, create_additions: true)['db_shard'] || 0).to_i : 0
+    end
+
     # Generate a list of topics for this interface. This includes the interface itself
     # and all the targets which are assigned to this interface.
     def self.topics(interface, scope:)
@@ -33,16 +39,39 @@ module OpenC3
       topics
     end
 
-    def self.receive_commands(interface, scope:)
+    def self.receive_commands(interface, scope:, db_shard: 0)
+      db_shard = db_shard.to_i
+      interface_cmd_topic = "{#{scope}__CMD}INTERFACE__#{interface.name}"
+      system_events_topic = "OPENC3__SYSTEM__EVENTS"
+
+      target_topics = []
+      interface.cmd_target_names.each do |target_name|
+        target_topics << "{#{scope}__CMD}TARGET__#{target_name}"
+      end
+
+      # Group target command topics by db_shard; include interface cmd and system events on db_shard
+      db_shard_groups = Topic.group_topics_by_db_shard(target_topics, target_pattern: 'CMD}TARGET__', scope: scope)
+      db_shard_groups[db_shard] ||= []
+      db_shard_groups[db_shard] << interface_cmd_topic
+      db_shard_groups[db_shard] << system_events_topic
+
+      all_same_db_shard = Topic.all_same_db_shard?(db_shard_groups)
+
       while true
-        Topic.read_topics(InterfaceTopic.topics(interface, scope: scope)) do |topic, msg_id, msg_hash, redis|
-          result = yield topic, msg_id, msg_hash, redis
-          if result
-            # Only ack if we intend to - Disabled targets will not ack
-            ack_topic = topic.split("__")
-            ack_topic[1] = 'ACK' + ack_topic[1]
-            ack_topic = ack_topic.join("__")
-            Topic.write_topic(ack_topic, { 'result' => result, 'id' => msg_id }, '*', 100)
+        if all_same_db_shard
+          # Fast path: everything on one db_shard, single read
+          db_shard = db_shard_groups.keys.first || 0
+          Topic.read_topics(db_shard_groups[db_shard], db_shard: db_shard) do |topic, msg_id, msg_hash, redis|
+            result = yield topic, msg_id, msg_hash, redis
+            Topic.write_ack(topic, result, msg_id, db_shard: db_shard) if result
+          end
+        else
+          timeout_per_db_shard = [1000 / [db_shard_groups.length, 1].max, 100].max
+          db_shard_groups.each do |db_shard, topics|
+            Topic.read_topics(topics, nil, timeout_per_db_shard, db_shard: db_shard) do |topic, msg_id, msg_hash, redis|
+              result = yield topic, msg_id, msg_hash, redis
+              Topic.write_ack(topic, result, msg_id, db_shard: db_shard) if result
+            end
           end
         end
       end
@@ -50,15 +79,16 @@ module OpenC3
 
     def self.write_raw(interface_name, data, timeout: nil, scope:)
       interface_name = interface_name.upcase
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
 
       timeout = COMMAND_ACK_TIMEOUT_S unless timeout
       ack_topic = "{#{scope}__ACKCMD}INTERFACE__#{interface_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
 
-      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'raw' => data }, '*', 100)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'raw' => data }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == cmd_id
             if msg_hash["result"] == "SUCCESS"
               return
@@ -72,61 +102,70 @@ module OpenC3
     end
 
     def self.connect_interface(interface_name, *interface_params, scope:)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
       if interface_params && !interface_params.empty?
-        Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true', 'params' => JSON.generate(interface_params, allow_nan: true) }, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true', 'params' => JSON.generate(interface_params, allow_nan: true) }, '*', 100, db_shard: db_shard)
       else
-        Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true' }, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'connect' => 'true' }, '*', 100, db_shard: db_shard)
       end
     end
 
     def self.disconnect_interface(interface_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'disconnect' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'disconnect' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.start_raw_logging(interface_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.stop_raw_logging(interface_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'false' }, '*', 100)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'log_stream' => 'false' }, '*', 100, db_shard: db_shard)
     end
 
     def self.shutdown(interface, scope:)
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface.name}", { 'shutdown' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_interface(interface.name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface.name}", { 'shutdown' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.interface_cmd(interface_name, cmd_name, *cmd_params, scope:)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'interface_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'interface_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
       data['read_write'] = read_write.to_s.upcase
       data['index'] = index
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
-    def self.inject_tlm(interface_name, target_name, packet_name, item_hash = nil, type: :CONVERTED, timeout: nil, scope:)
+    def self.inject_tlm(interface_name, target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, timeout: nil, scope:)
       interface_name = interface_name.upcase
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
 
       timeout = COMMAND_ACK_TIMEOUT_S unless timeout
       ack_topic = "{#{scope}__ACKCMD}INTERFACE__#{interface_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
 
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['packet_name'] = packet_name.to_s.upcase
       data['item_hash'] = item_hash
       data['type'] = type
-      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      data['stored'] = stored
+      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == cmd_id
             if msg_hash["result"] == "SUCCESS"
               return
@@ -140,34 +179,37 @@ module OpenC3
     end
 
     def self.interface_target_enable(interface_name, target_name, cmd_only: false, tlm_only: false, scope:)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['cmd_only'] = cmd_only
       data['tlm_only'] = tlm_only
       data['action'] = 'enable'
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.interface_target_disable(interface_name, target_name, cmd_only: false, tlm_only: false, scope:)
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['cmd_only'] = cmd_only
       data['tlm_only'] = tlm_only
       data['action'] = 'disable'
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.interface_details(interface_name, timeout: nil, scope:)
       interface_name = interface_name.upcase
+      db_shard = _db_shard_for_interface(interface_name, scope: scope)
 
       timeout = COMMAND_ACK_TIMEOUT_S unless timeout
       ack_topic = "{#{scope}__ACKCMD}INTERFACE__#{interface_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
 
-      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'interface_details' => 'true' }, '*', 100)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'interface_details' => 'true' }, '*', 100, db_shard: db_shard)
       time = Time.now
       while (Time.now - time) < timeout
-        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+        Topic.read_topics([ack_topic], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
           if msg_hash["id"] == cmd_id
             return JSON.parse(msg_hash["result"], :allow_nan => true, :create_additions => true)
           end

data/lib/openc3/topics/limits_event_topic.rb

@@ -25,6 +25,16 @@ module OpenC3
   # While this isn't a clean separation of topics (streams) and models (key-value)
   # it helps maintain consistency as the topic and model are linked.
   class LimitsEventTopic < Topic
+    # Collect all unique target db_shards from TargetModel
+    def self._active_db_shards(scope:)
+      db_shards = Set.new([0])
+      Store.hgetall("#{scope}__openc3_targets").each do |_name, json|
+        parsed = JSON.parse(json, allow_nan: true, create_additions: true)
+        db_shards << (parsed['db_shard'] || 0).to_i
+      end
+      db_shards
+    end
+
     def self.write(event, scope:)
       case event[:type]
       when :LIMITS_CHANGE
@@ -81,7 +91,10 @@ module OpenC3
         raise "Invalid limits event type '#{event[:type]}'"
       end
 
-      Topic.write_topic("#{scope}__openc3_limits_events", {event: JSON.generate(event, allow_nan: true)}, '*', 1000)
+      # Write to all active db_shards so each decom microservice can read limits events inline
+      _active_db_shards(scope: scope).each do |db_shard|
+        Topic.write_topic("#{scope}__openc3_limits_events", {event: JSON.generate(event, allow_nan: true)}, '*', 1000, db_shard: db_shard)
+      end
     end
 
     # Remove the JSON encoding to return hashes directly
@@ -189,51 +202,59 @@ module OpenC3
       end
     end
 
-    # Update the local system based on limits events
-    def self.sync_system_thread_body(scope:, block_ms: nil)
-      telemetry = System.telemetry.all
-      topics = ["#{scope}__openc3_limits_events"]
-      Topic.read_topics(topics, nil, block_ms) do |_topic, _msg_id, event, _redis|
-        event = JSON.parse(event['event'], allow_nan: true, create_additions: true)
-        case event['type']
-        when 'LIMITS_CHANGE'
-          # Ignore
-        when 'LIMITS_SETTINGS'
-          target_name = event['target_name']
-          packet_name = event['packet_name']
-          item_name = event['item_name']
-          target = telemetry[target_name]
-          if target
-            packet = target[packet_name]
-            if packet
-              enabled = ConfigParser.handle_true_false_nil(event['enabled'])
-              persistence = event['persistence']
-              System.limits.set(target_name, packet_name, item_name,
-                  event['red_low'], event['yellow_low'], event['yellow_high'], event['red_high'],
-                  event['green_low'], event['green_high'], event['limits_set'], persistence, enabled)
-            end
+    # Process a single limits event hash and update the local System accordingly.
+    # Called inline by DecomMicroservice when reading from the limits events topic.
+    def self.process_event(event, telemetry: nil)
+      telemetry ||= System.telemetry.all
+      case event['type']
+      when 'LIMITS_CHANGE'
+        # Ignore
+      when 'LIMITS_SETTINGS'
+        target_name = event['target_name']
+        packet_name = event['packet_name']
+        item_name = event['item_name']
+        target = telemetry[target_name]
+        if target
+          packet = target[packet_name]
+          if packet
+            enabled = ConfigParser.handle_true_false_nil(event['enabled'])
+            persistence = event['persistence']
+            System.limits.set(target_name, packet_name, item_name,
+                event['red_low'], event['yellow_low'], event['yellow_high'], event['red_high'],
+                event['green_low'], event['green_high'], event['limits_set'], persistence, enabled)
           end
+        end
 
-        when 'LIMITS_ENABLE_STATE'
-          target_name = event['target_name']
-          packet_name = event['packet_name']
-          item_name = event['item_name']
-          target = telemetry[target_name]
-          if target
-            packet = target[packet_name]
-            if packet
-              enabled = ConfigParser.handle_true_false_nil(event['enabled'])
-              if enabled
-                System.limits.enable(target_name, packet_name, item_name)
-              else
-                System.limits.disable(target_name, packet_name, item_name)
-              end
+      when 'LIMITS_ENABLE_STATE'
+        target_name = event['target_name']
+        packet_name = event['packet_name']
+        item_name = event['item_name']
+        target = telemetry[target_name]
+        if target
+          packet = target[packet_name]
+          if packet
+            enabled = ConfigParser.handle_true_false_nil(event['enabled'])
+            if enabled
+              System.limits.enable(target_name, packet_name, item_name)
+            else
+              System.limits.disable(target_name, packet_name, item_name)
             end
           end
-
-        when 'LIMITS_SET'
-          System.limits_set = event['set']
         end
+
+      when 'LIMITS_SET'
+        System.limits_set = event['set']
+      end
+    end
+
+    # Update the local system based on limits events (standalone read loop).
+    # Still available for non-decom consumers that need to sync limits.
+    def self.sync_system_thread_body(scope:, block_ms: nil)
+      telemetry = System.telemetry.all
+      topics = ["#{scope}__openc3_limits_events"]
+      Topic.read_topics(topics, nil, block_ms) do |_topic, _msg_id, event, _redis|
+        event = JSON.parse(event['event'], allow_nan: true, create_additions: true)
+        process_event(event, telemetry: telemetry)
       end
     end
   end