openc3 5.0.8 → 5.0.10

data/lib/openc3/packets/packet.rb

@@ -21,6 +21,7 @@ require 'digest'
 require 'openc3/packets/structure'
 require 'openc3/packets/packet_item'
 require 'openc3/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+require 'base64'
 
 module OpenC3
   # Adds features common to all OpenC3 packets of data to the Structure class.
@@ -85,6 +86,9 @@ module OpenC3
     # @return [Symbol] :CMD or :TLM
     attr_accessor :cmd_or_tlm
 
+    # @return [String] Base data for building packet
+    attr_reader :template
+
     # Valid format types
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
 
@@ -98,7 +102,7 @@ module OpenC3
       # @param buffer [String] String buffer to hold the packet data
       # @param item_class [Class] Class used to instantiate items (Must be a
       #   subclass of PacketItem)
-      def initialize(target_name, packet_name, default_endianness = :BIG_ENDIAN, description = nil, buffer = nil, item_class = PacketItem)
+      def initialize(target_name = nil, packet_name = nil, default_endianness = :BIG_ENDIAN, description = nil, buffer = nil, item_class = PacketItem)
         super(default_endianness, buffer, item_class)
         # Explictly call the defined setter methods
         self.target_name = target_name
@@ -123,6 +127,7 @@ module OpenC3
         @stored = false
         @extra = nil
         @cmd_or_tlm = nil
+        @template = nil
       end
 
       # Sets the target name this packet is associated with. Unidentified packets
@@ -290,7 +295,9 @@ module OpenC3
         begin
           internal_buffer_equals(buffer)
         rescue RuntimeError
-          Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
+          if BinaryAccessor == @accessor
+            Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
+          end
         end
         @read_conversion_cache.clear if @read_conversion_cache
         process()
@@ -353,6 +360,20 @@ module OpenC3
       end
     end
 
+    # Sets the template data for the packet
+    # Template data is used as the default buffer contents if provided
+    #
+    # @param hazardous_description [String] Hazardous description of the packet
+    def template=(template)
+      if template
+        raise ArgumentError, "template must be a String but is a #{template.class}" unless String === template
+
+        @template = template.freeze
+      else
+        @template = nil
+      end
+    end
+
     # Review bit offset to look for overlapping definitions. This will allow
     # gaps in the packet, but not allow the same bits to be used for multiple
     # variables.
@@ -531,11 +552,16 @@ module OpenC3
     # @param value_type [Symbol] How to convert the item before returning it.
     #   Must be one of {VALUE_TYPES}
     # @param buffer (see Structure#read_item)
+    # @param given_raw Given raw value to optimize
     # @return The value. :FORMATTED and :WITH_UNITS values are always returned
     #   as Strings. :RAW values will match their data_type. :CONVERTED values
     #   can be any type.
-    def read_item(item, value_type = :CONVERTED, buffer = @buffer)
-      value = super(item, :RAW, buffer)
+    def read_item(item, value_type = :CONVERTED, buffer = @buffer, given_raw = nil)
+      if given_raw
+        value = given_raw
+      else
+        value = super(item, :RAW, buffer)
+      end
       derived_raw = false
       if item.data_type == :DERIVED && value_type == :RAW
         value_type = :CONVERTED
@@ -632,6 +658,31 @@ module OpenC3
       return value
     end
 
+    # Read a list of items in the structure
+    #
+    # @param items [StructureItem] Array of PacketItem or one of its subclasses
+    # @param value_type [Symbol] Value type to read for every item
+    # @param buffer [String] The binary buffer to read the items from
+    # @return Hash of read names and values
+    def read_items(items, value_type = :RAW, buffer = @buffer, raw_value = nil)
+      buffer = allocate_buffer_if_needed() unless buffer
+      if value_type == :RAW
+        result = super(items, value_type, buffer)
+        # Must handle DERIVED special
+        items.each do |item|
+          if item.data_type == :DERIVED
+            result[item.name] = read_item(item, value_type, buffer)
+          end
+        end
+      else
+        result = {}
+        items.each do |item|
+          result[item.name] = read_item(item, value_type, buffer)
+        end
+      end
+      return result
+    end
+
     # Write an item in the packet
     #
     # @param item [PacketItem] Instance of PacketItem or one of its subclasses
@@ -674,6 +725,24 @@ module OpenC3
       end
     end
 
+    # Write values to the buffer based on the item definitions
+    #
+    # @param items [StructureItem] Array of StructureItem or one of its subclasses
+    # @param value [Object] Array of values based on the item definitions.
+    # @param value_type [Symbol] Value type of each item to write
+    # @param buffer [String] The binary buffer to write the values to
+    def write_items(items, values, value_type = :RAW, buffer = @buffer)
+      buffer = allocate_buffer_if_needed() unless buffer
+      if value_type == :RAW
+        return super(items, values, value_type, buffer)
+      else
+        items.each_with_index do |item, index|
+          write_item(item, values[index], value_type, buffer)
+        end
+      end
+      return buffer
+    end
+
     # Read an item in the packet by name
     #
     # @param name [String] Name of the item to read
@@ -738,12 +807,17 @@ module OpenC3
     #
     # @param buffer [String] Raw buffer of binary data
     # @param skip_item_names [Array] Array of item names to skip
-    def restore_defaults(buffer = @buffer, skip_item_names = nil)
+    # @param use_templase [Boolean] Apply template before setting defaults (or not)
+    def restore_defaults(buffer = @buffer, skip_item_names = nil, use_template = true)
+      buffer = allocate_buffer_if_needed() unless buffer
       upcase_skip_item_names = skip_item_names.map(&:upcase) if skip_item_names
+      buffer.replace(@template) if @template and use_template
       @sorted_items.each do |item|
         next if RESERVED_ITEM_NAMES.include?(item.name)
 
-        write_item(item, item.default, :CONVERTED, buffer) unless skip_item_names and upcase_skip_item_names.include?(item.name)
+        unless item.default.nil?
+          write_item(item, item.default, :CONVERTED, buffer) unless skip_item_names and upcase_skip_item_names.include?(item.name)
+        end
       end
     end
 
@@ -986,6 +1060,8 @@ module OpenC3
       config['disabled'] = true if @disabled
       config['hidden'] = true if @hidden
       config['stale'] = true if @stale
+      config['accessor'] = @accessor.to_s
+      config['template'] = Base64.encode64(@template) if @template
 
       if @processors
         processors = []
@@ -1024,6 +1100,14 @@ module OpenC3
       packet.disabled = hash['disabled']
       packet.hidden = hash['hidden']
       # packet.stale is read only
+      if hash['accessor']
+        begin
+          packet.accessor = OpenC3::const_get(hash['accessor'])
+        rescue => error
+          Logger.instance.error "#{packet.target_name} #{packet.packet_name} accessor of #{hash['accessor']} could not be found due to #{error}"
+        end
+      end
+      packet.template = Base64.decode64(hash['template']) if hash['template']
       packet.meta = hash['meta']
       # Can't convert processors
       hash['items'].each do |item|
@@ -1032,6 +1116,22 @@ module OpenC3
       packet
     end
 
+    def decom
+      # Read all the RAW at once because this could be optimized by the accessor
+      json_hash = read_items(@sorted_items)
+
+      # Now read all other value types - no accessor required
+      @sorted_items.each do |item|
+        given_raw = json_hash[item.name]
+        json_hash["#{item.name}__C"] = read_item(item, :CONVERTED, @buffer, given_raw) if item.states or (item.read_conversion and item.data_type != :DERIVED)
+        json_hash["#{item.name}__F"] = read_item(item, :FORMATTED, @buffer, given_raw) if item.format_string
+        json_hash["#{item.name}__U"] = read_item(item, :WITH_UNITS, @buffer, given_raw) if item.units
+        limits_state = item.limits.state
+        json_hash["#{item.name}__L"] = limits_state if limits_state
+      end
+      json_hash
+    end
+
     protected
 
     # Performs packet specific processing on the packet.

data/lib/openc3/packets/packet_config.rb

@@ -209,7 +209,7 @@ module OpenC3
               'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM',\
               'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM',\
               'APPEND_ARRAY_PARAMETER', 'ALLOW_SHORT', 'HAZARDOUS', 'PROCESSOR', 'META',\
-              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED'
+              'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED', 'ACCESSOR', 'TEMPLATE', 'TEMPLATE_FILE'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
 
             process_current_packet(parser, keyword, params)
@@ -221,7 +221,7 @@ module OpenC3
               'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',\
               'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED',\
               'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',\
-              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP'
+              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP', 'KEY'
             raise parser.error("No current item for #{keyword}") unless @current_item
 
             process_current_item(parser, keyword, params)
@@ -427,7 +427,30 @@ module OpenC3
         parser.verify_num_parameters(0, 0, usage)
         @current_packet.hidden = true
         @current_packet.disabled = true
+      when 'ACCESSOR'
+        usage = "#{keyword} <Accessor class name>"
+        parser.verify_num_parameters(1, 1, usage)
+        begin
+          klass = OpenC3.require_class(params[0])
+          @current_packet.accessor = klass
+        rescue Exception => err
+          raise parser.error(err)
+        end
+
+      when 'TEMPLATE'
+        usage = "#{keyword} <Template string>"
+        parser.verify_num_parameters(1, 1, usage)
+        @current_packet.template = params[0]
 
+      when 'TEMPLATE_FILE'
+        usage = "#{keyword} <Template file path>"
+        parser.verify_num_parameters(1, 1, usage)
+
+        begin
+          @current_packet.template = parser.read_file(params[0])
+        rescue Exception => err
+          raise parser.error(err)
+        end
       end
     end
 
@@ -444,14 +467,11 @@ module OpenC3
         usage = "#{keyword} <conversion class filename> <custom parameters> ..."
         parser.verify_num_parameters(1, nil, usage)
         begin
-          # require should be performed in target.txt
-          klass = params[0].filename_to_class_name.to_class
-          raise parser.error("#{params[0].filename_to_class_name} class not found. Did you require the file in target.txt?", usage) unless klass
-
+          klass = OpenC3.require_class(params[0])
           conversion = klass.new(*params[1..(params.length - 1)])
           @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
           if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
-            msg = "Read Conversion #{params[0].filename_to_class_name} on item #{@current_item.name} does not specify converted type or bit size"
+            msg = "Read Conversion #{params[0]} on item #{@current_item.name} does not specify converted type or bit size"
             @warnings << msg
             Logger.instance.warn @warnings[-1]
           end
@@ -600,6 +620,9 @@ module OpenC3
         parser.verify_num_parameters(0, 0, 'OVERLAP')
         @current_item.overlap = true
 
+      when 'KEY'
+        parser.verify_num_parameters(1, 1, 'KEY <key or path into data>')
+        @current_item.key = params[0]
       end
     end
 

data/lib/openc3/packets/parsers/limits_response_parser.rb

@@ -45,9 +45,7 @@ module OpenC3
 
     # @param item [PacketItem] The item the limits response should be added to
     def create_limits_response(item)
-      # require should be performed in target.txt
-      klass = @parser.parameters[0].filename_to_class_name.to_class
-      raise @parser.error("#{@parser.parameters[0].filename_to_class_name} class not found. Did you require the file in target.txt?", @usage) unless klass
+      klass = OpenC3.require_class(@parser.parameters[0])
 
       if @parser.parameters[1]
         item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])

data/lib/openc3/packets/parsers/processor_parser.rb

@@ -48,8 +48,7 @@ module OpenC3
     # @param packet [Packet] The packet the processor should be added to
     def create_processor(packet)
       # require should be performed in target.txt
-      klass = @parser.parameters[1].filename_to_class_name.to_class
-      raise @parser.error("#{@parser.parameters[1].filename_to_class_name} class not found. Did you require the file in target.txt?", @usage) unless klass
+      klass = OpenC3.require_class(@parser.parameters[1])
 
       if @parser.parameters[2]
         processor = klass.new(*@parser.parameters[2..(@parser.parameters.length - 1)])

data/lib/openc3/packets/parsers/xtce_parser.rb

@@ -178,14 +178,40 @@ module OpenC3
       when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
         'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
         'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
-        'ArgumentAssignmentList', 'LocationInContainerInBits'
+        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime'
         # Do Nothing
 
+      when 'ErrorDetectCorrect'
+        # TODO: Setup an algorithm to calculate the CRC
+        exponents = []
+        xtce_recurse_element(element) do |crc_element|
+          if crc_element.name == 'CRC'
+            xtce_recurse_element(crc_element) do |poly_element|
+              if poly_element['Polynomial']
+                xtce_recurse_element(poly_element) do |term_element|
+                  if term_element['Term']
+                    exponents << term_element['exponent'].to_i
+                  end
+                  true
+                end
+              end
+              true
+            end
+          end
+          true
+        end
+        @current_type.xtce_encoding = 'IntegerDataEncoding'
+        @current_type.signed = 'false'
+        return false # Already recursed
+
       when 'EnumeratedParameterType', 'EnumeratedArgumentType',
         'IntegerParameterType', 'IntegerArgumentType',
         'FloatParameterType', 'FloatArgumentType',
         'StringParameterType', 'StringArgumentType',
-        'BinaryParameterType', 'BinaryArgumentType'
+        'BinaryParameterType', 'BinaryArgumentType',
+        'BooleanParameterType', 'BooleanArgumentType',
+        'AbsoluteTimeParameterType', 'AbsoluteTimeArgumentType',
+        'RelativeTimeParameterType', 'RelativeTimeArgumentType'
         @current_type = create_new_type(element)
         @current_type.endianness = :BIG_ENDIAN
 
@@ -204,6 +230,20 @@ module OpenC3
         when 'BinaryParameterType', 'BinaryArgumentType'
           @current_type.xtce_encoding = 'BinaryDataEncoding'
           @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
+        when 'BooleanParameterType', 'BooleanArgumentType'
+          @current_type.xtce_encoding = 'StringDataEncoding'
+          @current_type.sizeInBits = 8 # This is undocumented but appears to be the design
+          @current_type.states ||= {}
+          if element.attributes['zeroStringValue'] && element.attributes['oneStringValue']
+            @current_type.states[element.attributes['zeroStringValue'].value] = 0
+            @current_type.states[element.attributes['oneStringValue'].value] = 1
+          else
+            @current_type.states['FALSE'] = 0
+            @current_type.states['TRUE'] = 1
+          end
+        # No defaults for the time types
+        # when 'AbsoluteTimeParameterType', 'AbsoluteTimeArgumentType',
+        # when'RelativeTimeParameterType', 'RelativeTimeArgumentType'
         end
 
       when 'ArrayParameterType', 'ArrayArgumentType'
@@ -251,7 +291,7 @@ module OpenC3
 
         return false # Already recursed
 
-      when "SizeInBits"
+      when 'SizeInBits'
         xtce_recurse_element(element) do |block_element|
           if block_element.name == 'FixedValue'
             @current_type.sizeInBits = Integer(block_element.text)
@@ -326,6 +366,26 @@ module OpenC3
         @current_type.states ||= {}
         @current_type.states[element['label']] = Integer(element['value'])
 
+      when 'Encoding'
+        if element.attributes['units']
+          @current_type.units_full = element.attributes['units'].value
+          # Could do a better job mapping units to abbreviations
+          @current_type.units = element.attributes['units'].value[0]
+        end
+        # TODO: Not sure if this is correct
+        # if @current_type.attributes['scale'] || @current_type.attributes['offset']
+        #   @current_type.conversion ||= PolynomialConversion.new()
+        #   if @current_type.attributes['offset']
+        #     @current_type.conversion.coeffs[0] = @current_type.attributes['offset']
+        #   end
+        #   if @current_type.attributes['scale']
+        #     @current_type.conversion.coeffs[1] = @current_type.attributes['scale']
+        #   end
+        # end
+
+      when 'Epoch'
+        # TODO: How to handle this ... it affects the conversion applied
+
       when 'IntegerDataEncoding', 'FloatDataEncoding', 'StringDataEncoding', 'BinaryDataEncoding'
         @current_type.xtce_encoding = element.name
         element.attributes.each do |att_name, att|
@@ -340,6 +400,11 @@ module OpenC3
           @current_type.endianness = :LITTLE_ENDIAN
         end
 
+        # Ensure if the encoding is a string we convert state values to strings
+        if @current_type.xtce_encoding == 'StringDataEncoding' && @current_type.states
+          @current_type.states.transform_values!(&:to_s)
+        end
+
       when 'Parameter'
         @current_parameter = OpenStruct.new
         element.attributes.each do |att_name, att|

data/lib/openc3/packets/structure.rb

@@ -51,6 +51,9 @@ module OpenC3
     #   required data size is allowed.
     attr_accessor :short_buffer_allowed
 
+    # @return [Accessor] Class used to access raw data of structure from buffer
+    attr_reader :accessor
+
     if RUBY_ENGINE != 'ruby' or ENV['OPENC3_NO_EXT']
       # Used to force encoding
       ASCII_8BIT_STRING = "ASCII-8BIT".freeze
@@ -86,6 +89,7 @@ module OpenC3
           @fixed_size = true
           @short_buffer_allowed = false
           @mutex = nil
+          @accessor = BinaryAccessor
         else
           raise(ArgumentError, "Unknown endianness '#{default_endianness}', must be :BIG_ENDIAN or :LITTLE_ENDIAN")
         end
@@ -103,11 +107,7 @@ module OpenC3
         return nil if item.data_type == :DERIVED
 
         buffer = allocate_buffer_if_needed() unless buffer
-        if item.array_size
-          return BinaryAccessor.read_array(item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness)
-        else
-          return BinaryAccessor.read(item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness)
-        end
+        return @accessor.read_item(item, buffer)
       end
 
       # Get the length of the buffer used by the structure
@@ -133,6 +133,26 @@ module OpenC3
       end
     end
 
+    # Configure the accessor for this packet
+    #
+    # @param accessor [Accessor] The class to use as an accessor
+    def accessor=(accessor)
+      @accessor = accessor
+      @short_buffer_allowed = true if @accessor != BinaryAccessor
+    end
+
+    # Read a list of items in the structure
+    #
+    # @param items [StructureItem] Array of StructureItem or one of its subclasses
+    # @param value_type [Symbol] Not used. Subclasses should overload this
+    #   parameter to check whether to perform conversions on the item.
+    # @param buffer [String] The binary buffer to read the item from
+    # @return Hash of read names and values
+    def read_items(items, value_type = :RAW, buffer = @buffer)
+      buffer = allocate_buffer_if_needed() unless buffer
+      return @accessor.read_items(items, buffer)
+    end
+
     # Allocate a buffer if not available
     def allocate_buffer_if_needed
       unless @buffer
@@ -180,11 +200,8 @@ module OpenC3
     #   dependant on the item_class but by default see StructureItem.
     # @return [StrutureItem] The struture item defined
     def define_item(name, bit_offset, bit_size, data_type, array_size = nil, endianness = @default_endianness, overflow = :ERROR)
-      # Handle case-insensitive naming
-      name_upcase = name.upcase
-
       # Create the item
-      item = @item_class.new(name_upcase, bit_offset, bit_size, data_type, endianness, array_size, overflow)
+      item = @item_class.new(name, bit_offset, bit_size, data_type, endianness, array_size, overflow)
       define(item)
     end
 
@@ -348,11 +365,19 @@ module OpenC3
     # @param buffer [String] The binary buffer to write the value to
     def write_item(item, value, value_type = :RAW, buffer = @buffer)
       buffer = allocate_buffer_if_needed() unless buffer
-      if item.array_size
-        BinaryAccessor.write_array(value, item.bit_offset, item.bit_size, item.data_type, item.array_size, buffer, item.endianness, item.overflow)
-      else
-        BinaryAccessor.write(value, item.bit_offset, item.bit_size, item.data_type, buffer, item.endianness, item.overflow)
-      end
+      return @accessor.write_item(item, value, buffer)
+    end
+
+    # Write values to the buffer based on the item definitions
+    #
+    # @param items [StructureItem] Array of StructureItem or one of its subclasses
+    # @param value [Object] Array of values based on the item definitions.
+    # @param value_type [Symbol] Not used. Subclasses should overload this
+    #   parameter to check whether to perform conversions on the item.
+    # @param buffer [String] The binary buffer to write the values to
+    def write_items(items, values, value_type = :RAW, buffer = @buffer)
+      buffer = allocate_buffer_if_needed() unless buffer
+      return @accessor.write_items(items, values, buffer)
     end
 
     # Read an item in the structure by name

data/lib/openc3/packets/structure_item.rb

@@ -34,6 +34,9 @@ module OpenC3
     # @return [String] Name of the item
     attr_reader :name
 
+    # Key is used to access into nested structures during decom if applicable
+    attr_reader :key
+
     # Indicates where in the binary buffer the StructureItem exists.
     # @return [Integer] 0 based bit offset
     attr_reader :bit_offset
@@ -89,6 +92,7 @@ module OpenC3
       @structure_item_constructed = false
       # Assignment order matters due to verifications!
       self.name = name
+      self.key = name # Key defaults to name as given (not upcased)
       self.endianness = endianness
       self.data_type = data_type
       self.bit_offset = bit_offset
@@ -110,6 +114,13 @@ module OpenC3
       verify_overall() if @structure_item_constructed
     end
 
+    def key=(key)
+      raise ArgumentError, "key must be a String but is a #{name.class}" unless String === key
+      raise ArgumentError, "key must contain at least one character" if key.empty?
+
+      @key = key
+    end
+
     def endianness=(endianness)
       raise ArgumentError, "#{@name}: endianness must be a Symbol" unless Symbol === endianness
       unless BinaryAccessor::ENDIANNESS.include? endianness
@@ -297,13 +308,16 @@ module OpenC3
       endianness = hash['endianness'] ? hash['endianness'].intern : nil
       data_type = hash['data_type'] ? hash['data_type'].intern : nil
       overflow = hash['overflow'] ? hash['overflow'].intern : nil
-      StructureItem.new(hash['name'], hash['bit_offset'], hash['bit_size'], data_type,
+      si = StructureItem.new(hash['name'], hash['bit_offset'], hash['bit_size'], data_type,
         endianness, hash['array_size'], overflow)
+      si.key = hash['key'] || hash['name']
+      si
     end
 
     def as_json(*a)
       hash = {}
       hash['name'] = self.name
+      hash['key'] = self.key
       hash['bit_offset'] = self.bit_offset
       hash['bit_size'] = self.bit_size
       hash['data_type'] = self.data_type

data/lib/openc3/script/storage.rb

@@ -17,6 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 
+require 'tempfile'
 require 'net/http'
 
 module OpenC3
@@ -34,7 +35,7 @@ module OpenC3
         OpenC3::Logger.info "Deleting #{delete_path}"
         response = $api_server.request('delete', endpoint, query: {bucket: 'config'}, scope: scope)
         if response.nil? || response.code != 200
-          raise "Failed to delete #{delete_path}. Note: #{scope}/targets is read-only."
+          raise "Failed to delete #{delete_path}"
         end
       rescue => error
         raise "Failed deleting #{path} due to #{error.message}"
@@ -48,7 +49,13 @@ module OpenC3
     # @param io_or_string [Io or String] IO object
     def put_target_file(path, io_or_string, scope: $openc3_scope)
       raise "Disallowed path modifier '..' found in #{path}" if path.include?('..')
+
       upload_path = "#{scope}/targets_modified/#{path}"
+
+      if ENV['OPENC3_LOCAL_MODE'] and $openc3_in_cluster
+        OpenC3::LocalMode.put_target_file(upload_path, io_or_string, scope: scope)
+      end
+
       endpoint = "/openc3-api/storage/upload/#{upload_path}"
       OpenC3::Logger.info "Writing #{upload_path}"
       result = _get_presigned_request(endpoint, scope: scope)
@@ -86,6 +93,17 @@ module OpenC3
       # Loop to allow redo when switching from modified to original
       loop do
         begin
+          if part == "targets_modified" and ENV['OPENC3_LOCAL_MODE']
+            local_file = OpenC3::LocalMode.open_local_file(path, scope: scope)
+            if local_file
+              file = Tempfile.new('target', binmode: true)
+              file.write(local_file.read)
+              local_file.close
+              file.rewind
+              return file if local_file
+            end
+          end
+
           return _get_storage_file("#{part}/#{path}", scope: scope)
         rescue => error
           if part == "targets_modified"