openc3 5.13.0 → 5.14.0

data/lib/openc3/api/limits_api.rb

@@ -190,10 +190,10 @@ module OpenC3
     #               'TVAC' => [-25, -10, 50, 55] }
     #
     # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
-    def get_limits(target_name, packet_name, item_name, scope: $openc3_scope, token: $openc3_token)
+    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       limits = {}
-      item = _get_item(target_name, packet_name, item_name, scope: scope)
+      item = _get_item(target_name, packet_name, item_name, cache_timeout: cache_timeout, scope: scope)
       item['limits'].each do |key, vals|
         next unless vals.is_a?(Hash)
 
@@ -374,7 +374,7 @@ module OpenC3
     # @param item_name [String] item name
     # @param scope [String] scope
     # @return Hash The requested item based on the packet name
-    def _get_item(target_name, packet_name, item_name, cache_timeout: 0.1, scope:)
+    def _get_item(target_name, packet_name, item_name, cache_timeout: nil, scope:)
       # Determine if this item exists, it will raise appropriate errors if not
       packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: $openc3_scope) if packet_name == 'LATEST'
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)

data/lib/openc3/api/tlm_api.rb

@@ -69,26 +69,26 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     # @return [Object] The telemetry value formatted as requested
-    def tlm(*args, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm(*args, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'tlm', cache_timeout: cache_timeout, scope: scope)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       CvtModel.get_item(target_name, packet_name, item_name, type: type.intern, cache_timeout: cache_timeout, scope: scope)
     end
 
-    def tlm_raw(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_raw(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :RAW, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    def tlm_formatted(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_formatted(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
-    def tlm_with_units(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_with_units(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type:
-    def tlm_variable(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def tlm_variable(*args, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       tlm(*args[0..-2], type: args[-1].intern, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
@@ -226,7 +226,7 @@ module OpenC3
     # @return [Array<String, Object, Symbol|nil>] Returns an Array consisting
     #   of [item name, item value, item limits state] where the item limits
     #   state can be one of {OpenC3::Limits::LIMITS_STATES}
-    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_packet(*args, stale_time: 30, type: :CONVERTED, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name = _extract_target_packet_names('get_tlm_packet', *args)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
@@ -248,7 +248,7 @@ module OpenC3
     # @return [Array<Object, Symbol>]
     #   Array consisting of the item value and limits state
     #   given as symbols such as :RED, :YELLOW, :STALE
-    def get_tlm_values(items, stale_time: 30, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
@@ -466,7 +466,7 @@ module OpenC3
       return nil
     end
 
-    def _tlm_process_args(args, method_name, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+    def _tlm_process_args(args, method_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])

data/lib/openc3/interfaces/interface.rb

@@ -198,14 +198,16 @@ module OpenC3
             log_dont_log.upcase!
             period = "#{period.to_f}s"
             @scheduler.every period do
-              begin
-                if log_dont_log == 'DONT_LOG'
-                  cmd(cmd_string, log_message: false)
-                else
-                  cmd(cmd_string)
+              if connected?()
+                begin
+                  if log_dont_log == 'DONT_LOG'
+                    cmd(cmd_string, log_message: false)
+                  else
+                    cmd(cmd_string)
+                  end
+                rescue Exception => err
+                  Logger.error("Error sending periodic cmd(#{cmd_string}):\n#{err.formatted}")
                 end
-              rescue Exception => err
-                Logger.error("Error sending periodic cmd(#{cmd_string}):\n#{err.formatted}")
               end
             end
           end

data/lib/openc3/interfaces/protocols/cmd_response_protocol.rb

@@ -0,0 +1,116 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/config/config_parser'
+require 'openc3/interfaces/protocols/protocol'
+require 'thread' # For Queue
+require 'timeout' # For Timeout::Error
+
+module OpenC3
+  # Protocol that waits for a response for any commands with a defined response packet.
+  # The response packet is identified but not defined by the protocol.
+  class CmdResponseProtocol < Protocol
+    # @param response_timeout [Float] Number of seconds to wait before timing out
+    #   when waiting for a response
+    # @param response_polling_period [Float] Number of seconds to wait between polling
+    #   for a response
+    # @param raise_exceptions [String] Whether to raise exceptions when errors
+    #   occur in the protocol like unexpected responses or response timeouts.
+    # @param allow_empty_data [true/false/nil] See Protocol#initialize
+    def initialize(
+      response_timeout = 5.0,
+      response_polling_period = 0.02,
+      raise_exceptions = false,
+      allow_empty_data = nil
+    )
+      super(allow_empty_data)
+      @response_timeout = ConfigParser.handle_nil(response_timeout)
+      @response_timeout = @response_timeout.to_f if @response_timeout
+      @response_polling_period = response_polling_period.to_f
+      @raise_exceptions = ConfigParser.handle_true_false(raise_exceptions)
+      @write_block_queue = Queue.new
+      @response_packet = nil
+    end
+
+    def connect_reset
+      super()
+      @write_block_queue.clear
+    end
+
+    def disconnect_reset
+      super()
+      @write_block_queue << nil # Unblock the write block queue
+    end
+
+    def read_packet(packet)
+      if @response_packet
+        # Grab the response packet specified in the command
+        result_packet = System.telemetry.packet(@response_packet[0], @response_packet[1]).clone
+        result_packet.buffer = packet.buffer
+        result_packet.received_time = nil
+        result_packet.stored = packet.stored
+        result_packet.extra = packet.extra
+
+        # Release the write
+        @write_block_queue << nil
+
+        # This returns the fully identified and defined packet
+        # Received time is handled by the interface microservice
+        return result_packet
+      else
+        return packet
+      end
+    end
+
+    def write_packet(packet)
+      # Setup the response packet (if there is one)
+      # This primes waiting for the response in post_write_interface
+      @response_packet = packet.response
+
+      return packet
+    end
+
+    def post_write_interface(packet, data, extra = nil)
+      if @response_packet
+        if @response_timeout
+          response_timeout_time = Time.now + @response_timeout
+        else
+          response_timeout_time = nil
+        end
+
+        # Block the write until the response is received
+        begin
+          @write_block_queue.pop(true)
+        rescue
+          sleep(@response_polling_period)
+          retry if !response_timeout_time
+          retry if response_timeout_time and Time.now < response_timeout_time
+          handle_error("#{@interface ? @interface.name : ""}: Timeout waiting for response")
+        end
+
+        @response_packet = nil
+      end
+      return super(packet, data, extra)
+    end
+
+    def handle_error(msg)
+      Logger.error(msg)
+      raise msg if @raise_exceptions
+    end
+  end
+end

data/lib/openc3/interfaces/tcpip_client_interface.rb

@@ -67,6 +67,10 @@ module OpenC3
         @write_timeout,
         @read_timeout
       )
+      # Pass down options to the stream
+      @options.each do |option_name, option_values|
+        @stream.set_option(option_name, option_values)
+      end
       super()
     end
   end

data/lib/openc3/interfaces/tcpip_server_interface.rb

@@ -391,6 +391,11 @@ module OpenC3
       read_socket = socket if listen_read
       stream = TcpipSocketStream.new(write_socket, read_socket, @write_timeout, @read_timeout)
 
+      # Pass down options to the stream
+      @options.each do |option_name, option_values|
+        stream.set_option(option_name, option_values)
+      end
+
       interface = StreamInterface.new
       interface.target_names = @target_names
       interface.cmd_target_names = @cmd_target_names

data/lib/openc3/interfaces.rb

@@ -42,7 +42,7 @@ module OpenC3
   autoload(:PreidentifiedProtocol, 'openc3/interfaces/protocols/preidentified_protocol.rb')
   autoload(:TemplateProtocol, 'openc3/interfaces/protocols/template_protocol.rb')
   autoload(:TerminatedProtocol, 'openc3/interfaces/protocols/terminated_protocol.rb')
-
+  autoload(:CmdResponseProtocol, 'openc3/interfaces/protocols/cmd_response_protocol.rb')
   autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
   autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
 end

data/lib/openc3/microservices/decom_microservice.rb

@@ -100,6 +100,7 @@ module OpenC3
           packet.extra = extra
         end
         packet.buffer = msg_hash["buffer"]
+        packet.process # Run processors
         packet.check_limits(System.limits_set) # Process all the limits and call the limits_change_callback (as necessary)
 
         TelemetryDecomTopic.write_packet(packet, scope: @scope)

data/lib/openc3/microservices/interface_microservice.rb

@@ -613,7 +613,16 @@ module OpenC3
 
     def connect
       @logger.info "#{@interface.name}: Connecting ..."
-      @interface.connect
+      begin
+        @interface.connect
+      rescue Exception => error
+        begin
+          @interface.disconnect # Ensure disconnect is called at least once on a partial connect
+        rescue Exception
+          # We want to report any connect errors, not disconnect in this case
+        end
+        raise error
+      end
       @interface.state = 'CONNECTED'
       if @interface_or_router == 'INTERFACE'
         InterfaceStatusModel.set(@interface.as_json(:allow_nan => true), scope: @scope)

data/lib/openc3/models/cvt_model.rb

@@ -52,12 +52,14 @@ module OpenC3
 
     # Get the hash for packet in the CVT
     # Note: Does not apply overrides
-    def self.get(target_name:, packet_name:, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get(target_name:, packet_name:, cache_timeout: nil, scope: $openc3_scope)
       key = "#{scope}__tlm__#{target_name}"
       tgt_pkt_key = key + "__#{packet_name}"
-      cache_time, hash = @@packet_cache[tgt_pkt_key]
       now = Time.now
-      return hash if hash and (now - cache_time) < cache_timeout
+      if cache_timeout
+        cache_time, hash = @@packet_cache[tgt_pkt_key]
+        return hash if hash and (now - cache_time) < cache_timeout
+      end
       packet = Store.hget(key, packet_name)
       raise "Packet '#{target_name} #{packet_name}' does not exist" unless packet
       hash = JSON.parse(packet, :allow_nan => true, :create_additions => true)
@@ -67,7 +69,7 @@ module OpenC3
 
     # Set an item in the current value table
     def self.set_item(target_name, packet_name, item_name, value, type:, scope: $openc3_scope)
-      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: 0.0, scope: scope)
+      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: nil, scope: scope)
       case type
       when :WITH_UNITS
         hash["#{item_name}__U"] = value.to_s # WITH_UNITS should always be a string
@@ -89,10 +91,10 @@ module OpenC3
     end
 
     # Get an item from the current value table
-    def self.get_item(target_name, packet_name, item_name, type:, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get_item(target_name, packet_name, item_name, type:, cache_timeout: nil, scope: $openc3_scope)
       result, types = self._handle_item_override(target_name, packet_name, item_name, type: type, cache_timeout: cache_timeout, scope: scope)
       return result if result
-      hash = get(target_name: target_name, packet_name: packet_name, scope: scope)
+      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: cache_timeout, scope: scope)
       hash.values_at(*types).each do |result|
         if result
           if type == :FORMATTED or type == :WITH_UNITS
@@ -109,7 +111,7 @@ module OpenC3
     # @param items [Array<String>] Items to return. Must be formatted as TGT__PKT__ITEM__TYPE
     # @param stale_time [Integer] Time in seconds from Time.now that value will be marked stale
     # @return [Array] Array of values
-    def self.get_tlm_values(items, stale_time: 30, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope)
       now = Time.now
       results = []
       lookups = []
@@ -246,7 +248,7 @@ module OpenC3
       end
     end
 
-    def self.determine_latest_packet_for_item(target_name, item_name, cache_timeout: 0.1, scope: $openc3_scope)
+    def self.determine_latest_packet_for_item(target_name, item_name, cache_timeout: nil, scope: $openc3_scope)
       item_map = TargetModel.get_item_to_packet_map(target_name, scope: scope)
       packet_names = item_map[item_name]
       raise "Item '#{target_name} LATEST #{item_name}' does not exist for scope: #{scope}" unless packet_names
@@ -293,10 +295,12 @@ module OpenC3
     end
 
     def self._get_overrides(now, tgt_pkt_key, overrides, target_name, packet_name, cache_timeout:, scope:)
-      cache_time, hash = @@override_cache[tgt_pkt_key]
-      if hash and (now - cache_time) < cache_timeout
-        overrides[tgt_pkt_key] = hash
-        return hash
+      if cache_timeout
+        cache_time, hash = @@override_cache[tgt_pkt_key]
+        if hash and (now - cache_time) < cache_timeout
+          overrides[tgt_pkt_key] = hash
+          return hash
+        end
       end
       override_data = Store.hget("#{scope}__override__#{target_name}", packet_name)
       if override_data

data/lib/openc3/models/gem_model.rb

@@ -39,11 +39,17 @@ module OpenC3
     include Api
 
     def self.names
-      result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
+      if Dir.exist?("#{ENV['GEM_HOME']}/gems")
+        result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
+      else
+        result = []
+      end
       return result.sort
     end
 
     def self.get(name)
+      path = "#{ENV['GEM_HOME']}/cosmoscache/#{name}"
+      return path if File.exist?(path)
       path = "#{ENV['GEM_HOME']}/cache/#{name}"
       return path if File.exist?(path)
       raise "Gem #{name} not found"
@@ -52,8 +58,9 @@ module OpenC3
     def self.put(gem_file_path, gem_install: true, scope:)
       if File.file?(gem_file_path)
         gem_filename = File.basename(gem_file_path)
-        FileUtils.mkdir_p("#{ENV['GEM_HOME']}/cache") unless Dir.exist?("#{ENV['GEM_HOME']}/cache")
-        FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cache/#{File.basename(gem_file_path)}")
+        # Put into cosmoscache folder that we control
+        FileUtils.mkdir_p("#{ENV['GEM_HOME']}/cosmoscache") unless Dir.exist?("#{ENV['GEM_HOME']}/cosmoscache")
+        FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cosmoscache/#{File.basename(gem_file_path)}")
         if gem_install
           Logger.info "Installing gem: #{gem_filename}"
           result = OpenC3::ProcessManager.instance.spawn(["ruby", "/openc3/bin/openc3cli", "geminstall", gem_filename, scope], "package_install", gem_filename, Time.now + 3600.0, scope: scope)
@@ -118,5 +125,15 @@ module OpenC3
       version = File.basename(split_name[-1], '.gem')
       return gem_name, version
     end
+
+    def self.destroy_all_other_versions(name)
+      keep_gem_name, keep_gem_version = GemModel.extract_name_and_version(name)
+      GemModel.names.each do |gem_full_name|
+        gem_name, gem_version = GemModel.extract_name_and_version(gem_full_name)
+        if gem_name == keep_gem_name and gem_version != keep_gem_version
+          GemModel.destroy(gem_full_name)
+        end
+      end
+    end
   end
 end

data/lib/openc3/models/microservice_model.rb

@@ -185,7 +185,7 @@ module OpenC3
         @topics << parameters[0]
       when 'TARGET_NAME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
-        @target_names << parameters[0]
+        @target_names << parameters[0].upcase
       when 'CMD'
         parser.verify_num_parameters(1, nil, "#{keyword} <Args>")
         @cmd = parameters.dup

data/lib/openc3/models/plugin_model.rb

@@ -158,6 +158,11 @@ module OpenC3
           gem_file_path = OpenC3::GemModel.get(gem_name)
         end
 
+        # Attempt to remove all older versions of this same plugin before install to prevent version conflicts
+        # Especially on downgrades
+        # Leave the same version if it already exists
+        OpenC3::GemModel.destroy_all_other_versions(File.basename(gem_file_path))
+
         # Actually install the gem now (slow)
         OpenC3::GemModel.install(gem_file_path, scope: scope) unless validate_only
 
@@ -356,7 +361,6 @@ module OpenC3
     # Reinstall
     def restore
       plugin_hash = self.as_json(:allow_nan => true)
-      plugin_hash['name'] = plugin_hash['name'].split("__")[0]
       OpenC3::PluginModel.install_phase2(plugin_hash, scope: @scope)
       @destroyed = false
     end

data/lib/openc3/models/target_model.rb

@@ -742,7 +742,7 @@ module OpenC3
       end
     end
 
-    def update_store(system)
+    def update_target_model(system)
       target = system.targets[@name]
 
       # Add in the information from the target and update
@@ -754,10 +754,11 @@ module OpenC3
       @tlm_unique_id_mode = target.tlm_unique_id_mode
       @limits_groups = system.limits.groups.keys
       update()
+    end
 
-      # Store Packet Definitions
-      system.telemetry.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3tlm__#{target_name}")
+    def update_store_telemetry(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3tlm__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring tlm packet: #{target_name} #{packet_name}"
           begin
@@ -773,8 +774,11 @@ module OpenC3
           CvtModel.set(json_hash, target_name: packet.target_name, packet_name: packet.packet_name, scope: @scope)
         end
       end
-      system.commands.all.each do |target_name, packets|
-        Store.del("#{@scope}__openc3cmd__#{target_name}")
+    end
+
+    def update_store_commands(packet_hash, clear_old: true)
+      packet_hash.each do |target_name, packets|
+        Store.del("#{@scope}__openc3cmd__#{target_name}") if clear_old
         packets.each do |packet_name, packet|
           Logger.info "Configuring cmd packet: #{target_name} #{packet_name}"
           begin
@@ -785,7 +789,9 @@ module OpenC3
           end
         end
       end
-      # Store Limits Groups
+    end
+
+    def update_store_limits_groups(system)
       system.limits.groups.each do |group, items|
         begin
           Store.hset("#{@scope}__limits_groups", group, JSON.generate(items))
@@ -794,23 +800,77 @@ module OpenC3
           raise err
         end
       end
-      # Merge in Limits Sets
+    end
+
+    def update_store_limits_sets(system)
       sets = Store.hgetall("#{@scope}__limits_sets")
       sets ||= {}
       system.limits.sets.each do |set|
         sets[set.to_s] = "false" unless sets.key?(set.to_s)
       end
       Store.hmset("#{@scope}__limits_sets", *sets)
+    end
 
+    def update_store_item_map
       # Create item_map
       item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
       item_map = self.class.build_item_to_packet_map(@name, scope: @scope)
       Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
       @@item_map_cache[@name] = [Time.now, item_map]
+    end
 
+    def update_store(system, clear_old: true)
+      update_target_model(system)
+      update_store_telemetry(system.telemetry.all, clear_old: clear_old)
+      update_store_commands(system.commands.all, clear_old: clear_old)
+      update_store_limits_groups(system)
+      update_store_limits_sets(system)
+      update_store_item_map()
       return system
     end
 
+    def dynamic_update(packets, cmd_or_tlm = :TELEMETRY, filename = "dynamic_tlm.txt")
+      # Build hash of targets/packets
+      packet_hash = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        packet_hash[target_name] ||= {}
+        packet_name = packet.packet_name.upcase
+        packet_hash[target_name][packet_name] = packet
+      end
+
+      # Update Redis
+      if cmd_or_tlm == :TELEMETRY
+        update_store_telemetry(packet_hash, clear_old: false)
+        update_store_item_map()
+      else
+        update_store_commands(packet_hash, clear_old: false)
+      end
+
+      # Build dynamic file for cmd_tlm
+      configs = {}
+      packets.each do |packet|
+        target_name = packet.target_name.upcase
+        configs[target_name] ||= ""
+        config = configs[target_name]
+        config << packet.to_config(cmd_or_tlm)
+        config << "\n"
+      end
+      configs.each do |target_name, config|
+        begin
+          bucket_key = "#{@scope}/targets_modified/#{target_name}/cmd_tlm/#{filename}"
+          client = Bucket.getClient()
+          client.put_object(
+            # Use targets_modified to save modifications
+            # This keeps the original target clean (read-only)
+            bucket: ENV['OPENC3_CONFIG_BUCKET'],
+            key: bucket_key,
+            body: config
+          )
+        end
+      end
+    end
+
     def deploy_commmandlog_microservice(gem_path, variables, topics, instance = nil, parent = nil)
       microservice_name = "#{@scope}__COMMANDLOG#{instance}__#{@name}"
       microservice = MicroserviceModel.new(
@@ -990,6 +1050,7 @@ module OpenC3
           cmd: ["ruby", "multi_microservice.rb", *@children],
           work_dir: '/openc3/lib/openc3/microservices',
           plugin: @plugin,
+          needs_dependencies: @needs_dependencies,
           scope: @scope
         )
         microservice.create