cosmos 5.0.2 → 5.0.3

data/lib/cosmos/packets/packet_item.rb

@@ -486,6 +486,63 @@ module Cosmos
       config
     end
 
+    def self.from_json(hash)
+      # Convert strings to symbols
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil
+      data_type = hash['data_type'] ? hash['data_type'].intern : nil
+      overflow = hash['overflow'] ? hash['overflow'].intern : nil
+      item = PacketItem.new(hash['name'], hash['bit_offset'], hash['bit_size'],
+        data_type, endianness, hash['array_size'], overflow)
+      item.description = hash['description']
+      item.id_value = hash['id_value']
+      item.default = hash['default']
+      item.range = (hash['minimum']..hash['maximum']) if hash['minimum'] && hash['maximum']
+      item.required = hash['required']
+      item.format_string = hash['format_string']
+      item.units = hash['units']
+      item.units_full = hash['units_full']
+      if hash['states']
+        item.states = {}
+        item.hazardous = {}
+        item.state_colors = {}
+        hash['states'].each do |state_name, state|
+          item.states[state_name] = state['value']
+          item.hazardous[state_name] = state['hazardous']
+          item.state_colors[state_name] = state['color'].to_sym if state['color']
+        end
+      end
+      # Recreate COSMOS built-in conversions
+      if hash['read_conversion']
+        begin
+          item.read_conversion = Cosmos::const_get(hash['read_conversion']['class']).new(*hash['read_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} read_conversion of #{hash['read_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+      if hash['write_conversion']
+        begin
+          item.write_conversion = Cosmos::const_get(hash['write_conversion']['class']).new(*hash['write_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} write_conversion of #{hash['write_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+
+      if hash['limits']
+        item.limits = PacketItemLimits.new
+        # Delete these keys so the only ones left are limits sets
+        item.limits.persistence_setting = hash['limits'].delete('persistence_setting')
+        item.limits.enabled = true if hash['limits'].delete('enabled')
+        values = {}
+        hash['limits'].each do |set, items|
+          values[set.to_sym] = [items['red_low'], items['yellow_low'], items['yellow_high'], items['red_high']]
+          values[set.to_sym].concat([items['green_low'], items['green_high']]) if items['green_low'] && items['green_high']
+        end
+        item.limits.values = values
+      end
+      item.meta = hash['meta']
+      item
+    end
+
     protected
 
     def parameter_config

data/lib/cosmos/packets/packet_item_limits.rb

@@ -132,7 +132,7 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def as_json
       hash = {}
       hash['values'] = self.values
       hash['enabled'] = self.enabled
@@ -146,5 +146,17 @@ module Cosmos
       hash['persistence_count'] = self.persistence_count
       hash
     end
+
+    def self.from_json(hash)
+      limits = PacketItemLimits.new
+      limits.values = hash['values'].transform_keys(&:to_sym) if hash['values']
+      limits.enabled = hash['enabled']
+      limits.state = hash['state'] ? hash['state'].to_sym : nil
+      # Can't recreate a LimitsResponse class
+      # limits.response = hash['response']
+      limits.persistence_setting = hash['persistence_setting'] if hash['persistence_setting']
+      limits.persistence_count = hash['persistence_count'] if hash['persistence_count']
+      limits
+    end
   end
-end # module Cosmos
+end

data/lib/cosmos/packets/parsers/packet_item_parser.rb

@@ -56,7 +56,7 @@ module Cosmos
       max_options = @usage.count("<")
       # The last two options (description and endianness) are optional
       @parser.verify_num_parameters(max_options - 2, max_options, @usage)
-      @parser.verify_parameters_underscores(1) # Item name is the 1st parameter
+      @parser.verify_parameter_naming(1) # Item name is the 1st parameter
     end
 
     def create_packet_item(packet, cmd_or_tlm)

data/lib/cosmos/packets/parsers/packet_parser.rb

@@ -72,7 +72,7 @@ module Cosmos
     def verify_parameters
       @usage = "#{@parser.keyword} <TARGET NAME> <PACKET NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DESCRIPTION (Optional)>"
       @parser.verify_num_parameters(3, 4, @usage)
-      @parser.verify_parameters_underscores(2) # Packet name is the 2nd parameter
+      @parser.verify_parameter_naming(2) # Packet name is the 2nd parameter
     end
 
     def create_command(target_name, commands, warnings)

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

@@ -293,7 +293,7 @@ module Cosmos
         xtce_recurse_element(element) do |block_element|
           if block_element.name == 'Term'
             exponent = Float(block_element['exponent']).to_i
-            @current_type.conversion ||= PolynomialConversion.new([])
+            @current_type.conversion ||= PolynomialConversion.new()
             @current_type.conversion.coeffs[exponent] = Float(block_element['coefficient'])
             @current_type.conversion.coeffs.each_with_index do |value, index|
               @current_type.conversion.coeffs[index] = 0.0 if value.nil?

data/lib/cosmos/packets/structure_item.rb

@@ -292,7 +292,16 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def self.from_json(hash)
+      # Convert strings to symbols
+      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,
+        endianness, hash['array_size'], overflow)
+    end
+
+    def as_json
       hash = {}
       hash['name'] = self.name
       hash['bit_offset'] = self.bit_offset

data/lib/cosmos/script/api_shared.rb

@@ -300,10 +300,10 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
-    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args, scope: scope, token: token)
       start_time = Time.now.sys
-      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
+      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       with_value_str = "with value == #{value} after waiting #{time} seconds"
@@ -321,8 +321,8 @@ module Cosmos
     end
 
     # @deprecated use wait_check with type: :RAW
-    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait for the value of a telmetry item to be within a tolerance of a value
@@ -334,7 +334,7 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW or :CONVERTED (default)
-    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       raise "Invalid type '#{type}' for wait_check_tolerance" unless %i(RAW CONVERTED).include?(type)
 
       target_name, packet_name, item_name, expected_value, tolerance, timeout, polling_rate = _wait_tolerance_process_args(args, scope: scope, token: token)
@@ -343,7 +343,7 @@ module Cosmos
       if value.is_a?(Array)
         expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance', scope: scope, token: token)
 
-        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
         time = Time.now.sys - start_time
 
         message = ""
@@ -388,8 +388,8 @@ module Cosmos
     end
 
     # @deprecated Use wait_check_tolerance with type: :RAW
-    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.  On a timeout, the script will pause.
@@ -397,12 +397,12 @@ module Cosmos
                               timeout,
                               polling_rate = DEFAULT_TLM_POLLING_RATE,
                               context = nil,
-                              scope: $cosmos_scope, token: $cosmos_token)
+                              scope: $cosmos_scope, token: $cosmos_token, &block)
       start_time = Time.now.sys
       success = cosmos_script_wait_implementation_expression(exp_to_eval,
                                                              timeout,
                                                              polling_rate,
-                                                             context, scope: scope, token: token)
+                                                             context, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       if success
         Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time} seconds"
@@ -691,15 +691,20 @@ module Cosmos
       return [target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate]
     end
 
-    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: $cosmos_scope, token: $cosmos_token)
+    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $cosmos_scope, token: $cosmos_token, &block)
       end_time = Time.now.sys + timeout
-      exp_to_eval = yield
 
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-        if eval(exp_to_eval)
-          return true, value
+        if not block.nil?
+          if block.call(value)
+            return true, value
+          end
+        else
+          if eval(exp_to_eval)
+            return true, value
+          end
         end
         break if Time.now.sys >= end_time
 
@@ -724,25 +729,25 @@ module Cosmos
     end
 
     # Wait for a converted telemetry item to pass a comparison
-    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "value " + comparison_to_eval
+    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      if comparison_to_eval
+        exp_to_eval = "value " + comparison_to_eval
+      else
+        exp_to_eval = nil
       end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
-      end
+    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
+    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
       statements = []
       array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
       exp_to_eval = statements.join(" && ")
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        exp_to_eval
-      end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.

data/lib/cosmos/script/commands.rb

@@ -112,13 +112,11 @@ module Cosmos
           target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args)
           _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         rescue HazardousError => e
-          ok_to_proceed = prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-          if ok_to_proceed
-            target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
-            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
-          else
-            retry unless prompt_for_script_abort()
-          end
+          # This opens a prompt at which point they can cancel and stop the script
+          # or say Yes and send the command. Thus we don't care about the return value.
+          prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
+          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         end
       end
     end

data/lib/cosmos/script/script.rb

@@ -129,58 +129,38 @@ module Cosmos
       message_box(string, *items, **options)
     end
 
-    def _file_dialog(message, directory, filter, select_files = true)
+    def _file_dialog(title, message, filter:)
       answer = ''
-      files = Dir["#{directory}/#{filter}"]
-      if select_files
-        files.select! { |f| !File.directory? f }
-      else
-        files.select! { |f| File.directory? f }
-      end
+      path = "./*"
+      path += filter if filter
+      files = Dir[path]
+      files.select! { |f| !File.directory? f }
       while answer.empty?
-        print message + "\n" + files.join("\n") + "\n<Type file name>:"
+        print "#{title}\n#{message}\n#{files.join("\n")}\n<Type file name>:"
         answer = gets
         answer.chomp!
       end
       return answer
     end
 
-    def save_file_dialog(directory, message = "Save File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_file_dialog(directory, message = "Open File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_files_dialog(directory, message = "Open File(s)", filter = "*")
-      _file_dialog(message, directory, filter)
+    def open_file_dialog(title, message = "Open File", filter:)
+      _file_dialog(title, message, filter)
     end
 
-    def open_directory_dialog(directory, message = "Open Directory")
-      _file_dialog(message, directory, "*", false)
+    def open_files_dialog(title, message = "Open File(s)", filter:)
+      _file_dialog(title, message, filter)
     end
 
     def prompt_for_hazardous(target_name, cmd_name, hazardous_description)
-      message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
-      message << "\n#{hazardous_description}\n" if hazardous_description
-      message << "Send? (y,n): "
-      print message
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        return true
-      else
-        return false
-      end
-    end
-
-    def prompt_for_script_abort
-      print "Stop running script? (y,n): "
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        exit
-      else
-        return false # Not aborted - Retry
+      loop do
+        message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
+        message << "\n#{hazardous_description}\n" if hazardous_description
+        message << "Send? (y): "
+        print message
+        answer = gets.chomp
+        if answer.downcase == 'y'
+          return true
+        end
       end
     end
 

data/lib/cosmos/script/storage.rb

@@ -23,137 +23,124 @@ module Cosmos
   module Script
     private
 
-    # Get a handle to access a target file
+    # Delete a file on a target
+    #
+    # @param [String] Path to a file in a target directory
+    def delete_target_file(path, scope: $cosmos_scope)
+      begin
+        # Only delete from the targets_modified
+        delete_path = "#{scope}/targets_modified/#{path}"
+        endpoint = "/cosmos-api/storage/delete/#{delete_path}"
+        Cosmos::Logger.info "Deleting #{delete_path}"
+        response = $api_server.request('delete', endpoint, query: {bucket: 'config'})
+        if response.nil? || response.code != 200
+          raise "Failed to delete #{delete_path}. Note: #{scope}/targets is read-only."
+        end
+      rescue => error
+        raise "Failed deleting #{path} due to #{error.message}"
+      end
+      nil
+    end
+
+    # Get a handle to write a target file
     #
     # @param path [String] Path to a file in a target directory
-    # @param original [Boolean] Whether to get the original or modified file
-    # @return [File|nil]
-    def get_target_file(path, original: false, scope: $cosmos_scope)
-      # Create Tempfile to store data
-      file = Tempfile.new('target', binmode: true)
+    # @param io_or_string [Io or String] IO object
+    def put_target_file(path, io_or_string, scope: $cosmos_scope)
+      raise "Disallowed path modifier '..' found in #{path}" if path.include?('..')
+      upload_path = "#{scope}/targets_modified/#{path}"
+      endpoint = "/cosmos-api/storage/upload/#{upload_path}"
+      Cosmos::Logger.info "Writing #{upload_path}"
+      result = _get_presigned_request(endpoint)
 
-      # Get presigned url
-      if original
-        part = "targets"
-      else
-        part = "targets_modified"
-      end
-      # Loop to allow redo
-      loop do
-        endpoint = "/cosmos-api/storage/download/#{scope}/#{part}/#{path}"
-        Cosmos::Logger.info "Reading #{scope}/#{part}/#{path}"
-        if $cosmos_in_cluster
-          response = $api_server.request('get', endpoint, query: {bucket: 'config', internal: true})
-        else
-          response = $api_server.request('get', endpoint, query: {bucket: 'config'})
-        end
-        if response.nil? || response.code != 201
-          Cosmos::Logger.error "Failed Get Presigned URL for #{scope}/#{part}/#{path}"
-          if part == "targets_modified"
-            part = "targets"
-            redo
+      # Try to put the file
+      success = false
+      begin
+        uri = _get_uri(result['url'])
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          request = Net::HTTP::Put.new(uri, {'Content-Length' => io_or_string.length.to_s})
+          if String === io_or_string
+            request.body = io_or_string
           else
-            raise "#{path} not found"
+            request.body_stream = io_or_string
+          end
+          result = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            http.request(request)
           end
+          return result
         end
-        result = JSON.parse(response.body)
+      rescue => error
+        raise "Failed to write #{upload_path}"
+      end
+      nil
+    end
 
-        # Try to get the file
+    # Get a handle to access a target file
+    #
+    # @param path [String] Path to a file in a target directory, e.g. "INST/procedures/test.rb"
+    # @param original [Boolean] Whether to get the original or modified file
+    # @return [File|nil]
+    def get_target_file(path, original: false, scope: $cosmos_scope)
+      part = "targets"
+      part += "_modified" unless original
+      # Loop to allow redo when switching from modified to original
+      loop do
         begin
-          if $cosmos_in_cluster
-            uri = URI.parse("http://cosmos-minio:9000" + result['url'])
-          else
-            uri = URI.parse($api_server.generate_url + result['url'])
-          end
-          Net::HTTP.start(uri.host, uri.port) do |http|
-            request = Net::HTTP::Get.new uri
-
-            http.request request do |response|
-              response.read_body do |chunk|
-                puts chunk.length
-                file.write chunk
-              end
-            end
-            file.rewind
-          end
-          return file
+          return _get_storage_file("#{part}/#{path}", scope: scope)
         rescue => error
-          Cosmos::Logger.info("#{scope}/#{part}/#{path} not found")
           if part == "targets_modified"
             part = "targets"
             redo
           else
-            raise "#{path} not found"
+            raise error
           end
         end
         break
       end
     end
 
-    # Get a handle to write a target file
-    #
-    # @param path [String] Path to a file in a target directory
-    # @param io_or_string [Io or String] IO object
-    def put_target_file(path, io_or_string, scope: $cosmos_scope)
-      # Get presigned url
-      part = "targets_modified"
-      begin
-        endpoint = "/cosmos-api/storage/upload/#{scope}/#{part}/#{path}"
-        Cosmos::Logger.info "Writing #{scope}/#{part}/#{path}"
-        if $cosmos_in_cluster
-          response = $api_server.request('get', endpoint, query: {bucket: 'config', internal: true})
-        else
-          response = $api_server.request('get', endpoint, query: {bucket: 'config'})
-        end
-        if response.nil? || response.code != 201
-          Cosmos::Logger.error "Failed Get Presigned URL for #{scope}/#{part}/#{path}"
-          return nil
-        end
-        result = JSON.parse(response.body)
+    # These are helper methods ... should not be used directly
 
-        # Try to put the file
-        success = false
-        begin
-          if $cosmos_in_cluster
-            uri = URI.parse("http://cosmos-minio:9000" + result['url'])
-          else
-            uri = URI.parse($api_server.generate_url + result['url'])
-          end
-          Net::HTTP.start(uri.host, uri.port) do |http|
-            request = Net::HTTP::Put.new(uri, {'Content-Length' => io_or_string.length.to_s})
-            if String === io_or_string
-              request.body = io_or_string
-            else
-              request.body_stream = io_or_string
-            end
-            result = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-              http.request(request)
-            end
-            return result
+    def _get_storage_file(path, scope: $cosmos_scope)
+      # Create Tempfile to store data
+      file = Tempfile.new('target', binmode: true)
+
+      endpoint = "/cosmos-api/storage/download/#{scope}/#{path}"
+      Cosmos::Logger.info "Reading #{scope}/#{path}"
+      result = _get_presigned_request(endpoint)
+
+      # Try to get the file
+      uri = _get_uri(result['url'])
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Get.new uri
+        http.request request do |response|
+          response.read_body do |chunk|
+            file.write chunk
           end
-        rescue => error
-          raise "Failed to write #{scope}/#{part}/#{path}"
         end
+        file.rewind
       end
-      nil
+      return file
     end
 
-    # Delete a file on a target
-    #
-    # @param [String] Path to a file in a target directory
-    def delete_target_file(path, scope: $cosmos_scope)
-      begin
-        # Only delete from the targets_modified
-        endpoint = "/cosmos-api/storage/delete/#{scope}/targets_modified/#{path}"
-        Cosmos::Logger.info "Deleting #{scope}/targets_modified/#{path}"
-        response = $api_server.request('delete', endpoint, query: {bucket: 'config'})
-        if response.nil? || response.code != 200
-          raise "Failed to delete #{scope}/targets_modified/#{path}"
-        end
-      rescue => error
-        raise "Failed deleting #{path} due to #{error.message}"
+    def _get_uri(url)
+      if $cosmos_in_cluster
+        uri = URI.parse("http://cosmos-minio:9000" + url)
+      else
+        uri = URI.parse($api_server.generate_url + url)
       end
-      nil
+    end
+
+    def _get_presigned_request(endpoint)
+      if $cosmos_in_cluster
+        response = $api_server.request('get', endpoint, query: { bucket: 'config', internal: true })
+      else
+        response = $api_server.request('get', endpoint, query: { bucket: 'config' })
+      end
+      if response.nil? || response.code != 201
+        raise "Failed to get presigned URL for #{endpoint}"
+      end
+      JSON.parse(response.body)
     end
   end
 end

data/lib/cosmos/tools/table_manager/table_item.rb

@@ -80,7 +80,7 @@ module Cosmos
     alias dup clone
 
     # Create a hash of this item's attributes
-    def to_hash
+    def as_json
       hash = super()
       hash['editable'] = self.editable
       hash['hidden'] = self.hidden

data/lib/cosmos/topics/command_decom_topic.rb

@@ -21,6 +21,10 @@ require 'cosmos/topics/topic'
 
 module Cosmos
   class CommandDecomTopic < Topic
+    def self.topics(scope:)
+      super(scope, 'DECOMCMD')
+    end
+
     def self.write_packet(packet, scope:)
       topic = "#{scope}__DECOMCMD__{#{packet.target_name}}__#{packet.packet_name}"
       msg_hash = { time: packet.received_time.to_nsec_from_epoch,

data/lib/cosmos/topics/telemetry_decom_topic.rb

@@ -21,6 +21,10 @@ require 'cosmos/topics/topic'
 
 module Cosmos
   class TelemetryDecomTopic < Topic
+    def self.topics(scope:)
+      super(scope, 'DECOM')
+    end
+
     def self.write_packet(packet, id: nil, scope:)
       # Need to build a JSON hash of the decommutated data
       # Support "downward typing"

data/lib/cosmos/topics/topic.rb

@@ -34,5 +34,15 @@ module Cosmos
         Store.xtrim(topic, maxlen)
       end
     end
+
+    def self.topics(scope, key)
+      topics = []
+      loop do
+        token, streams = Store.scan(0, :match => "#{scope}__#{key}__*", :count => 1000)
+        topics.concat(streams)
+        break if token == 0
+      end
+      topics
+    end
   end
 end