openc3 7.0.0 → 7.1.0

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,83 +102,114 @@ 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, 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], 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
-      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], db_shard: db_shard) do |_topic, _msg_id, msg_hash, _redis|
+          if msg_hash["id"] == cmd_id
+            if msg_hash["result"] == "SUCCESS"
+              return
+            else
+              raise msg_hash["result"]
+            end
+          end
+        end
+      end
+      raise "Timeout of #{timeout}s waiting for cmd ack"
     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

data/lib/openc3/topics/router_topic.rb

@@ -21,6 +21,12 @@ module OpenC3
   class RouterTopic < Topic
     COMMAND_ACK_TIMEOUT_S = 30
 
+    # Look up db_shard from RouterModel
+    def self._db_shard_for_router(router_name, scope:)
+      json = Store.hget("#{scope}__openc3_routers", router_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 router. This includes the router itself
     # and all the targets which are assigned to this router.
     def self.topics(router, scope:)
@@ -34,15 +40,39 @@ module OpenC3
       topics
     end
 
-    def self.receive_telemetry(router, scope:)
+    def self.receive_telemetry(router, scope:, db_shard: 0)
+      db_shard = db_shard.to_i
+      router_cmd_topic = "{#{scope}__CMD}ROUTER__#{router.name}"
+
+      target_topics = []
+      router.tlm_target_names.each do |target_name|
+        System.telemetry.packets(target_name).each do |_packet_name, packet|
+          target_topics << "#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}"
+        end
+      end
+
+      # Group telemetry topics by db_shard; include router cmd topic on db_shard
+      db_shard_groups = Topic.group_topics_by_db_shard(target_topics, target_pattern: '__TELEMETRY__', scope: scope)
+      db_shard_groups[db_shard] ||= []
+      db_shard_groups[db_shard] << router_cmd_topic
+
+      all_same_db_shard = Topic.all_same_db_shard?(db_shard_groups)
+
       while true
-        Topic.read_topics(RouterTopic.topics(router, scope: scope)) do |topic, msg_id, msg_hash, redis|
-          result = yield topic, msg_id, msg_hash, redis
-          if result and /CMD}ROUTER/.match?(topic)
-            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 }, 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 and /CMD}ROUTER/.match?(topic)
+          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 and /CMD}ROUTER/.match?(topic)
+            end
           end
         end
       end
@@ -61,74 +91,84 @@ module OpenC3
     end
 
     def self.connect_router(router_name, *router_params, scope:)
+      db_shard = _db_shard_for_router(router_name, scope: scope)
       if router_params && !router_params.empty?
-        Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => 'true', 'params' => JSON.generate(router_params, allow_nan: true) }, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => 'true', 'params' => JSON.generate(router_params, allow_nan: true) }, '*', 100, db_shard: db_shard)
       else
-        Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => 'true' }, '*', 100)
+        Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'connect' => 'true' }, '*', 100, db_shard: db_shard)
       end
     end
 
     def self.disconnect_router(router_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'disconnect' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_router(router_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'disconnect' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.start_raw_logging(router_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_router(router_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.stop_raw_logging(router_name, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'false' }, '*', 100)
+      db_shard = _db_shard_for_router(router_name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'log_stream' => 'false' }, '*', 100, db_shard: db_shard)
     end
 
     def self.shutdown(router, scope:)
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router.name}", { 'shutdown' => 'true' }, '*', 100)
+      db_shard = _db_shard_for_router(router.name, scope: scope)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router.name}", { 'shutdown' => 'true' }, '*', 100, db_shard: db_shard)
     end
 
     def self.router_cmd(router_name, cmd_name, *cmd_params, scope:)
+      db_shard = _db_shard_for_router(router_name, scope: scope)
       data = {}
       data['cmd_name'] = cmd_name
       data['cmd_params'] = cmd_params
-      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'router_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'router_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.protocol_cmd(router_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope:)
+      db_shard = _db_shard_for_router(router_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}ROUTER__#{router_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.router_target_enable(router_name, target_name, cmd_only: false, tlm_only: false, scope:)
+      db_shard = _db_shard_for_router(router_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}ROUTER__#{router_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.router_target_disable(router_name, target_name, cmd_only: false, tlm_only: false, scope:)
+      db_shard = _db_shard_for_router(router_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}ROUTER__#{router_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'target_control' => JSON.generate(data, allow_nan: true) }, '*', 100, db_shard: db_shard)
     end
 
     def self.router_details(router_name, timeout: nil, scope:)
       router_name = router_name.upcase
+      db_shard = _db_shard_for_router(router_name, scope: scope)
 
       timeout = COMMAND_ACK_TIMEOUT_S unless timeout
       ack_topic = "{#{scope}__ACKCMD}ROUTER__#{router_name}"
-      Topic.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic], db_shard: db_shard)
 
-      cmd_id = Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'router_details' => 'true' }, '*', 100)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}ROUTER__#{router_name}", { 'router_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/system_events_topic.rb

@@ -17,13 +17,30 @@ module OpenC3
   class SystemEventsTopic < Topic
     PRIMARY_KEY = "OPENC3__SYSTEM__EVENTS".freeze
 
+    # Collect all unique target db_shards from TargetModel
+    def self._active_db_shards
+      db_shards = Set.new([0])
+      # Iterate all scopes to find all target db_shards
+      Store.scan_each(match: '*__openc3_targets', type: 'hash') do |key|
+        Store.hgetall(key).each do |_name, json|
+          parsed = JSON.parse(json, allow_nan: true, create_additions: true)
+          db_shards << (parsed['db_shard'] || 0).to_i
+        end
+      end
+      db_shards
+    end
+
     def self.update_topic_offsets()
       Topic.update_topic_offsets([PRIMARY_KEY])
     end
 
     def self.write(type, event)
       event['type'] = type
-      Topic.write_topic(PRIMARY_KEY, {event: JSON.generate(event, allow_nan: true)}, '*', 1000)
+      msg = {event: JSON.generate(event, allow_nan: true)}
+      # Write to all active db_shards so every interface microservice can read system events inline
+      _active_db_shards.each do |db_shard|
+        Topic.write_topic(PRIMARY_KEY, msg, '*', 1000, db_shard: db_shard)
+      end
     end
 
     def self.read()

data/lib/openc3/topics/telemetry_decom_topic.rb

@@ -43,7 +43,8 @@ module OpenC3
           :received_count => packet.received_count,
           :json_data => json_data,
         }
-        Topic.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id)
+        db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
+        Topic.write_topic("#{scope}__DECOM__{#{packet.target_name}}__#{packet.packet_name}", msg_hash, id, db_shard: db_shard)
 
         unless packet.stored
           # Also update the current value table with the latest decommutated data

data/lib/openc3/topics/telemetry_topic.rb

@@ -31,10 +31,12 @@ module OpenC3
         :buffer => packet.buffer(false)
       }
       msg_hash[:extra] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
+      topic = "#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}"
+      db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
       if queued
-        EphemeralStoreQueued.write_topic("#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}", msg_hash)
+        EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
       else
-        Topic.write_topic("#{scope}__TELEMETRY__{#{packet.target_name}}__#{packet.packet_name}", msg_hash)
+        Topic.write_topic(topic, msg_hash, db_shard: db_shard)
       end
     end
   end