openc3 5.5.0.pre.beta0 → 5.5.1

data/lib/openc3/models/plugin_model.rb

@@ -44,7 +44,7 @@ module OpenC3
   class PluginModel < Model
     PRIMARY_KEY = 'openc3_plugins'
     # Reserved VARIABLE names. See local_mode.rb: update_local_plugin()
-    RESERVED_VARIABLE_NAMES = ['target_name', 'microservice_name']
+    RESERVED_VARIABLE_NAMES = ['target_name', 'microservice_name', 'scope']
 
     attr_accessor :variables
     attr_accessor :plugin_txt_lines
@@ -72,7 +72,7 @@ module OpenC3
       temp_dir = Dir.mktmpdir
       tf = nil
       begin
-        if File.exists?(gem_file_path)
+        if File.exist?(gem_file_path)
           # Load gem to internal gem server
           OpenC3::GemModel.put(gem_file_path, gem_install: false, scope: scope) unless validate_only
         else
@@ -122,7 +122,6 @@ module OpenC3
             if existing_variables && existing_variables.key?(variable_name)
               variables[variable_name] = existing_variables[variable_name]
             end
-            # Ignore everything else during phase 1
           end
         end
 
@@ -162,14 +161,21 @@ module OpenC3
         gem_path = File.join(temp_dir, "gem")
         FileUtils.mkdir_p(gem_path)
         pkg = Gem::Package.new(gem_file_path)
-        needs_dependencies = pkg.spec.runtime_dependencies.length > 0
         pkg.extract_files(gem_path)
         Dir[File.join(gem_path, '**/screens/*.txt')].each do |filename|
           if File.basename(filename) != File.basename(filename).downcase
-            raise "Invalid screen name: #{filename}. Screen names must be lowercase."
+            raise "Invalid screen filename: #{filename}. Screen filenames must be lowercase."
           end
         end
+        needs_dependencies = pkg.spec.runtime_dependencies.length > 0
         needs_dependencies = true if Dir.exist?(File.join(gem_path, 'lib'))
+        # If needs_dependencies hasn't already been set we need to scan the plugin.txt
+        # to see if they've explicitly set the NEEDS_DEPENDENCIES keyword
+        unless needs_dependencies
+          if plugin_hash['plugin_txt_lines'].join("\n").include?('NEEDS_DEPENDENCIES')
+            needs_dependencies = true
+          end
+        end
         if needs_dependencies
           plugin_model.needs_dependencies = true
           plugin_model.update unless validate_only
@@ -192,13 +198,15 @@ module OpenC3
           tf.close
           plugin_txt_path = tf.path
           variables = plugin_hash['variables']
+          variables ||= {}
+          variables['scope'] = scope
           if File.exist?(plugin_txt_path)
             parser = OpenC3::ConfigParser.new("https://openc3.com")
 
             current_model = nil
             parser.parse_file(plugin_txt_path, false, true, true, variables) do |keyword, params|
               case keyword
-              when 'VARIABLE'
+              when 'VARIABLE', 'NEEDS_DEPENDENCIES'
                 # Ignore during phase 2
               when 'TARGET', 'INTERFACE', 'ROUTER', 'MICROSERVICE', 'TOOL', 'WIDGET'
                 if current_model
@@ -206,12 +214,13 @@ module OpenC3
                   current_model.deploy(gem_path, variables, validate_only: validate_only)
                   current_model = nil
                 end
-                current_model = OpenC3.const_get((keyword.capitalize + 'Model').intern).handle_config(parser, keyword, params, plugin: plugin_model.name, needs_dependencies: needs_dependencies, scope: scope)
+                current_model = OpenC3.const_get((keyword.capitalize + 'Model').intern).handle_config(parser,
+                  keyword, params, plugin: plugin_model.name, needs_dependencies: needs_dependencies, scope: scope)
               else
                 if current_model
                   current_model.handle_config(parser, keyword, params)
                 else
-                  raise "Invalid keyword #{keyword} in plugin.txt"
+                  raise "Invalid keyword '#{keyword}' in plugin.txt"
                 end
               end
             end

data/lib/openc3/models/timeline_model.rb

@@ -91,7 +91,7 @@ module OpenC3
       if color.nil?
         color = '#%06x' % (rand * 0xffffff)
       end
-      valid_color = color =~ /[0-9,a-f,A-F]{6}/
+      valid_color = color =~ /[0-9a-fA-F]{6}/
       if valid_color.nil?
         raise RuntimeError.new "invalid color but in hex format. #FF0000"
       end

data/lib/openc3/models/trigger_group_model.rb

@@ -92,7 +92,7 @@ module OpenC3
       if color.nil?
         color = '#%06x' % (rand * 0xffffff)
       end
-      valid_color = color =~ /[0-9,a-f,A-F]{6}/
+      valid_color = color =~ /[0-9a-fA-F]{6}/
       if valid_color.nil?
         raise TriggerGroupInputError.new "invalid color must be in hex format. #FF0000"
       end

data/lib/openc3/operators/microservice_operator.rb

@@ -60,8 +60,8 @@ module OpenC3
       # Setup secrets for microservice
       secrets = microservice_config["secrets"]
       if secrets
-        secrets.each do |type, secret_name, env_name_or_path|
-          secret_value = @secrets.get(secret_name, scope: scope)
+        secrets.each do |type, secret_name, env_name_or_path, secret_store|
+          secret_value = @secrets.get(secret_name, secret_store: secret_store, scope: scope)
           if secret_value
             case type
             when 'ENV'

data/lib/openc3/packets/packet_item.rb

@@ -80,7 +80,7 @@ module OpenC3
 
     # @return [Hash] Whether or not messages should be printed for this state.
     #   Given as STATE_NAME => true / false.
-    attr_accessor :messages_disabled
+    attr_reader :messages_disabled
 
     # Colors associated with states
     # @return [Hash] State colors given as STATE_NAME => COLOR

data/lib/openc3/script/storage.rb

@@ -77,7 +77,7 @@ module OpenC3
           else
             request.body_stream = io_or_string
           end
-          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
             http.request(request) do |response|
               response.value() # Raises an HTTP error if the response is not 2xx (success)
               return response
@@ -157,17 +157,17 @@ module OpenC3
       if $openc3_in_cluster
         case ENV['OPENC3_CLOUD']
         when 'local'
-          uri = URI.parse("http://openc3-minio:9000" + url)
+          URI.parse("http://openc3-minio:9000" + url)
         when 'aws'
-          uri = URI.parse("https://s3.#{ENV['AWS_REGION']}.amazonaws.com" + url)
+          URI.parse("https://s3.#{ENV['AWS_REGION']}.amazonaws.com" + url)
         when 'gcp'
-          uri = URI.parse("https://storage.googleapis.com" + url)
+          URI.parse("https://storage.googleapis.com" + url)
         # when 'azure'
         else
           raise "Unknown cloud #{ENV['OPENC3_CLOUD']}"
         end
       else
-        uri = URI.parse($api_server.generate_url + url)
+        URI.parse($api_server.generate_url + url)
       end
     end
 

data/lib/openc3/streams/web_socket_client_stream.rb

@@ -51,7 +51,6 @@ module OpenC3
       @frame = ::WebSocket::Frame::Incoming::Client.new
       @handshaked = false
       @write_socket.write(@handshake.to_s)
-      start_time = Time.now
       read() # This should wait for the handshake
       return true
     end

data/lib/openc3/tools/table_manager/table_manager_core.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3'
@@ -148,7 +148,6 @@ module OpenC3
         }
         col = 0
         row = 0
-        num_cols = table.num_columns
         table.sorted_items.each_with_index do |item, index|
           next if item.hidden
           if table.num_columns == 1

data/lib/openc3/utilities/aws_bucket.rb

@@ -111,7 +111,12 @@ module OpenC3
       token = nil
       result = []
       while true
-        resp = @client.list_objects_v2(bucket: bucket, prefix: prefix, max_keys: max_request)
+        resp = @client.list_objects_v2({
+          bucket: bucket,
+          max_keys: max_request,
+          prefix: prefix,
+          continuation_token: token
+        })
         result.concat(resp.contents)
         break if result.length >= max_total
         break unless resp.is_truncated
@@ -119,12 +124,12 @@ module OpenC3
       end
       # Array of objects with key and size methods
       result
-    rescue Aws::S3::Errors::NoSuchBucket => error
+    rescue Aws::S3::Errors::NoSuchBucket
       raise NotFound, "Bucket '#{bucket}' does not exist."
     end
 
     # Lists the files under a specified path
-    def list_files(bucket:, path:, only_directories: false)
+    def list_files(bucket:, path:, only_directories: false, include_head: false)
       # Trailing slash is important in AWS S3 when listing files
       # See https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Types/ListObjectsV2Output.html#common_prefixes-instance_method
       if path[-1] != '/'
@@ -158,6 +163,9 @@ module OpenC3
             item['name'] = aws_item.key.split('/')[-1]
             item['modified'] = aws_item.last_modified
             item['size'] = aws_item.size
+            if include_head
+              item['head'] = head_object(bucket: bucket, key: aws_item.key)
+            end
             files << item
           end
           result = [dirs, files]
@@ -166,10 +174,20 @@ module OpenC3
         token = resp.next_continuation_token
       end
       result
-    rescue Aws::S3::Errors::NoSuchBucket => error
+    rescue Aws::S3::Errors::NoSuchBucket
       raise NotFound, "Bucket '#{bucket}' does not exist."
     end
 
+    # get metadata for a specific object
+    def head_object(bucket:, key:)
+      head = @client.head_object({
+        bucket: bucket,
+        key: key
+      })
+    rescue Aws::S3::Errors::NotFound => error
+      raise NotFound, "Object: #{bucket}/#{key}"
+    end
+
     # put_object fires off the request to store but does not confirm
     def put_object(bucket:, key:, body:, content_type: nil, cache_control: nil, metadata: nil)
       @client.put_object(bucket: bucket, key: key, body: body,

data/lib/openc3/utilities/bucket_file_cache.rb

@@ -57,10 +57,10 @@ class BucketFile
     cmd_or_tlm = path_split[2].to_s.upcase
     target_name = path_split[3].to_s.upcase
     if stream_mode == 'RAW'
-      type = (@cmd_or_tlm == 'CMD') ? 'COMMAND' : 'TELEMETRY'
+      type = (cmd_or_tlm == 'CMD') ? 'COMMAND' : 'TELEMETRY'
     else
       if stream_mode == 'DECOM'
-        type = (@cmd_or_tlm == 'CMD') ? 'DECOMCMD' : 'DECOM'
+        type = (cmd_or_tlm == 'CMD') ? 'DECOMCMD' : 'DECOM'
       else
         type = stream_mode # REDUCED_MINUTE, REDUCED_HOUR, or REDUCED_DAY
       end
@@ -156,6 +156,7 @@ class BucketFileCache
     @current_disk_usage = 0
     @queued_bucket_files = []
     @bucket_file_hash = {}
+    bucket_file = nil
 
     @thread = Thread.new do
       client = OpenC3::Bucket.getClient()

data/lib/openc3/utilities/bucket_utilities.rb

@@ -162,7 +162,7 @@ module OpenC3
 
     def self.get_file_times(bucket_path)
       basename = File.basename(bucket_path)
-      file_start_timestamp, file_end_timestamp, other = basename.split("__")
+      file_start_timestamp, file_end_timestamp, _ = basename.split("__")
       file_start_time = DateTime.strptime(file_start_timestamp, FILE_TIMESTAMP_FORMAT).to_time
       file_end_time = DateTime.strptime(file_end_timestamp, FILE_TIMESTAMP_FORMAT).to_time
       return file_start_time, file_end_time

data/lib/openc3/utilities/cli_generator.rb

@@ -0,0 +1,210 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 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.
+
+module OpenC3
+  class CliGenerator
+    GENERATORS = %w(plugin target microservice conversion limits_response)
+    TEMPLATES_DIR = "#{File.dirname(__FILE__)}/../../../templates"
+
+    # Called by openc3cli with ARGV[1..-1]
+    def self.generate(args)
+      unless GENERATORS.include?(args[0])
+        abort("Unknown generator '#{args[0]}'. Valid generators: #{GENERATORS.join(', ')}")
+      end
+      check_args(args)
+      send("generate_#{args[0]}", args)
+    end
+
+    def self.check_args(args)
+      args.each do |arg|
+        if arg =~ /\s/
+          abort("#{args[0].capitalize} arguments can not have spaces!")
+        end
+      end
+      # All generators except 'plugin' must be within an existing plugin
+      if args[0] != 'plugin' and Dir.glob("*.gemspec").empty?
+        abort("No gemspec file detected. #{args[0].capitalize} generator should be run within an existing plugin.")
+      end
+    end
+
+    def self.process_template(template_dir, the_binding)
+      Dir.glob("#{template_dir}/**/*").each do |file|
+        base_name = file.sub("#{template_dir}/", '')
+        yield base_name
+        if File.directory?(file)
+          FileUtils.mkdir(base_name)
+          next
+        end
+        output = ERB.new(File.read(file), trim_mode: "-").result(the_binding)
+        File.open(base_name, 'w') do |file|
+          file.write output
+        end
+      end
+    end
+
+    def self.generate_plugin(args)
+      if args.length != 2
+        abort("Usage: cli generate #{args[0]} <NAME>")
+      end
+
+      # Create the local variables
+      plugin = args[1].downcase.gsub(/_+|-+/, '-')
+      plugin_name = "openc3-cosmos-#{plugin}"
+      if File.exist?(plugin_name)
+        abort("Plugin #{plugin_name} already exists!")
+      end
+      FileUtils.mkdir(plugin_name)
+      Dir.chdir(plugin_name) # Change to the plugin path to make copying easier
+
+      process_template("#{TEMPLATES_DIR}/plugin", binding) do |filename|
+        filename.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
+      end
+
+      puts "Plugin #{plugin_name} successfully generated!"
+      return plugin_name
+    end
+
+    def self.generate_target(args)
+      if args.length != 2
+        abort("Usage: cli generate #{args[0]} <NAME>")
+      end
+
+      # Create the local variables
+      target_name = args[1].upcase.gsub(/_+|-+/, '_')
+      target_path = "targets/#{target_name}"
+      if File.exist?(target_path)
+        abort("Target #{target_path} already exists!")
+      end
+      target_lib_filename = "#{target_name.downcase}.rb"
+      target_class = target_lib_filename.filename_to_class_name
+      target_object = target_name.downcase
+
+      process_template("#{TEMPLATES_DIR}/target", binding) do |filename|
+        # Rename the template TARGET to our actual target named after the plugin
+        filename.sub!("targets/TARGET", "targets/#{target_name}")
+        filename.sub!("target.rb", target_lib_filename)
+      end
+
+      # Add this target to plugin.txt
+      File.open("plugin.txt", 'a') do |file|
+        file.puts <<~DOC
+
+          VARIABLE #{target_name.downcase}_target_name #{target_name}
+
+          TARGET #{target_name} <%= #{target_name.downcase}_target_name %>
+          INTERFACE <%= #{target_name.downcase}_target_name %>_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
+            MAP_TARGET <%= #{target_name.downcase}_target_name %>
+        DOC
+      end
+
+      puts "Target #{target_name} successfully generated!"
+      return target_name
+    end
+
+    def self.generate_microservice(args)
+      if args.length != 2
+        abort("Usage: cli generate #{args[0]} <NAME>")
+      end
+
+      # Create the local variables
+      microservice_name = args[1].upcase.gsub(/_+|-+/, '_')
+      microservice_path = "microservices/#{microservice_name}"
+      if File.exist?(microservice_path)
+        abort("Microservice #{microservice_path} already exists!")
+      end
+      microservice_filename = "#{microservice_name.downcase}.rb"
+      microservice_class = microservice_filename.filename_to_class_name
+
+      process_template("#{TEMPLATES_DIR}/microservice", binding) do |filename|
+        # Rename the template MICROSERVICE to our actual microservice name
+        filename.sub!("microservices/TEMPLATE", "microservices/#{microservice_name}")
+        filename.sub!("microservice.rb", microservice_filename)
+      end
+
+      # Add this microservice to plugin.txt
+      File.open("plugin.txt", 'a') do |file|
+        file.puts <<~DOC
+
+          MICROSERVICE #{microservice_name} #{microservice_name.downcase.gsub('_','-')}-microservice
+            CMD ruby #{microservice_name.downcase}.rb
+        DOC
+      end
+
+      puts "Microservice #{microservice_name} successfully generated!"
+      return microservice_name
+    end
+
+    def self.generate_conversion(args)
+      if args.length != 3
+        abort("Usage: cli generate conversion <TARGET> <NAME>")
+      end
+
+      # Create the local variables
+      target_name = args[1].upcase
+      unless File.exist?("targets/#{target_name}")
+        abort("Target '#{target_name}' does not exist! Conversions must be created for existing targets.")
+      end
+      conversion_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_CONVERSION"
+      conversion_path = "targets/#{target_name}/lib/"
+      conversion_basename = "#{conversion_name.downcase}.rb"
+      conversion_class = conversion_basename.filename_to_class_name
+      conversion_filename = "targets/#{target_name}/lib/#{conversion_basename}"
+      if File.exist?(conversion_filename)
+        abort("Conversion #{conversion_filename} already exists!")
+      end
+
+      process_template("#{TEMPLATES_DIR}/conversion", binding) do |filename|
+        filename.sub!("conversion.rb", conversion_filename)
+      end
+
+      puts "Conversion #{conversion_filename} successfully generated!"
+      puts "To use the conversion add the following to a telemetry item:"
+      puts "  READ_CONVERSION #{conversion_basename}"
+      return conversion_name
+    end
+
+    def self.generate_limits_response(args)
+      if args.length != 3
+        abort("Usage: cli generate limits_response <TARGET> <NAME>")
+      end
+
+      # Create the local variables
+      target_name = args[1].upcase
+      unless File.exist?("targets/#{target_name}")
+        abort("Target '#{target_name}' does not exist! Limits responses must be created for existing targets.")
+      end
+      response_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_LIMITS_RESPONSE"
+      response_path = "targets/#{target_name}/lib/"
+      response_basename = "#{response_name.downcase}.rb"
+      response_class = response_basename.filename_to_class_name
+      response_filename = "targets/#{target_name}/lib/#{response_basename}"
+      if File.exist?(response_filename)
+        abort("response #{response_filename} already exists!")
+      end
+
+      process_template("#{TEMPLATES_DIR}/limits_response", binding) do |filename|
+        filename.sub!("response.rb", response_filename)
+      end
+
+      puts "Limits response #{response_filename} successfully generated!"
+      puts "To use the limits response add the following to a telemetry item:"
+      puts "  LIMITS_RESPONSE #{response_basename}"
+      return response_name
+    end
+  end
+end

data/lib/openc3/utilities/local_mode.rb

@@ -275,13 +275,13 @@ module OpenC3
       return if DEFAULT_PLUGINS.include?(gem_name)
       puts "Updating local plugin files: #{full_folder_path}"
       FileUtils.mkdir_p(full_folder_path)
-      gems, plugin_instance = scan_plugin_dir(full_folder_path)
+      gems, _ = scan_plugin_dir(full_folder_path)
       gems.each do |gem|
         File.delete(gem)
       end
       temp_dir = Dir.mktmpdir
       begin
-        unless File.exists?(plugin_file_path)
+        unless File.exist?(plugin_file_path)
           plugin_file_path = OpenC3::GemModel.get(plugin_file_path)
         end
         File.open(File.join(full_folder_path, File.basename(plugin_file_path)), 'wb') do |file|

data/lib/openc3/utilities/redis_secrets.rb

@@ -21,11 +21,11 @@ require 'openc3/utilities/secrets'
 
 module OpenC3
   class RedisSecrets < Secrets
-    def keys(scope:)
+    def keys(secret_store: nil, scope:)
       SecretModel.names(scope: scope)
     end
 
-    def get(key, scope:)
+    def get(key, secret_store: nil, scope:)
       data = SecretModel.get(name: key, scope: scope)
       if data
         return data['value']
@@ -34,11 +34,11 @@ module OpenC3
       end
     end
 
-    def set(key, value, scope:)
+    def set(key, value, secret_store: nil, scope:)
       SecretModel.set( {name: key, value: value.to_s }, scope: scope)
     end
 
-    def delete(key, scope:)
+    def delete(key, secret_store: nil, scope:)
       model = SecretModel.get_model(name: key, scope: scope)
       model.destroy if model
     end

data/lib/openc3/utilities/secrets.rb

@@ -31,24 +31,24 @@ module OpenC3
       klass.new
     end
 
-    def keys(scope:)
+    def keys(secret_store: nil, scope:)
       raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
     end
 
-    def get(key, scope:)
+    def get(key, secret_store: nil, scope:)
       return @local_secrets[key]
     end
 
-    def set(key, value, scope:)
+    def set(key, value, secret_store: nil, scope:)
       raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
     end
 
-    def delete(key, scope:)
+    def delete(key, secret_store: nil, scope:)
       raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
     end
 
     def setup(secrets)
-      secrets.each do |type, key, data|
+      secrets.each do |type, key, data, secret_store|
         case type
         when 'ENV'
           @local_secrets[key] = ENV[data]

data/lib/openc3/utilities/target_file.rb

@@ -26,41 +26,19 @@ module OpenC3
     # Matches ScriptRunner.vue const TEMP_FOLDER
     TEMP_FOLDER = '__TEMP__'
 
-    def self.all(scope, path_matchers, include_temp: false)
-      result = []
-      modified = []
-      temp = []
+    def self.all(scope, path_matchers, target: nil, include_temp: false)
+      target = target.upcase if target
 
       bucket = Bucket.getClient()
-      resp = bucket.list_objects(
-        bucket: ENV['OPENC3_CONFIG_BUCKET'],
-        prefix: "#{scope}/targets",
-      )
-      resp.each do |object|
-        split_key = object.key.split('/')
-        # DEFAULT/targets_modified/__TEMP__/YYYY_MM_DD_HH_MM_SS_mmm_temp.rb
-        if split_key[2] == TEMP_FOLDER
-          temp << split_key[2..-1].join('/') if include_temp
-          next
-        end
-
-        if path_matchers
-          found = false
-          path_matchers.each do |path|
-            if split_key.include?(path)
-              found = true
-              break
-            end
-          end
-          next unless found
-        end
-        result_no_scope_or_target_folder = split_key[2..-1].join('/')
-        if object.key.include?("#{scope}/targets_modified")
-          modified << result_no_scope_or_target_folder
-        else
-          result << result_no_scope_or_target_folder
-        end
+      if target
+        prefix = "#{scope}/targets/#{target}/"
+        modified_prefix = "#{scope}/targets_modified/#{target}/"
+      else
+        prefix = "#{scope}/targets/"
+        modified_prefix = "#{scope}/targets_modified/"
       end
+      result, _ = remote_target_files(bucket_client: bucket, prefix: prefix, include_temp: false, path_matchers: path_matchers)
+      modified, temp = remote_target_files(bucket_client: bucket, prefix: modified_prefix, include_temp: include_temp, path_matchers: path_matchers)
 
       # Add in local targets_modified if present
       if ENV['OPENC3_LOCAL_MODE']
@@ -172,5 +150,38 @@ module OpenC3
       )
       true
     end
+
+    # protected
+
+    def self.remote_target_files(bucket_client:, prefix:, include_temp: false, path_matchers: nil)
+      result = []
+      temp = []
+      resp = bucket_client.list_objects(
+        bucket: ENV['OPENC3_CONFIG_BUCKET'],
+        prefix: prefix,
+      )
+      resp.each do |object|
+        split_key = object.key.split('/')
+        # DEFAULT/targets_modified/__TEMP__/YYYY_MM_DD_HH_MM_SS_mmm_temp.rb
+        if split_key[2] == TEMP_FOLDER
+          temp << split_key[2..-1].join('/') if include_temp
+          next
+        end
+
+        if path_matchers
+          found = false
+          path_matchers.each do |path|
+            if split_key.include?(path)
+              found = true
+              break
+            end
+          end
+          next unless found
+        end
+        result_no_scope_or_target_folder = split_key[2..-1].join('/')
+        result << result_no_scope_or_target_folder
+      end
+      return result, temp
+    end
   end
 end

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '5.5.0-beta0'
+OPENC3_VERSION = '5.5.1'
 module OpenC3
   module Version
     MAJOR = '5'
     MINOR = '5'
-    PATCH = '0'
-    OTHER = 'pre.beta0'
-    BUILD = 'abab088dbe97761fca351752b3396f1c05dd852b'
+    PATCH = '1'
+    OTHER = ''
+    BUILD = 'a1e84e1850e06f2c01726e03372e2872137b3852'
   end
-  VERSION = '5.5.0-beta0'
-  GEM_VERSION = '5.5.0.pre.beta0'
+  VERSION = '5.5.1'
+  GEM_VERSION = '5.5.1'
 end