openc3 7.0.0.pre.rc3 → 7.0.1

data/lib/openc3/script/extract.rb

@@ -15,6 +15,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'json'
 require 'openc3/utilities/store'
 
 module OpenC3
@@ -154,22 +155,54 @@ module OpenC3
     end
 
     def extract_fields_from_check_text(text)
-      split_string = text.split
-      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 3
+      target_name, packet_name, item_name, comparison = text.split(nil, 4) # Ruby: second split arg is max number of resultant elements
+      raise "ERROR: Check improperly specified: #{text}" if item_name.nil?
 
-      target_name = split_string[0]
-      packet_name = split_string[1]
-      item_name = split_string[2]
-      comparison_to_eval = nil
-      return [target_name, packet_name, item_name, comparison_to_eval] if split_string.length == 3
-      raise "ERROR: Check improperly specified: #{text}" if split_string.length < 4
+      # comparison is either nil, the comparison string, or an empty string.
+      # We need it to not be an empty string.
+      comparison = nil if comparison&.length == 0
+
+      operator, _ = comparison&.split(nil, 2)
+      raise "ERROR: Use '==' instead of '=' in #{text}" if operator == "="
+
+      return [target_name, packet_name, item_name, comparison]
+    end
+
+    # Splits `check()` comparison expressions, e.g. "== 'foo bar'" becomes ["==", "foo bar"]
+    def extract_operator_and_operand_from_comparison(comparison)
+      valid_operators = ["==", "!=", ">=", "<=", ">", "<", "in"]
 
-      split_string = text.split(/ /) # Split on regex spaces to preserve spaces in comparison
-      index = split_string.rindex(item_name)
-      comparison_to_eval = split_string[(index + 1)..(split_string.length - 1)].join(" ")
-      raise "ERROR: Use '==' instead of '=': #{text}" if split_string[3] == '='
+      operator, operand = comparison.split(nil, 2) # Ruby: second split arg is max number of resultant elements
 
-      return [target_name, packet_name, item_name, comparison_to_eval]
+      if operand.nil?
+        # Don't allow operator without operand
+        raise "ERROR: Invalid comparison, must specify an operand: #{comparison}" if !operator.nil?
+        return [nil, nil]
+      end
+
+      raise "ERROR: Invalid operator: '#{operator}'" unless valid_operators.include?(operator)
+
+      # Handle string operand: remove surrounding double/single quotes
+      if operand.match?(/^(['"])(.*)\1$/m) # Starts with single or double quote, and ends with matching quote
+        operand = operand[1..-2]
+        return [operator, operand]
+      end
+
+      # Handle other operand types
+      if operand == "nil"
+        operand = nil
+      elsif operand == "false"
+        operand = false
+      elsif operand == "true"
+        operand = true
+      else
+        begin
+          operand = JSON.parse(operand)
+        rescue JSON::ParserError
+          raise "ERROR: Unable to parse operand: #{operand}"
+        end
+      end
+      return [operator, operand]
     end
   end
 end

data/lib/openc3/script/script.rb

@@ -47,6 +47,9 @@ $disconnect = false
 $openc3_scope = ENV['OPENC3_SCOPE'] || 'DEFAULT'
 $openc3_in_cluster = false
 
+saved_verbose = $VERBOSE
+$VERBOSE = false
+
 module OpenC3
   module Script
     private
@@ -177,6 +180,10 @@ module OpenC3
       message_box(string, *items, **options)
     end
 
+    def check_box(string, *items, **options)
+      message_box(string, *items, **options)
+    end
+
     def _file_dialog(title, message, filter:)
       answer = ''
       path = "./*"
@@ -199,6 +206,16 @@ module OpenC3
       _file_dialog(title, message, filter)
     end
 
+    def open_bucket_dialog(title, message = "Open Bucket File")
+      answer = ''
+      while answer.empty?
+        print "#{title}\n#{message}\n<Type bucket file path (e.g. BUCKET/path/to/file)>:"
+        answer = gets
+        answer.chomp!
+      end
+      return answer
+    end
+
     def prompt(string, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string}: "
       print "Details: #{details}\n" if details
@@ -363,3 +380,5 @@ module OpenC3
     end
   end
 end
+
+$VERBOSE = saved_verbose

data/lib/openc3/script/storage.rb

@@ -110,7 +110,7 @@ module OpenC3
           end
 
           return _get_storage_file("#{part}/#{path}", scope: scope)
-        rescue => e
+        rescue
           if part == "targets_modified"
             part = "targets"
             redo
@@ -141,13 +141,13 @@ module OpenC3
       return result['url']
     end
 
-    def _get_storage_file(path, scope: $openc3_scope)
+    def _get_storage_file(path, bucket: 'OPENC3_CONFIG_BUCKET', scope: $openc3_scope)
       # Create Tempfile to store data
       file = Tempfile.new('target', binmode: true)
       file.filename = path
 
       endpoint = "/openc3-api/storage/download/#{scope}/#{path}"
-      result = _get_presigned_request(endpoint, scope: scope)
+      result = _get_presigned_request(endpoint, bucket: bucket, scope: scope)
       puts "Reading #{scope}/#{path}"
 
       # Try to get the file
@@ -186,11 +186,11 @@ module OpenC3
       end
     end
 
-    def _get_presigned_request(endpoint, external: nil, scope: $openc3_scope)
+    def _get_presigned_request(endpoint, external: nil, bucket: 'OPENC3_CONFIG_BUCKET', scope: $openc3_scope)
       if external or !$openc3_in_cluster
-        response = $api_server.request('get', endpoint, query: { bucket: 'OPENC3_CONFIG_BUCKET' }, scope: scope)
+        response = $api_server.request('get', endpoint, query: { bucket: bucket }, scope: scope)
       else
-        response = $api_server.request('get', endpoint, query: { bucket: 'OPENC3_CONFIG_BUCKET', internal: true }, scope: scope)
+        response = $api_server.request('get', endpoint, query: { bucket: bucket, internal: true }, scope: scope)
       end
       if response.nil? || response.status != 201
         raise "Failed to get presigned URL for #{endpoint}"

data/lib/openc3/system/system.rb

@@ -81,22 +81,22 @@ module OpenC3
       # Nothing to do if there are no targets
       return if target_names.nil? or target_names.length == 0
       if @@instance.nil?
-        FileUtils.mkdir_p("#{base_dir}/targets")
+        targets_path = "#{base_dir}/_targets"
+        FileUtils.mkdir_p(targets_path)
         bucket = Bucket.getClient()
         target_names.each do |target_name|
           # Retrieve bucket/targets/target_name/<TARGET>_current.zip
-          zip_path = "#{base_dir}/targets/#{target_name}_current.zip"
+          zip_path = "#{targets_path}/#{target_name}_current.zip"
           FileUtils.mkdir_p(File.dirname(zip_path))
           bucket_key = "#{scope}/target_archives/#{target_name}/#{target_name}_current.zip"
           Logger.info("Retrieving #{bucket_key} from targets bucket")
           bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: zip_path)
-          targets_path = "#{base_dir}/targets"
-          FileUtils.mkdir_p(targets_path)
           Zip::File.open(zip_path) do |zip_file|
             zip_file.each do |entry|
               zip_file.extract(entry.name, destination_directory: targets_path)
             end
           end
+          FileUtils.rm(zip_path) if File.exist?(zip_path)
 
           # Now add any modifications in targets_modified/TARGET/cmd_tlm
           # This adds support for remembering dynamically created packets
@@ -106,13 +106,13 @@ module OpenC3
           _, files = bucket.list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: bucket_path)
           files.each do |file|
             bucket_key = File.join(bucket_path, file['name'])
-            local_path = "#{base_dir}/targets/#{target_name}/cmd_tlm/#{file['name']}"
+            local_path = "#{targets_path}/#{target_name}/cmd_tlm/#{file['name']}"
             bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: local_path)
           end
         end
 
         # Build System from targets
-        System.instance(target_names, "#{base_dir}/targets")
+        System.instance(target_names, targets_path)
       end
     end
 

data/lib/openc3/tools/cmd_tlm_server/interface_thread.rb

@@ -221,7 +221,6 @@ module OpenC3
           else
             Logger.error connect_error.formatted
             unless @connection_failed_messages.include?(connect_error.message)
-              OpenC3.write_exception_file(connect_error)
               @connection_failed_messages << connect_error.message
             end
           end
@@ -242,7 +241,6 @@ module OpenC3
           else
             Logger.error err.formatted
             unless @connection_lost_messages.include?(err.message)
-              OpenC3.write_exception_file(err)
               @connection_lost_messages << err.message
             end
           end

data/lib/openc3/top_level.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2022 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
@@ -101,6 +101,20 @@ module OpenC3
     end
   end
 
+  def self.sanitize_path(path)
+    return '' if path.nil?
+    # path is passed as a parameter thus we have to sanitize it or the code scanner detects:
+    # "Uncontrolled data used in path expression"
+    # This method is taken directly from the Rails source:
+    #   https://api.rubyonrails.org/v5.2/classes/ActiveStorage/Filename.html#method-i-sanitized
+    # NOTE: I removed the '/' character because we have to allow this in order to traverse the path
+    sanitized = path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;\t\r\n\\", "-").gsub('..', '-')
+    if sanitized != path
+      raise StorageError, "Invalid path: #{path}"
+    end
+    sanitized
+  end
+
   require 'openc3/utilities/logger'
 
   # Creates a marshal file by serializing the given obj
@@ -280,65 +294,6 @@ module OpenC3
     return log_file
   end
 
-  # Writes a log file with information about the current configuration
-  # including the Ruby version, OpenC3 version, whether you are on Windows, the
-  # OpenC3 path, and the Ruby path along with the exception that
-  # is passed in.
-  #
-  # @param [String] filename String to append to the exception log filename.
-  #   The filename will start with a date/time stamp.
-  # @param [String] log_dir By default this method will write to the OpenC3
-  #   default log directory. By setting this parameter you can override the
-  #   directory the log will be written to.
-  # @return [String|nil] The fully pathed log filename or nil if there was
-  #   an error creating the log file.
-  def self.write_exception_file(exception, filename = 'exception', log_dir = nil)
-    log_file = create_log_file(filename, log_dir) do |file|
-      file.puts "Exception:"
-      if exception
-        file.puts exception.formatted
-        file.puts
-      else
-        file.puts "No Exception Given"
-        file.puts caller.join("\n")
-        file.puts
-      end
-      file.puts "Caller Backtrace:"
-      file.puts caller().join("\n")
-      file.puts
-
-      file.puts "Ruby Version: ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE} patchlevel #{RUBY_PATCHLEVEL}) [#{RUBY_PLATFORM}]"
-      file.puts "Rubygems Version: #{Gem::VERSION}"
-      file.puts "OpenC3 Version: #{OpenC3::VERSION}"
-      file.puts "OpenC3::PATH: #{OpenC3::PATH}"
-      file.puts ""
-      file.puts "Environment:"
-      file.puts "RUBYOPT: #{ENV['RUBYOPT']}"
-      file.puts "RUBYLIB: #{ENV['RUBYLIB']}"
-      file.puts "GEM_PATH: #{ENV['GEM_PATH']}"
-      file.puts "GEMRC: #{ENV['GEMRC']}"
-      file.puts "RI_DEVKIT: #{ENV['RI_DEVKIT']}"
-      file.puts "GEM_HOME: #{ENV['GEM_HOME']}"
-      file.puts "PYTHONUSERBASE: #{ENV['PYTHONUSERBASE']}"
-      file.puts "PATH: #{ENV['PATH']}"
-      file.puts ""
-      file.puts "Ruby Path:\n  #{$:.join("\n  ")}\n\n"
-      file.puts "Gems:"
-      Gem.loaded_specs.values.map { |x| file.puts "#{x.name} #{x.version} #{x.platform}" }
-      file.puts ""
-      file.puts "All Threads Backtraces:"
-      Thread.list.each do |thread|
-        file.puts thread.backtrace.join("\n")
-        file.puts
-      end
-      file.puts ""
-      file.puts ""
-    ensure
-      file.close
-    end
-    return log_file
-  end
-
   # Writes a log file with information about unexpected output
   #
   # @param [String] text The unexpected output text
@@ -367,7 +322,6 @@ module OpenC3
   def self.handle_fatal_exception(error, _try_gui = true)
     unless SystemExit === error or SignalException === error
       $openc3_fatal_exception = error
-      self.write_exception_file(error)
       Logger.fatal "Fatal Exception! Exiting..."
       Logger.fatal error.formatted
       if $stdout != STDOUT
@@ -392,7 +346,6 @@ module OpenC3
   # @param try_gui [Boolean] Whether to try and create a GUI exception popup
   def self.handle_critical_exception(error, _try_gui = true)
     Logger.error "Critical Exception! #{error.formatted}"
-    self.write_exception_file(error)
   end
 
   # Creates a Ruby Thread to run the given block. Rescues any exceptions and
@@ -412,7 +365,6 @@ module OpenC3
         Logger.error e.formatted
         retry_count += 1
         if retry_count <= retry_attempts
-          self.write_exception_file(e)
           retry
         end
         handle_fatal_exception(e)

data/lib/openc3/topics/decom_interface_topic.rb

@@ -37,7 +37,7 @@ module OpenC3
             if msg_hash["result"] == "SUCCESS"
               return msg_hash
             else
-              raise msg_hash["message"]
+              raise msg_hash["result"]
             end
           end
         end
@@ -45,14 +45,29 @@ module OpenC3
       raise "Timeout of #{timeout}s waiting for cmd ack. Does target '#{target_name}' exist?"
     end
 
-    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope:)
+    def self.inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, timeout: 5, scope:)
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['packet_name'] = packet_name.to_s.upcase
       data['item_hash'] = item_hash
       data['type'] = type
-      Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
+      ack_topic = "{#{scope}__ACKCMD}TARGET__#{target_name}"
+      Topic.update_topic_offsets([ack_topic])
+      decom_id = Topic.write_topic("#{scope}__DECOMINTERFACE__{#{target_name}}",
           { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      time = Time.now
+      while (Time.now - time) < timeout
+        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+          if msg_hash["id"] == decom_id
+            if msg_hash["result"] == "SUCCESS"
+              return
+            else
+              raise msg_hash["result"]
+            end
+          end
+        end
+      end
+      raise "Timeout of #{timeout}s waiting for cmd ack. Does target '#{target_name}' exist?"
     end
 
     def self.get_tlm_buffer(target_name, packet_name, timeout: 5, scope:)
@@ -77,7 +92,7 @@ module OpenC3
               end
               return msg_hash
             else
-              raise msg_hash["message"]
+              raise msg_hash["result"]
             end
           end
         end

data/lib/openc3/topics/interface_topic.rb

@@ -111,13 +111,32 @@ module OpenC3
       Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'protocol_cmd' => JSON.generate(data, allow_nan: true) }, '*', 100)
     end
 
-    def self.inject_tlm(interface_name, target_name, packet_name, item_hash = nil, type: :CONVERTED, scope:)
+    def self.inject_tlm(interface_name, target_name, packet_name, item_hash = nil, type: :CONVERTED, timeout: nil, scope:)
+      interface_name = interface_name.upcase
+
+      timeout = COMMAND_ACK_TIMEOUT_S unless timeout
+      ack_topic = "{#{scope}__ACKCMD}INTERFACE__#{interface_name}"
+      Topic.update_topic_offsets([ack_topic])
+
       data = {}
       data['target_name'] = target_name.to_s.upcase
       data['packet_name'] = packet_name.to_s.upcase
       data['item_hash'] = item_hash
       data['type'] = type
-      Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}INTERFACE__#{interface_name}", { 'inject_tlm' => JSON.generate(data, allow_nan: true) }, '*', 100)
+      time = Time.now
+      while (Time.now - time) < timeout
+        Topic.read_topics([ack_topic]) do |_topic, _msg_id, msg_hash, _redis|
+          if msg_hash["id"] == cmd_id
+            if msg_hash["result"] == "SUCCESS"
+              return
+            else
+              raise msg_hash["result"]
+            end
+          end
+        end
+      end
+      raise "Timeout of #{timeout}s waiting for cmd ack"
     end
 
     def self.interface_target_enable(interface_name, target_name, cmd_only: false, tlm_only: false, scope:)

data/lib/openc3/topics/limits_event_topic.rb

@@ -53,7 +53,7 @@ module OpenC3
         limits['red_high'] = event[:red_high]
         limits['green_low'] = event[:green_low] if event[:green_low] && event[:green_high]
         limits['green_high'] = event[:green_high] if event[:green_low] && event[:green_high]
-        limits_settings[event[:limits_set]] = limits
+        limits_settings[event[:limits_set].to_s] = limits
         limits_settings['persistence_setting'] = event[:persistence] if event[:persistence]
         limits_settings['enabled'] = event[:enabled] if not event[:enabled].nil?
         Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))

data/lib/openc3/utilities/bucket_utilities.rb

@@ -117,7 +117,9 @@ module OpenC3
       # Allow caching for files that have a filename versioning strategy
       has_version_number = /(-|_|\.)\d+(-|_|\.)\d+(-|_|\.)\d+\./.match(filename)
       has_content_hash = /[\.-][a-f0-9]{20}\./.match(filename)
-      return nil if has_version_number or has_content_hash
+      # Font files are immutable assets deployed with plugins and safe to cache
+      is_font = /\.(woff2?|eot|ttf|otf)$/.match(filename)
+      return nil if has_version_number or has_content_hash or is_font
       return 'no-store'
     end
 

data/lib/openc3/utilities/cli_generator.rb

@@ -197,6 +197,8 @@ module OpenC3
       target_lib_filename = "#{target_name.downcase}.#{@@language}"
       target_class = target_lib_filename.filename_to_class_name
       target_object = target_name.downcase
+      target_class.inspect # Remove unused variable warning. These are used in binding for generator
+      target_object.inspect # Remove unused variable warning. These are used in binding for generator
 
       process_template("#{TEMPLATES_DIR}/target", binding) do |filename|
         # Rename the template TARGET to our actual target named after the plugin
@@ -292,6 +294,7 @@ RUBY
       end
       microservice_filename = "#{microservice_name.downcase}.#{@@language}"
       microservice_class = microservice_filename.filename_to_class_name
+      microservice_class.inspect # Remove unused variable warning. These are used in binding for generator
 
       process_template("#{TEMPLATES_DIR}/microservice", binding) do |filename|
         # Rename the template MICROSERVICE to our actual microservice name
@@ -547,6 +550,7 @@ RUBY
       conversion_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_CONVERSION"
       conversion_basename = "#{conversion_name.downcase}.#{@@language}"
       conversion_class = conversion_basename.filename_to_class_name
+      conversion_class.inspect # Remove unused variable warning. These are used in binding for generator
       conversion_filename = "targets/#{target_name}/lib/#{conversion_basename}"
       if File.exist?(conversion_filename)
         abort("Conversion #{conversion_filename} already exists!")
@@ -601,6 +605,7 @@ RUBY
       processor_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_PROCESSOR"
       processor_basename = "#{processor_name.downcase}.#{@@language}"
       processor_class = processor_basename.filename_to_class_name
+      processor_class.inspect # Remove unused variable warning. These are used in binding for generator
       processor_filename = "targets/#{target_name}/lib/#{processor_basename}"
       if File.exist?(processor_filename)
         abort("Processor #{processor_filename} already exists!")
@@ -656,6 +661,7 @@ RUBY
       response_basename = "#{response_name.downcase}.#{@@language}"
       response_filename = "targets/#{target_name}/lib/#{response_basename}"
       response_class = response_basename.filename_to_class_name
+      response_class.inspect # Remove unused variable warning. These are used in binding for generator
       if File.exist?(response_filename)
         abort("response #{response_filename} already exists!")
       end
@@ -709,6 +715,7 @@ RUBY
       validator_name = "#{args[2].upcase.gsub(/_+|-+/, '_')}_COMMAND_VALIDATOR"
       validator_basename = "#{validator_name.downcase}.#{@@language}"
       validator_class = validator_basename.filename_to_class_name
+      validator_class.inspect # Remove unused variable warning. These are used in binding for generator
       validator_filename = "targets/#{target_name}/lib/#{validator_basename}"
       if File.exist?(validator_filename)
         abort("Command validator #{validator_filename} already exists!")

data/lib/openc3/utilities/cmd_log.rb

@@ -11,7 +11,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'openc3/packets/packet'
+# require 'openc3/packets/packet' # Circular require
 
 module OpenC3
   module CmdLog