openc3 5.9.0 → 5.10.0

data/lib/openc3/models/target_model.rb

@@ -44,6 +44,8 @@ module OpenC3
   class TargetModel < Model
     PRIMARY_KEY = 'openc3_targets'
     VALID_TYPES = %i(CMD TLM)
+    ITEM_MAP_CACHE_TIMEOUT = 10.0
+    @@item_map_cache = {}
 
     attr_accessor :folder_name
     attr_accessor :requires
@@ -208,7 +210,7 @@ module OpenC3
     # @return [Array>Hash>] All packet hashes under the target_name
     def self.packets(target_name, type: :TLM, scope:)
       raise "Unknown type #{type} for #{target_name}" unless VALID_TYPES.include?(type)
-      raise "Target '#{target_name}' does not exist" unless get(name: target_name, scope: scope)
+      raise "Target '#{target_name}' does not exist for scope: #{scope}" unless get(name: target_name, scope: scope)
 
       result = []
       packets = Store.hgetall("#{scope}__openc3#{type.to_s.downcase}__#{target_name}")
@@ -268,6 +270,36 @@ module OpenC3
       end
     end
 
+    def self.get_item_to_packet_map(target_name, scope:)
+      cache_time, item_map = @@item_map_cache[target_name]
+      return item_map if item_map and (Time.now - cache_time) < ITEM_MAP_CACHE_TIMEOUT
+      item_map_key = "#{scope}__#{target_name}__item_to_packet_map"
+      target_name = target_name.upcase
+      json_data = Store.get(item_map_key)
+      if json_data
+        item_map = JSON.parse(json_data, :allow_nan => true, :create_additions => true)
+      else
+        item_map = build_item_to_packet_map(target_name, scope: scope)
+        Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
+      end
+      @@item_map_cache[target_name] = [Time.now, item_map]
+      return item_map
+    end
+
+    def self.build_item_to_packet_map(target_name, scope:)
+      item_map = {}
+      packets = packets(target_name, scope: scope)
+      packets.each do |packet|
+        items = packet['items']
+        items.each do |item|
+          item_name = item['name']
+          item_map[item_name] ||= []
+          item_map[item_name] << packet['packet_name']
+        end
+      end
+      return item_map
+    end
+
     # Called by the PluginModel to allow this class to validate it's top-level keyword: "TARGET"
     def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
       case keyword
@@ -601,8 +633,14 @@ module OpenC3
           model.destroy if model
         end
       end
+      # Delete item_map
+      item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
+      Store.del(item_map_key)
+      @@item_map_cache[@name] = nil
 
       ConfigTopic.write({ kind: 'deleted', type: 'target', name: @name, plugin: @plugin }, scope: @scope)
+    rescue Exception => error
+      Logger.error("Error undeploying target model #{@name} in scope #{@scope} due to #{error}")
     end
 
     ##################################################
@@ -731,6 +769,12 @@ module OpenC3
       end
       Store.hmset("#{@scope}__limits_sets", *sets)
 
+      # Create item_map
+      item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
+      item_map = self.class.build_item_to_packet_map(@name, scope: @scope)
+      Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
+      @@item_map_cache[@name] = [Time.now, item_map]
+
       return system
     end
 

data/lib/openc3/models/tool_model.rb

@@ -247,6 +247,8 @@ module OpenC3
           ConfigTopic.write({ kind: 'deleted', type: 'tool', name: @folder_name, plugin: @plugin }, scope: @scope)
         end
       end
+    rescue Exception => error
+      Logger.error("Error undeploying tool model #{@name} in scope #{@scope} due to #{error}")
     end
 
     ##################################################

data/lib/openc3/models/widget_model.rb

@@ -139,6 +139,8 @@ module OpenC3
       bucket = Bucket.getClient()
       bucket.delete_object(bucket: ENV['OPENC3_TOOLS_BUCKET'], key: @bucket_key)
       bucket.delete_object(bucket: ENV['OPENC3_TOOLS_BUCKET'], key: @bucket_key + '.map')
+    rescue Exception => error
+      Logger.error("Error undeploying widget model #{@name} in scope #{@scope} due to #{error}")
     end
   end
 end

data/lib/openc3/packets/structure.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/packets/binary_accessor'
@@ -518,7 +518,7 @@ module OpenC3
     # Take the structure mutex to ensure the buffer does not change while you perform activities
     def synchronize
       setup_mutex()
-      @mutex.synchronize { || yield }
+      @mutex.synchronize { || yield } #|
     end
 
     # Take the structure mutex to ensure the buffer does not change while you perform activities

data/lib/openc3/packets/structure_item.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/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
@@ -135,14 +135,7 @@ module OpenC3
     end
 
     def bit_offset=(bit_offset)
-      if 0.class == Integer
-        # Ruby version >= 2.4.0
-        raise ArgumentError, "#{@name}: bit_offset must be an Integer" unless Integer === bit_offset
-      else
-        # Ruby version < 2.4.0
-        raise ArgumentError, "#{@name}: bit_offset must be a Fixnum" unless Fixnum === bit_offset
-      end
-
+      raise ArgumentError, "#{@name}: bit_offset must be an Integer" unless Integer === bit_offset
       byte_aligned = ((bit_offset % 8) == 0)
       if (@data_type == :FLOAT or @data_type == :STRING or @data_type == :BLOCK) and !byte_aligned
         raise ArgumentError, "#{@name}: bit_offset for :FLOAT, :STRING, and :BLOCK items must be byte aligned"
@@ -156,18 +149,14 @@ module OpenC3
     end
 
     def bit_size=(bit_size)
-      if 0.class == Integer
-        # Ruby version >=  2.4.0
-        raise ArgumentError, "#{name}: bit_size must be an Integer" unless Integer === bit_size
-      else
-        # Ruby version < 2.4.0
-        raise ArgumentError, "#{name}: bit_size must be a Fixnum" unless Fixnum === bit_size
-      end
+      raise ArgumentError, "#{@name}: bit_size must be an Integer" unless Integer === bit_size
       byte_multiple = ((bit_size % 8) == 0)
       if bit_size <= 0 and (@data_type == :INT or @data_type == :UINT or @data_type == :FLOAT)
         raise ArgumentError, "#{@name}: bit_size cannot be negative or zero for :INT, :UINT, and :FLOAT items: #{bit_size}"
       end
-      raise ArgumentError, "#{@name}: bit_size for STRING and BLOCK items must be byte multiples" if (@data_type == :STRING or @data_type == :BLOCK) and !byte_multiple
+      if (@data_type == :STRING or @data_type == :BLOCK) and !byte_multiple
+        raise ArgumentError, "#{@name}: bit_size for STRING and BLOCK items must be byte multiples"
+      end
       if @data_type == :FLOAT and bit_size != 32 and bit_size != 64
         raise ArgumentError, "#{@name}: bit_size for FLOAT items must be 32 or 64. Given: #{bit_size}"
       end
@@ -195,13 +184,7 @@ module OpenC3
 
     def array_size=(array_size)
       if array_size
-        if 0.class == Integer
-          # Ruby version >=  2.4.0
-          raise ArgumentError, "#{@name}: array_size must be an Integer" unless Integer === array_size
-        else
-          # Ruby version < 2.4.0
-          raise ArgumentError, "#{@name}: array_size must be a Fixnum" unless Fixnum === array_size
-        end
+        raise ArgumentError, "#{@name}: array_size must be an Integer" unless Integer === array_size
         raise ArgumentError, "#{@name}: array_size must be a multiple of bit_size" unless @bit_size == 0 or (array_size % @bit_size == 0) or array_size < 0
         raise ArgumentError, "#{@name}: bit_size cannot be negative or zero for array items" if @bit_size <= 0
       end

data/lib/openc3/script/api_shared.rb

@@ -44,17 +44,14 @@ module OpenC3
       _check(*args, scope: scope) { |tgt, pkt, item| tlm(tgt, pkt, item, type: type, scope: scope, token: token) }
     end
 
-    # @deprecated Use check with type: :RAW
     def check_raw(*args, scope: $openc3_scope, token: $openc3_token)
       check(*args, type: :RAW, scope: scope, token: token)
     end
 
-    # @deprecated Use check with type: :FORMATTED
     def check_formatted(*args, scope: $openc3_scope, token: $openc3_token)
       check(*args, type: :FORMATTED, scope: scope, token: token)
     end
 
-    # @deprecated Use check with type: :WITH_UNITS
     def check_with_units(*args, scope: $openc3_scope, token: $openc3_token)
       check(*args, type: :WITH_UNITS, scope: scope, token: token)
     end
@@ -90,10 +87,10 @@ module OpenC3
       raise "Invalid type '#{type}' for check_tolerance" unless %i(RAW CONVERTED).include?(type)
 
       target_name, packet_name, item_name, expected_value, tolerance =
-        _check_tolerance_process_args(args, scope: scope, token: token)
+        _check_tolerance_process_args(args)
       value = tlm(target_name, packet_name, item_name, type: type, scope: scope, token: token)
       if value.is_a?(Array)
-        expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'check_tolerance', scope: scope, token: token)
+        expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'check_tolerance')
 
         message = ""
         all_checks_ok = true
@@ -166,23 +163,23 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     def wait(*args, type: :CONVERTED, quiet: false, scope: $openc3_scope, token: $openc3_token)
-      time = nil
+      time_diff = nil
 
       case args.length
       # wait() # indefinitely until they click Go
       when 0
         start_time = Time.now.sys
         openc3_script_sleep()
-        time = Time.now.sys - start_time
-        Logger.info("WAIT: Indefinite for actual time of #{time} seconds") unless quiet
+        time_diff = Time.now.sys - start_time
+        Logger.info("WAIT: Indefinite for actual time of #{time_diff} seconds") unless quiet
 
       # wait(5) # absolute wait time
       when 1
         if args[0].kind_of? Numeric
           start_time = Time.now.sys
           openc3_script_sleep(args[0])
-          time = Time.now.sys - start_time
-          Logger.info("WAIT: #{args[0]} seconds with actual time of #{time} seconds") unless quiet
+          time_diff = Time.now.sys - start_time
+          Logger.info("WAIT: #{args[0]} seconds with actual time of #{time_diff} seconds") unless quiet
         else
           raise "Non-numeric wait time specified"
         end
@@ -216,7 +213,7 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to wait()"
       end
-      time
+      time_diff
     end
 
     # @deprecated Use wait with type: :RAW
@@ -235,11 +232,11 @@ module OpenC3
     def wait_tolerance(*args, type: :CONVERTED, quiet: false, scope: $openc3_scope, token: $openc3_token)
       raise "Invalid type '#{type}' for wait_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)
+      target_name, packet_name, item_name, expected_value, tolerance, timeout, polling_rate = _wait_tolerance_process_args(args)
       start_time = Time.now.sys
       value = tlm(target_name, packet_name, item_name, type: type, scope: scope, token: token)
       if value.is_a?(Array)
-        expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_tolerance', scope: scope, token: token)
+        expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_tolerance')
 
         success, value = openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time = Time.now.sys - start_time
@@ -285,13 +282,13 @@ module OpenC3
     def wait_expression(exp_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, context = nil, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
       success = openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
-      time = Time.now.sys - start_time
+      time_diff = Time.now.sys - start_time
       if success
-        Logger.info "WAIT: #{exp_to_eval} is TRUE after waiting #{time} seconds" unless quiet
+        Logger.info "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
       else
-        Logger.warn "WAIT: #{exp_to_eval} is FALSE after waiting #{time} seconds" unless quiet
+        Logger.warn "WAIT: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds" unless quiet
       end
-      time
+      time_diff
     end
 
     # Wait for the converted value of a telmetry item against a condition or for a timeout
@@ -304,13 +301,13 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     def wait_check(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token, &block)
-      target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args, scope: scope, token: token)
+      target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args)
       start_time = Time.now.sys
       success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
-      time = Time.now.sys - start_time
+      time_diff = 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"
+      with_value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
         Logger.info "#{check_str} success #{with_value_str}"
       else
@@ -321,7 +318,7 @@ module OpenC3
           raise CheckError, message
         end
       end
-      time
+      time_diff
     end
 
     # @deprecated use wait_check with type: :RAW
@@ -341,20 +338,20 @@ module OpenC3
     def wait_check_tolerance(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_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)
+      target_name, packet_name, item_name, expected_value, tolerance, timeout, polling_rate = _wait_tolerance_process_args(args)
       start_time = Time.now.sys
       value = tlm(target_name, packet_name, item_name, type: type, scope: scope, token: token)
       if value.is_a?(Array)
-        expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance', scope: scope, token: token)
+        expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance')
 
         success, value = openc3_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
+        time_diff = Time.now.sys - start_time
 
         message = ""
         value.size.times do |i|
           range = (expected_value[i] - tolerance[i]..expected_value[i] + tolerance[i])
           check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}[#{i}]"
-          range_str = "range #{range.first} to #{range.last} with value == #{value[i]} after waiting #{time} seconds"
+          range_str = "range #{range.first} to #{range.last} with value == #{value[i]} after waiting #{time_diff} seconds"
           if range.include?(value[i])
             message << "#{check_str} was within #{range_str}\n"
           else
@@ -373,10 +370,10 @@ module OpenC3
         end
       else
         success, value = openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
-        time = Time.now.sys - start_time
+        time_diff = Time.now.sys - start_time
         range = (expected_value - tolerance)..(expected_value + tolerance)
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
-        range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time} seconds"
+        range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time_diff} seconds"
         if success
           Logger.info "#{check_str} was within #{range_str}"
         else
@@ -388,7 +385,7 @@ module OpenC3
           end
         end
       end
-      time
+      time_diff
     end
 
     # @deprecated Use wait_check_tolerance with type: :RAW
@@ -407,18 +404,18 @@ module OpenC3
                                                              timeout,
                                                              polling_rate,
                                                              context, scope: scope, token: token, &block)
-      time = Time.now.sys - start_time
+      time_diff = Time.now.sys - start_time
       if success
-        Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time} seconds"
+        Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds"
       else
-        message = "CHECK: #{exp_to_eval} is FALSE after waiting #{time} seconds"
+        message = "CHECK: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds"
         if $disconnect
           Logger.error message
         else
           raise CheckError, message
         end
       end
-      time
+      time_diff
     end
     alias wait_expression_stop_on_timeout wait_check_expression
 
@@ -483,7 +480,7 @@ module OpenC3
     ###########################################################################
     # Scripts Outside of ScriptRunner Support
     # ScriptRunner overrides these methods to work in the OpenC3 cluster
-    # They are only here to allow for scripts to have a change to work
+    # They are only here to allow for scripts to have a chance to work
     # unaltered outside of the cluster
     ###########################################################################
 
@@ -534,17 +531,17 @@ module OpenC3
     # caller to allow the return of the value through various telemetry calls.
     # This method should not be called directly by application code.
     def _check(*args, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name, comparison_to_eval = _check_process_args(args, 'check', scope: scope, token: token)
+      target_name, packet_name, item_name, comparison_to_eval = _check_process_args(args, 'check')
 
       value = yield(target_name, packet_name, item_name)
       if comparison_to_eval
-        check_eval(target_name, packet_name, item_name, comparison_to_eval, value, scope: scope)
+        _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
       else
         Logger.info "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
       end
     end
 
-    def _check_process_args(args, method_name, scope: $openc3_scope, token: $openc3_token)
+    def _check_process_args(args, method_name)
       case args.length
       when 1
         target_name, packet_name, item_name, comparison_to_eval = extract_fields_from_check_text(args[0])
@@ -557,10 +554,11 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      raise "Invalid comparison to non-ascii value" unless comparison_to_eval.is_printable?
       return [target_name, packet_name, item_name, comparison_to_eval]
     end
 
-    def _check_tolerance_process_args(args, scope: $openc3_scope, token: $openc3_token)
+    def _check_tolerance_process_args(args)
       case args.length
       when 3
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])
@@ -612,11 +610,11 @@ module OpenC3
                                                          token: token)
       # If the packet has not been received the value could be nil
       value = 0 unless value
-      time = Time.now.sys - start_time
+      time_diff = Time.now.sys - start_time
       if success
-        Logger.info "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time} seconds" unless quiet
+        Logger.info "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time_diff} seconds" unless quiet
       else
-        message = "#{type}: #{target_name.upcase} #{packet_name.upcase} expected to be received #{num_packets} times but only received #{value - initial_count} times after waiting #{time} seconds"
+        message = "#{type}: #{target_name.upcase} #{packet_name.upcase} expected to be received #{num_packets} times but only received #{value - initial_count} times after waiting #{time_diff} seconds"
         if check
           if $disconnect
             Logger.error message
@@ -627,16 +625,16 @@ module OpenC3
           Logger.warn message unless quiet
         end
       end
-      time
+      time_diff
     end
 
     def _execute_wait(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
       success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
-      time = Time.now.sys - start_time
+      time_diff = Time.now.sys - start_time
       wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
-      value_str = "with value == #{value} after waiting #{time} seconds"
+      value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
         Logger.info "#{wait_str} success #{value_str}" unless quiet
       else
@@ -644,7 +642,7 @@ module OpenC3
       end
     end
 
-    def _wait_tolerance_process_args(args, scope: $openc3_scope, token: $openc3_token)
+    def _wait_tolerance_process_args(args)
       case args.length
       when 4, 5
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])
@@ -686,7 +684,7 @@ module OpenC3
     # When testing an array with a tolerance, the expected value and tolerance
     # can both be supplied as either an array or a single value.  If a single
     # value is passed in, that value will be used for all array elements.
-    def array_tolerance_process_args(array_size, expected_value, tolerance, method_name, scope: $openc3_scope, token: $openc3_token)
+    def _array_tolerance_process_args(array_size, expected_value, tolerance, method_name)
       if expected_value.is_a?(Array)
         if array_size != expected_value.size
           raise "ERROR: Invalid array size for expected_value passed to #{method_name}()"
@@ -704,7 +702,7 @@ module OpenC3
       return [expected_value, tolerance]
     end
 
-    def _wait_check_process_args(args, scope: $openc3_scope, token: $openc3_token)
+    def _wait_check_process_args(args)
       case args.length
       when 2, 3
         target_name, packet_name, item_name, comparison_to_eval = extract_fields_from_check_text(args[0])
@@ -849,8 +847,7 @@ module OpenC3
       end
     end
 
-    def check_eval(target_name, packet_name, item_name, comparison_to_eval, value, scope: $openc3_scope, token: $openc3_token)
-      raise "Invalid comparison to non-ascii value" unless comparison_to_eval.is_printable?
+    def _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
       string = "value " + comparison_to_eval
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       # Show user the check against a quoted string

data/lib/openc3/script/web_socket_api.rb

@@ -405,9 +405,9 @@ end
 # # Environment variables are already set inside of our containers
 # # START OUTSIDE OF DOCKER ONLY
 # $openc3_scope = 'DEFAULT'
-# ENV['OPENC3_API_HOSTNAME'] = 'localhost'
+# ENV['OPENC3_API_HOSTNAME'] = '127.0.0.1'
 # ENV['OPENC3_API_PORT'] = '2900'
-# ENV['OPENC3_SCRIPT_API_HOSTNAME'] = 'localhost'
+# ENV['OPENC3_SCRIPT_API_HOSTNAME'] = '127.0.0.1'
 # ENV['OPENC3_SCRIPT_API_PORT'] = '2900'
 # ENV['OPENC3_API_PASSWORD'] = 'password'
 # # END OUTSIDE OF DOCKER ONLY

data/lib/openc3/system/target.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/config/config_parser'
@@ -226,8 +226,8 @@ module OpenC3
     # Process the target's configuration file if it exists
     def process_target_config_file
       @filename = File.join(@dir, 'target.txt')
-      if File.exist?(filename)
-        process_file(filename)
+      if File.exist?(@filename)
+        process_file(@filename)
       else
         @filename = nil
       end

data/lib/openc3/top_level.rb

@@ -43,7 +43,7 @@ class HazardousError < StandardError
   attr_accessor :formatted # formatted command for use in resending original
 
   def to_s
-    string = "#{target_name} #{cmd_name} with #{cmd_params} is Hazardous"
+    string = "#{target_name} #{cmd_name} with #{cmd_params} is Hazardous "
     string << "due to '#{hazardous_description}'" if hazardous_description
     # Pass along the original formatted command so it can be resent
     string << ".\n#{formatted}"

data/lib/openc3/utilities/authentication.rb

@@ -98,7 +98,6 @@ module OpenC3
       rescue OpenC3AuthenticationError
         return nil
       end
-      return nil
     end
 
     private

data/lib/openc3/utilities/aws_bucket.rb

@@ -213,10 +213,14 @@ module OpenC3
 
     def delete_object(bucket:, key:)
       @client.delete_object(bucket: bucket, key: key)
+    rescue Exception
+      Logger.error("Error deleting object bucket: #{bucket}, key: #{key}")
     end
 
     def delete_objects(bucket:, keys:)
       @client.delete_objects(bucket: bucket, delete: { objects: keys.map {|key| { key: key } } })
+    rescue Exception
+      Logger.error("Error deleting objects bucket: #{bucket}, keys: #{keys}")
     end
 
     def presigned_request(bucket:, key:, method:, internal: true)

data/lib/openc3/utilities/local_mode.rb

@@ -431,7 +431,7 @@ module OpenC3
             # Parse just to ensure we have valid JSON
             JSON.parse(data, :allow_nan => true, :create_additions => true)
             # Only save if the parse was successful
-            ToolConfigModel.save_config(parts[-2], File.basename(config), data, scope: scope, local_mode: false)
+            ToolConfigModel.save_config(parts[-2], File.basename(config, '.json'), data, scope: scope, local_mode: false)
           rescue JSON::ParserError => error
             puts "Unable to initialize tool config due to #{error.message}"
           end

data/lib/openc3/utilities/store_autoload.rb

@@ -196,12 +196,12 @@ module OpenC3
     #   store.trim_topic('MANGO__TOPIC', 1000, approximate: 'true', limit: 0)
     #
     # @param topic  [String]  the stream key
-    # @param minid  [Integer] mid id length of entries to trim
+    # @param minid  [Integer] Id to throw away data up to
     # @param approximate [Boolean] whether to add `~` modifier of maxlen or not
-    # @param limit  [Boolean] whether to add `~` modifier of maxlen or not
+    # @param limit  [Boolean] number of items to return from the call
     #
     # @return [Integer] the number of entries actually deleted
-    def trim_topic(topic, minid, approximate = 'true', limit: 0)
+    def trim_topic(topic, minid, approximate = true, limit: 0)
       @redis_pool.with do |redis|
         return redis.xtrim_minid(topic, minid, approximate: approximate, limit: limit)
       end
@@ -218,8 +218,8 @@ module OpenC3
 end
 
 class Redis
-  def xtrim_minid(key, minid, approximate: 'true', limit: nil)
-    args = [:xtrim, key, :MINID, (approximate ? '~' : nil), minid].compact
+  def xtrim_minid(key, minid, approximate: true, limit: nil)
+    args = [:xtrim, key, :MINID, (approximate ? '~' : '='), minid]
     args.concat([:LIMIT, limit]) if limit
     send_command(args)
   end

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '5.9.0'
+OPENC3_VERSION = '5.10.0'
 module OpenC3
   module Version
     MAJOR = '5'
-    MINOR = '9'
+    MINOR = '10'
     PATCH = '0'
     OTHER = ''
-    BUILD = '7ad48e4189eb35c8a08051cc9856d0bd8be27f60'
+    BUILD = '926e6a3798993710a67729b9599c5a295b210152'
   end
-  VERSION = '5.9.0'
-  GEM_VERSION = '5.9.0'
+  VERSION = '5.10.0'
+  GEM_VERSION = '5.10.0'
 end

data/templates/tool_angular/package.json

@@ -1,6 +1,6 @@
 {
   "name": "<%= tool_name %>",
-  "version": "5.9.0",
+  "version": "5.10.0",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",
@@ -22,7 +22,7 @@
     "@angular/platform-browser": "^16.1.3",
     "@angular/platform-browser-dynamic": "^16.1.3",
     "@angular/router": "^16.1.3",
-    "@openc3/tool-common": "5.9.0",
+    "@openc3/tool-common": "5.10.0",
     "rxjs": "~7.8.0",
     "single-spa": ">=5.9.5",
     "single-spa-angular": "^8.1.0",

data/templates/tool_react/package.json

@@ -45,7 +45,7 @@
     "@emotion/react": "^11.11.1",
     "@emotion/styled": "^11.11.0",
     "@mui/material": "^5.13.6",
-    "@openc3/tool-common": "5.9.0",
+    "@openc3/tool-common": "5.10.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "single-spa-react": "^5.1.1"