openc3 7.1.1 → 7.2.1

data/lib/openc3/script/limits.rb

@@ -20,7 +20,7 @@ module OpenC3
     private
 
     # Define all the modification methods such that we can disconnect them
-    %i(enable_limits disable_limits set_limits enable_limits_group disable_limits_group set_limits_set).each do |method_name|
+    %i(enable_limits disable_limits set_limits set_state_color enable_limits_group disable_limits_group set_limits_set delete_limits_set).each do |method_name|
       define_method(method_name) do |*args, **kw_args, &block|
         kw_args[:scope] = $openc3_scope unless kw_args[:scope]
         if $disconnect

data/lib/openc3/script/suite.rb

@@ -287,7 +287,7 @@ module OpenC3
       # Find all the script methods
       methods = []
       self.instance_methods.each do |method_name|
-        if /^test|^script|op_/.match?(method_name.to_s)
+        if /^test_|^script_|^op_/.match?(method_name.to_s)
           methods << method_name.to_s
         end
       end

data/lib/openc3/script/suite_runner.rb

@@ -26,6 +26,11 @@ module OpenC3
   end
 
   class SuiteRunner
+    # Default suite_runner options shared by all callers (e.g. openc3cli) so
+    # the values stay consistent in one place.
+    DEFAULT_METHOD = 'start'
+    DEFAULT_OPTIONS = ['continueAfterError'].freeze
+
     @@suites = []
     @@settings = {}
     @@suite_results = nil
@@ -42,17 +47,46 @@ module OpenC3
       @@suite_results
     end
 
+    # Validate the suite_runner option combinations that don't require the
+    # built suites. Shared by all callers (the running script via execute and
+    # openc3cli when constructing options) so the contract lives in one place.
+    # Suite/Group existence is checked in execute since it needs @@suites.
+    def self.validate_options(group: nil, script: nil)
+      raise ArgumentError, "Script #{script} requires a Group" if script and not group
+    end
+
+    # Build the canonical, validated suite_runner hash from raw values,
+    # applying defaults. Shared by openc3cli (constructing from CLI flags) and
+    # the running script (normalizing a received hash before dispatch) so the
+    # hash shape, defaults, and validation live in one place.
+    def self.build_options(suite:, group: nil, script: nil, method: nil, options: nil)
+      validate_options(group: group, script: script)
+      suite_runner = { 'suite' => suite }
+      if group
+        suite_runner['group'] = group
+        suite_runner['script'] = script if script
+      end
+      # A script always runs via start, matching the GUI
+      suite_runner['method'] = script ? DEFAULT_METHOD : (method || DEFAULT_METHOD)
+      suite_runner['options'] = options || DEFAULT_OPTIONS.dup
+      suite_runner
+    end
+
     def self.execute(result_string, suite_class, group_class = nil, script = nil)
       @@suite_results = SuiteResults.new
-      @@suites.each do |suite|
-        if suite.class == suite_class
-          @@suite_results.start(result_string, suite_class, group_class, script, @@settings)
-          loop do
-            yield(suite)
-            break if not @@settings['Loop'] or (ScriptStatus.instance.fail_count > 0 and @@settings['Break Loop On Error'])
-          end
-          break
-        end
+      # Surface invalid suite / group / option combinations rather than
+      # silently running nothing or failing with an opaque nil error. An
+      # invalid script method raises later in Group#run_method.
+      validate_options(group: group_class, script: script)
+      suite = @@suites.find { |s| s.class == suite_class }
+      raise ArgumentError, "Suite #{suite_class} not found" unless suite
+      if group_class and not suite.scripts.key?(group_class)
+        raise ArgumentError, "Group #{group_class} not found in Suite #{suite_class}"
+      end
+      @@suite_results.start(result_string, suite_class, group_class, script, @@settings)
+      loop do
+        yield(suite)
+        break if not @@settings['Loop'] or (ScriptStatus.instance.fail_count > 0 and @@settings['Break Loop On Error'])
       end
     end
 

data/lib/openc3/script/web_socket_api.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
@@ -91,6 +91,10 @@ module OpenC3
     # Will subscribe to the channel based on @identifier
     def subscribe
       unless @subscribed
+        # Token is part of the identifier so it surfaces as params[:token] in
+        # ApplicationCable::Channel#authenticate_subscription! — ActionCable
+        # ignores `data` on `subscribe` commands.
+        @identifier['token'] = @authentication.token(include_bearer: false)
         json_hash = {}
         json_hash['command'] = 'subscribe'
         json_hash['identifier'] = JSON.generate(@identifier, allow_nan: true)
@@ -128,7 +132,7 @@ module OpenC3
     # Connect to the websocket with authorization in query params
     def connect
       disconnect()
-      final_url = @url + "?scope=#{@scope}&authorization=#{@authentication.get_otp(scope: @scope)}"
+      final_url = @url + "?scope=#{@scope}"
       @stream = WebSocketClientStream.new(final_url, @write_timeout, @read_timeout, @connect_timeout)
       @stream.headers = {
         'Sec-WebSocket-Protocol' => 'actioncable-v1-json, actioncable-unsupported',

data/lib/openc3/system/target.rb

@@ -102,7 +102,10 @@ module OpenC3
     def process_file(filename)
       Logger.instance.info "Processing target definition in file '#{filename}'"
       parser = ConfigParser.new("https://docs.openc3.com/docs/configuration/target")
-      parser.parse_file(filename) do |keyword, parameters|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy). At runtime target files are read already-rendered
+      # from the bucket, so they are treated as data, not re-executed as code.
+      parser.parse_file(filename, false, true, false) do |keyword, parameters|
         case keyword
         when 'LANGUAGE'
           usage = "#{keyword} <ruby | python>"

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

@@ -85,7 +85,10 @@ module OpenC3
         ConfigParser.new(
           'https://openc3.com/docs/tools/#table-manager-configuration-openc3--39',
         )
-      parser.parse_file(filename) do |keyword, params|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy). Table definitions are read already-rendered from the
+      # bucket here, so they are treated as data, not re-executed as code.
+      parser.parse_file(filename, false, true, false) do |keyword, params|
         if @building_generic_conversion
           case keyword
           # Complete a generic conversion

data/lib/openc3/top_level.rb

@@ -108,7 +108,7 @@ module OpenC3
     # 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('..', '-')
+    sanitized = path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\u{FFFD}").strip.tr("\u{202E}%$|:;\t\r\n\\", "-").gsub('..', '-')
     if sanitized != path
       raise StorageError, "Invalid path: #{path}"
     end

data/lib/openc3/topics/limits_event_topic.rb

@@ -39,9 +39,15 @@ module OpenC3
       case event[:type]
       when :LIMITS_CHANGE
         # The current_limits hash keeps only the current limits state of items
-        # It is used by the API to determine the overall limits state
-        field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
-        Store.hset("#{scope}__current_limits", field, event[:new_limits_state])
+        # It is used by the API to determine the overall limits state.
+        # When the event originates from a stored packet in a non-PROCESS mode
+        # (LOG or DISABLE), skip updating current_limits so that historical
+        # data does not affect the real-time overall limits state or the
+        # out_of_limits API response.
+        unless event[:suppress_stored]
+          field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
+          Store.hset("#{scope}__current_limits", field, event[:new_limits_state])
+        end
 
       when :LIMITS_SETTINGS
         # Limits updated in limits_api.rb to avoid circular reference to TargetModel
@@ -79,6 +85,19 @@ module OpenC3
         limits_settings['enabled'] = event[:enabled]
         Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))
 
+      when :LIMITS_STATE_COLOR
+        # Persist the state color so it survives a decom microservice restart (applied by sync_system)
+        field = "#{event[:target_name]}__#{event[:packet_name]}__#{event[:item_name]}"
+        limits_settings = Store.hget("#{scope}__current_limits_settings", field)
+        if limits_settings
+          limits_settings = JSON.parse(limits_settings, allow_nan: true, create_additions: true)
+        else
+          limits_settings = {}
+        end
+        limits_settings['state_colors'] ||= {}
+        limits_settings['state_colors'][event[:state_name].to_s] = event[:color].to_s
+        Store.hset("#{scope}__current_limits_settings", field, JSON.generate(limits_settings, allow_nan: true))
+
       when :LIMITS_SET
         sets = sets(scope: scope)
         raise "Set '#{event[:set]}' does not exist!" unless sets.key?(event[:set])
@@ -173,6 +192,28 @@ module OpenC3
       end
     end
 
+    # Removes a limits set from the limits_sets hash and from the
+    # current_limits_settings of every item. Note that the set is not removed
+    # from the TargetModel packet definitions; that is cleaned up on the next
+    # plugin install. Running microservices will continue to hold the set in
+    # memory until they restart and resync from current_limits_settings.
+    def self.delete_set(set_name, scope:)
+      set_name = set_name.to_s
+      limits_settings = Store.hgetall("#{scope}__current_limits_settings")
+      # Collect all changed items and write them back in a single hmset to
+      # avoid a Redis round trip per item (this hash can be large)
+      updates = {}
+      limits_settings.each do |item, settings|
+        settings = JSON.parse(settings, allow_nan: true, create_additions: true)
+        if settings.key?(set_name)
+          settings.delete(set_name)
+          updates[item] = JSON.generate(settings, allow_nan: true)
+        end
+      end
+      Store.hmset("#{scope}__current_limits_settings", *updates.flatten) unless updates.empty?
+      Store.hdel("#{scope}__limits_sets", set_name)
+    end
+
     # Update the local System based on overall state
     def self.sync_system(scope:)
       all_limits_settings = Store.hgetall("#{scope}__current_limits_settings")
@@ -188,6 +229,12 @@ module OpenC3
             persistence = limits_settings['persistence_setting']
             limits_settings.each do |limits_set, settings|
               next unless Hash === settings
+              if limits_set == 'state_colors'
+                settings.each do |state_name, color|
+                  System.limits.set_state_color(target_name, packet_name, item_name, state_name, color)
+                end
+                next
+              end
               System.limits.set(target_name, packet_name, item_name, settings['red_low'], settings['yellow_low'], settings['yellow_high'], settings['red_high'], settings['green_low'], settings['green_high'], limits_set.to_s.intern, persistence, enabled)
             end
             if not enabled.nil?
@@ -242,6 +289,18 @@ module OpenC3
           end
         end
 
+      when 'LIMITS_STATE_COLOR'
+        target_name = event['target_name']
+        packet_name = event['packet_name']
+        item_name = event['item_name']
+        target = telemetry[target_name]
+        if target
+          packet = target[packet_name]
+          if packet
+            System.limits.set_state_color(target_name, packet_name, item_name, event['state_name'], event['color'])
+          end
+        end
+
       when 'LIMITS_SET'
         System.limits_set = event['set']
       end

data/lib/openc3/topics/telemetry_decom_topic.rb

@@ -20,7 +20,7 @@ require 'openc3/utilities/open_telemetry'
 
 module OpenC3
   class TelemetryDecomTopic < Topic
-    def self.write_packet(packet, id: nil, scope:)
+    def self.write_packet(packet, id: nil, include_limits_states: true, scope:)
       OpenC3.in_span("write_packet") do
         # Need to build a JSON hash of the decommutated data
         # Support "downward typing"
@@ -29,7 +29,7 @@ module OpenC3
         # If nothing - item does not exist - nil
         # __ as separators ITEM1, ITEM1__C, ITEM1__F
 
-        json_hash = CvtModel.build_json_from_packet(packet)
+        json_hash = CvtModel.build_json_from_packet(packet, include_limits_states: include_limits_states)
         # Convert to JSON-safe types once and reuse for both topic write and CVT set
         json_safe_hash = json_hash.as_json
         json_data = JSON.generate(json_safe_hash, allow_nan: true)