openc3 7.2.0 → 7.3.0

data/lib/openc3/models/tool_model.rb

@@ -25,6 +25,13 @@ module OpenC3
   class ToolModel < Model
     PRIMARY_KEY = 'openc3_tools'
 
+    # Tools are global to the entire COSMOS installation and are always stored
+    # in the DEFAULT scope. The frontend navigation always requests the tool
+    # list from DEFAULT, so a tool installed into any other scope would be
+    # inaccessible. Every scope parameter in this class is therefore ignored
+    # and replaced with TOOL_SCOPE.
+    TOOL_SCOPE = 'DEFAULT'
+
     attr_accessor :folder_name
     attr_accessor :icon
     attr_accessor :url
@@ -39,21 +46,24 @@ module OpenC3
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.get(name:, scope: nil)
-      super("#{scope}__#{PRIMARY_KEY}", name: name)
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name)
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.names(scope: nil)
       array = []
-      all(scope: scope).each do |name, _tool|
+      all().each do |name, _tool|
         array << name
       end
       array
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.all(scope: nil)
       ordered_array = []
-      tools = unordered_all(scope: scope)
+      tools = unordered_all()
       tools.each do |_name, tool|
         ordered_array << tool
       end
@@ -65,14 +75,10 @@ module OpenC3
       ordered_hash
     end
 
+    # Tools only exist in the DEFAULT scope. Kept for backwards compatibility
+    # with the ToolsController importmap endpoint.
     def self.all_scopes
-      result = {}
-      scopes = OpenC3::ScopeModel.all
-      scopes.each do |key, _scope|
-        tools = unordered_all(scope: key)
-        result.merge!(tools)
-      end
-      result
+      unordered_all()
     end
 
     # Called by the PluginModel to allow this class to validate it's top-level keyword: "TOOL"
@@ -80,7 +86,8 @@ module OpenC3
       case keyword
       when 'TOOL'
         parser.verify_num_parameters(2, 2, "TOOL <Folder Name> <Name>")
-        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: scope)
+        # NOTE: scope is intentionally ignored, see TOOL_SCOPE
+        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: TOOL_SCOPE)
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Tool: #{keyword} #{parameters.join(" ")}")
       end
@@ -89,8 +96,10 @@ module OpenC3
 
     # The ToolsTab.vue calls the ToolsController which uses this method to reorder the tools
     # Position is index in the list starting with 0 = first
-    def self.set_position(name:, position:, scope:)
-      moving = from_json(get(name: name, scope: scope), scope: scope)
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
+    def self.set_position(name:, position:, scope: nil)
+      tool_scope = TOOL_SCOPE
+      moving = from_json(get(name: name, scope: tool_scope), scope: tool_scope)
       old_pos = moving.position
       new_pos = position
       direction = :down
@@ -101,8 +110,8 @@ module OpenC3
       end
 
       # Go through all the tools and reorder
-      all(scope: scope).each do |_tool_name, tool|
-        tool_model = from_json(tool, scope: scope)
+      all(scope: tool_scope).each do |_tool_name, tool|
+        tool_model = from_json(tool, scope: tool_scope)
         # Update the requested model to the new position
         if tool_model.name == name
           tool_model.position = position
@@ -134,9 +143,11 @@ module OpenC3
       needs_dependencies: false,
       disable_erb: nil,
       import_map_items: nil,
-      scope:
+      scope: nil  # NOTE: deprecated since 7.3.0 as tools are always created in the DEFAULT scope, see TOOL_SCOPE
     )
-      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
+      # Tools are always created in the DEFAULT scope regardless of the scope
+      # the plugin is being installed into, see TOOL_SCOPE
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: TOOL_SCOPE)
       @folder_name = folder_name
       @icon = icon
       @url = url
@@ -156,14 +167,15 @@ module OpenC3
     end
 
     def create(update: false, force: false, queued: false)
-      tools = self.class.all(scope: @scope)
+      tools = self.class.all()
 
       # Make sure a tool with this folder_name doesn't already exist
+      # NOTE: Tools are global (TOOL_SCOPE) so this check is across all scopes
       unless update
         if @folder_name
           tools.each do |_tool_name, tool|
             if tool['folder_name'] == @folder_name
-              raise "Tool with folder_name #{@folder_name} already exists at create"
+              raise "Tool with folder_name #{@folder_name} already exists at create. Tools are global to the entire COSMOS installation and can only be installed once."
             end
           end
         end
@@ -308,8 +320,9 @@ module OpenC3
     ##################################################
 
     # Returns the list of tools or the default OpenC3 tool set if no tools have been created
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.unordered_all(scope: nil)
-      tools = Store.hgetall("#{scope}__#{PRIMARY_KEY}")
+      tools = Store.hgetall("#{TOOL_SCOPE}__#{PRIMARY_KEY}")
       tools.each do |key, value|
         tools[key] = JSON.parse(value, allow_nan: true, create_additions: true)
       end

data/lib/openc3/operators/microservice_operator.rb

@@ -47,10 +47,39 @@ module OpenC3
       env = microservice_config["env"].dup
       if microservice_config["needs_dependencies"]
         env['GEM_HOME'] = '/gems'
-        env['PYTHONUSERBASE'] = '/gems/python_packages'
-        # Ensure PYTHONPATH includes both the UV venv (for base openc3 module) and user packages
-        # This is critical for UV-based Python installations where openc3 is installed as editable
-        env['PYTHONPATH'] = "#{ENV['PYTHONPATH']}"
+
+        # Resolve the Python virtual environment for this microservice.
+        # If the microservice belongs to a plugin that has a per-plugin UV venv
+        # (created by uvinstall during plugin install), use that isolated venv.
+        # Otherwise fall back to the shared PYTHONUSERBASE for legacy plugins.
+        plugin_name = microservice_config["plugin"]
+        plugin_venv_dir = nil
+        if plugin_name
+          scope = microservice_name.split("__")[0]
+          sanitized_name = "#{scope}__#{plugin_name}".tr('^a-zA-Z0-9_-', '_')
+          candidate = "/gems/plugin_venvs/#{sanitized_name}/.venv"
+          plugin_venv_dir = candidate if File.directory?(candidate)
+        end
+
+        if plugin_venv_dir
+          env['VIRTUAL_ENV'] = plugin_venv_dir
+          env['PATH'] = "#{plugin_venv_dir}/bin:#{ENV.fetch('PATH', '')}"
+          env['PYTHONUSERBASE'] = plugin_venv_dir
+          # Add the plugin venv's site-packages to PYTHONPATH so the base venv's
+          # Python binary can find plugin-specific packages. We keep the base binary
+          # because it has openc3 core installed; PYTHONPATH is always respected by
+          # CPython regardless of venv activation state.
+          site_packages = Dir.glob("#{plugin_venv_dir}/lib/python*/site-packages").first
+          existing_pythonpath = ENV.fetch('PYTHONPATH', '')
+          if site_packages
+            env['PYTHONPATH'] = existing_pythonpath.empty? ? site_packages : "#{site_packages}:#{existing_pythonpath}"
+          else
+            env['PYTHONPATH'] = existing_pythonpath.empty? ? nil : existing_pythonpath
+          end
+        else
+          env['PYTHONUSERBASE'] = '/gems/python_packages'
+          env['PYTHONPATH'] = ENV.fetch('PYTHONPATH', nil)
+        end
       else
         env['GEM_HOME'] = nil
         env['PYTHONUSERBASE'] = nil

data/lib/openc3/operators/operator.rb

@@ -381,11 +381,21 @@ module OpenC3
       # Monitor processes and respawn if died
       Logger.info("#{self.class} Monitoring processes every #{@cycle_time} sec...")
       loop do
-        update()
-        remove_old()
-        respawn_changed()
-        start_new()
-        respawn_dead()
+        # A single cycle must never be able to take down the operator process.
+        # update() in particular hits Redis every cycle and a transient network
+        # error (the kind that also makes targets reconnect) would otherwise
+        # unwind run() and exit the process, which in the container looks like a
+        # full operator restart. Catch, log, and keep cycling so the next cycle
+        # can recover once Redis is reachable again.
+        begin
+          update()
+          remove_old()
+          respawn_changed()
+          start_new()
+          respawn_dead()
+        rescue => e
+          Logger.error("#{self.class} cycle error, continuing: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}")
+        end
         break if @shutdown
 
         sleep(@cycle_time)

data/lib/openc3/packets/commands.rb

@@ -61,7 +61,7 @@ module OpenC3
     #   target name keyed by the packet name
     def packets(target_name)
       target_packets = @config.commands[target_name.to_s.upcase]
-      raise "Command target '#{target_name.to_s.upcase}' does not exist" unless target_packets
+      raise "Command target '#{target_name.to_s.upcase}' does not exist (packets lookup)" unless target_packets
 
       target_packets
     end
@@ -73,7 +73,7 @@ module OpenC3
     def packet(target_name, packet_name)
       target_packets = packets(target_name)
       packet = target_packets[packet_name.to_s.upcase]
-      raise "Command packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist" unless packet
+      raise "Command packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist (packet lookup)" unless packet
 
       packet
     end
@@ -187,9 +187,9 @@ module OpenC3
 
       # Lookup the command directly - avoid redundant upcase in packet()/packets()
       target_packets = @config.commands[target_upcase]
-      raise "Command target '#{target_upcase}' does not exist" unless target_packets
+      raise "Command target '#{target_upcase}' does not exist (build_cmd)" unless target_packets
       pkt = target_packets[packet_upcase]
-      raise "Command packet '#{target_upcase} #{packet_upcase}' does not exist" unless pkt
+      raise "Command packet '#{target_upcase} #{packet_upcase}' does not exist (build_cmd)" unless pkt
       # Use deep_copy to avoid shared item modifications affecting the template
       # This is critical for variable_bit_size items where handle_write_variable_bit_size
       # modifies item.bit_offset and item.array_size during writes
@@ -325,10 +325,10 @@ module OpenC3
               unless item.states.values.include?(value)
                 if command.raw
                   # Raw commands report missing value maps
-                  raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.values.join(', ')}"
+                  raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.values.join(', ')}"
                 else
                   # Normal commands report missing state maps
-                  raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.keys.join(', ')}"
+                  raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{value.to_s.upcase} not one of #{item.states.keys.join(', ')}"
                 end
               end
             end
@@ -340,7 +340,7 @@ module OpenC3
             # Perform Range Check on command parameter
             if not range.include?(range_check_value)
               range_check_value = "'#{range_check_value}'" if String === range_check_value
-              raise "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{range_check_value} not in valid range of #{range.first} to #{range.last}"
+              raise RangeError, "Command parameter '#{command.target_name} #{command.packet_name} #{item_upcase}' = #{range_check_value} not in valid range of #{range.first} to #{range.last}"
             end
           end
         end

data/lib/openc3/packets/limits.rb

@@ -153,16 +153,47 @@ module OpenC3
       return [limits_set, limits.persistence_setting, limits.enabled, limits_for_set[0], limits_for_set[1], limits_for_set[2], limits_for_set[3], limits_for_set[4], limits_for_set[5]]
     end
 
+    # Set the color for a telemetry item state
+    #
+    # @param target_name [String] Target Name
+    # @param packet_name [String] Packet Name
+    # @param item_name [String] Item Name
+    # @param state_name [String] State Name (e.g. 'CONNECTED')
+    # @param color [String or Symbol, nil] New color: GREEN, YELLOW, or RED.
+    #   Pass nil to clear (remove) the state color.
+    # @return [Symbol, nil] The color that was set, or nil if the color was cleared
+    def set_state_color(target_name, packet_name, item_name, state_name, color)
+      packet = _get_packet(target_name, packet_name)
+      item = packet.get_item(item_name)
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not have any states" unless item.states
+      state_name = state_name.to_s.upcase
+      raise "State '#{state_name}' does not exist for item '#{target_name} #{packet_name} #{item_name}'" unless item.states.key?(state_name)
+      if color.nil?
+        # Clear the state color while keeping state_colors as a Hash so limits
+        # checking (which indexes state_colors by value) continues to work.
+        item.state_colors.delete(state_name) if item.state_colors
+        packet.update_limits_items_cache(item)
+        return nil
+      end
+      color = color.to_s.upcase.intern
+      raise "Invalid state color '#{color}'. Must be one of #{PacketItem::STATE_COLORS.join(', ')}." unless PacketItem::STATE_COLORS.include?(color)
+      item.state_colors ||= {}
+      item.state_colors[state_name] = color
+      item.limits.enabled = true
+      packet.update_limits_items_cache(item)
+      return color
+    end
+
     protected
 
     def _get_packet(target_name, packet_name)
       raise "LATEST packet not valid" if packet_name.upcase == LATEST_PACKET_NAME
 
       packets = @config.telemetry[target_name.to_s.upcase]
-      raise "Telemetry target '#{target_name.to_s.upcase}' does not exist" unless packets
+      raise "Telemetry target '#{target_name.to_s.upcase}' does not exist (limits lookup)" unless packets
 
       packet = packets[packet_name.to_s.upcase]
-      raise "Telemetry packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist" unless packet
+      raise "Telemetry packet '#{target_name.to_s.upcase} #{packet_name.to_s.upcase}' does not exist (limits lookup)" unless packet
 
       return packet
     end

data/lib/openc3/packets/packet.rb

@@ -616,7 +616,7 @@ module OpenC3
     def get_item(name)
       return super(name)
     rescue ArgumentError
-      raise "Packet item '#{@target_name} #{@packet_name} #{name.upcase}' does not exist"
+      raise "Item '#{@target_name} #{@packet_name} #{name.upcase}' does not exist (Packet)"
     end
 
     # Read an item in the packet
@@ -1285,7 +1285,7 @@ module OpenC3
       config
     end
 
-    def decom
+    def decom(include_limits_states: true)
       # Read all the RAW at once because this could be optimized by the accessor
       json_hash = read_items(@sorted_items)
 
@@ -1301,7 +1301,9 @@ module OpenC3
           if item.format_string or item.units
             json_hash["#{item.name}__F"] = read_item(item, :FORMATTED, @buffer, given_raw)
           end
-          limits_state = item.limits.state
+          if include_limits_states
+            limits_state = item.limits.state
+          end
           if limits_state
             json_hash["#{item.name}__L"] = limits_state
           end
@@ -1551,4 +1553,4 @@ module OpenC3
       item
     end
   end
-end
+end

data/lib/openc3/packets/packet_config.rb

@@ -161,7 +161,11 @@ module OpenC3
       process_target_name = process_target_name.upcase
       parser = ConfigParser.new("https://docs.openc3.com/docs")
       parser.instance_variable_set(:@target_name, process_target_name)
-      parser.parse_file(filename) do |keyword, params|
+      # run_erb is false: ERB is only rendered once, at plugin install time
+      # (TargetModel#deploy), before files are written to the targets bucket. The
+      # targets_modified overlay (e.g. dynamically created packets) is never ERB
+      # rendered, so it is treated as data here rather than 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/packets/parsers/state_parser.rb

@@ -124,7 +124,7 @@ module OpenC3
     def get_state_colors(item)
       color = @parser.parameters[2].upcase.to_sym
       unless PacketItem::STATE_COLORS.include? color
-        raise @parser.error("Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}.", @usage)
+        raise @parser.error("Invalid state color '#{color}'. Must be one of #{PacketItem::STATE_COLORS.join(', ')}.", @usage)
       end
 
       item.limits.enabled = true