openc3 7.2.1 → 7.4.0

data/lib/openc3/utilities/local_mode.rb

@@ -99,7 +99,7 @@ module OpenC3
 
       Dir.each_child(path) do |filename|
         full_path = "#{path}/#{filename}"
-        if not File.directory?(full_path)
+        unless File.directory?(full_path)
           if File.extname(filename) == '.gem'
             gems << full_path
           elsif filename == 'plugin_instance.json'
@@ -283,7 +283,7 @@ module OpenC3
       return if DEFAULT_PLUGINS.include?(gem_name)
       puts "Updating local plugin files: #{full_folder_path}"
       FileUtils.mkdir_p(full_folder_path)
-      gems, _ = scan_plugin_dir(full_folder_path)
+      gems = scan_plugin_dir(full_folder_path).first
       gems.each do |gem|
         File.delete(gem)
       end
@@ -377,7 +377,7 @@ module OpenC3
       end
     end
 
-    def self.put_target_file(path, io_or_string, scope:)
+    def self.put_target_file(path, io_or_string, scope:) # NOSONAR - scope: is part of the caller-facing signature
       full_folder_path = "#{OPENC3_LOCAL_MODE_PATH}/#{path}"
       return unless File.expand_path(full_folder_path).start_with?(OPENC3_LOCAL_MODE_PATH)
       FileUtils.mkdir_p(File.dirname(full_folder_path))
@@ -468,16 +468,42 @@ module OpenC3
     end
 
     def self.sync_settings()
+      # The files are authoritative here, unlike the OPENC3_SETTING_* env var
+      # seeding done by `openc3cli initsettings`. An Admin Console edit is
+      # mirrored straight back into the file by set_setting, so the file is
+      # already the edited value and applying it reverts nothing. Skipping a
+      # setting that already exists would instead mean a file was never applied
+      # at all: localinit runs after the first plugin load creates the scope,
+      # and that seeds source_url, rubygems_url, pypi_url, news_feed and
+      # system_health, so those five always exist by the time this runs.
+      #
+      # Because initsettings runs before localinit, a local mode file wins over
+      # OPENC3_SETTING_<NAME> for the same setting.
+      #
+      # A file that won't coerce is reported and skipped rather than raising,
+      # for the same reason `initsettings` doesn't abort: one bad settings file
+      # shouldn't stop the rest of localinit.
+      problems = []
       scopes = ScopeModel.names()
       scopes.each do |scope|
         Dir["#{OPENC3_LOCAL_MODE_PATH}/#{scope}/settings/*.json"].each do |config|
           name = File.basename(config, ".json")
+          # save_setting writes a boolean as the JSON text "true"/"false", so
+          # convert it back rather than storing the file contents verbatim -
+          # the string "false" is truthy in the frontend. Settings that hold
+          # JSON text (classification_banner, astro) stay strings, which is
+          # what their components JSON.parse.
+          begin
+            data = SettingModel.coerce(name, File.read(config))
+          rescue StandardError => error
+            problems << "#{config}: #{error.message}"
+            next
+          end
           puts "Syncing setting #{name}"
-          # Anything can be stored in settings so read and set directly
-          data = File.read(config)
           SettingModel.set({ name: name, data: data }, scope: scope)
         end
       end
+      problems.each { |problem| puts "ERROR: #{problem}" }
     end
 
     def self.save_setting(scope, name, data)
@@ -485,7 +511,10 @@ module OpenC3
       config_path = "#{OPENC3_LOCAL_MODE_PATH}/#{scope}/settings/#{name}.json"
       return unless File.expand_path(config_path).start_with?(OPENC3_LOCAL_MODE_PATH)
       FileUtils.mkdir_p(File.dirname(config_path))
-      # Anything can be stored as a setting so write it out directly
+      # Anything can be stored as a setting. Strings are written directly since
+      # they're already the serialized form. Anything else is written as JSON so
+      # sync_settings can read it back rather than a Ruby inspect string.
+      data = JSON.generate(data.as_json(:allow_nan => true)) unless String === data
       File.write(config_path, data)
     end
 
@@ -579,7 +608,7 @@ module OpenC3
           # Both files exist - Handled earlier
         else
           # Local is missing remote file
-          if not ENV['OPENC3_LOCAL_MODE_SECONDARY'] and ENV['OPENC3_LOCAL_MODE_SYNC_REMOVE']
+          if not ENV.fetch('OPENC3_LOCAL_MODE_SECONDARY', nil) and ENV.fetch('OPENC3_LOCAL_MODE_SYNC_REMOVE', nil)
             delete_remote(bucket, key)
           else
             # Go ahead and copy down to get in sync

data/lib/openc3/utilities/logger.rb

@@ -42,39 +42,61 @@ module OpenC3
 
     @@mutex = Mutex.new
     @@instance = nil
-    @@scope = ENV['OPENC3_SCOPE']
+    @@scope = ENV.fetch('OPENC3_SCOPE', 'DEFAULT')
 
-    # DEBUG only prints DEBUG messages
+    # Levels in increasing severity. Logging at a level prints that level
+    # and everything above it, e.g. WARN prints WARN, ERROR and FATAL.
     DEBUG = ::Logger::DEBUG
-    # INFO prints INFO, DEBUG messages
     INFO  = ::Logger::INFO
-    # WARN prints WARN, INFO, DEBUG messages
     WARN  = ::Logger::WARN
-    # ERROR prints ERROR, WARN, INFO, DEBUG messages
     ERROR = ::Logger::ERROR
-    # FATAL prints FATAL, ERROR, WARN, INFO, DEBUG messages
     FATAL = ::Logger::FATAL
 
+    # Level names as they appear in log messages and OPENC3_LOG_LEVEL
     DEBUG_LEVEL = 'DEBUG'
     INFO_LEVEL = 'INFO'
     WARN_LEVEL = 'WARN'
     ERROR_LEVEL = 'ERROR'
     FATAL_LEVEL = 'FATAL'
 
+    LEVELS = {
+      DEBUG_LEVEL => DEBUG,
+      INFO_LEVEL => INFO,
+      WARN_LEVEL => WARN,
+      ERROR_LEVEL => ERROR,
+      FATAL_LEVEL => FATAL
+    }.freeze
+
     # Types
     LOG = 'log'
     NOTIFICATION = 'notification'
     ALERT = 'alert'
     EPHEMERAL = 'ephemeral'
 
+    # @return [Integer] Level named by the OPENC3_LOG_LEVEL env var.
+    #   INFO if the var is unset or isn't a level name.
+    def self.default_level
+      level = ENV.fetch('OPENC3_LOG_LEVEL', '')
+      name = level.to_s.strip.upcase
+      return INFO if name.empty?
+
+      LEVELS.fetch(name) do
+        unless @warned_bad_level
+          @warned_bad_level = true
+          $stderr.puts "OPENC3_LOG_LEVEL '#{level}' is not one of #{LEVELS.keys.join(', ')}, using INFO"
+        end
+        INFO
+      end
+    end
+
     # @param level [Integer] The initial logging level
-    def initialize(level = Logger::INFO)
+    def initialize(level = Logger.default_level)
       @stdout = true
       @level = level
       @detail_string = nil
       @container_name = Socket.gethostname
       @microservice_name = nil
-      @no_store = ENV['OPENC3_NO_STORE']
+      @no_store = ENV.fetch('OPENC3_NO_STORE', nil)
     end
 
     # Only set the microservice name once (to help with multi microservices)

data/lib/openc3/utilities/python_venv.rb

@@ -0,0 +1,135 @@
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# 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 LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'open3'
+require 'openc3/models/target_model'
+require 'openc3/utilities/target_file'
+
+module OpenC3
+  module PythonVenv
+    PLUGIN_VENVS_DIR = '/gems/plugin_venvs'
+
+    # Shared user site-packages directory used by plugins that predate the
+    # per-plugin UV venvs. Every caller that falls back off a plugin venv points
+    # PYTHONUSERBASE here, so keep it in one place rather than repeating the
+    # literal in script.rb, running_script.rb, microservice_operator.rb and
+    # microservice_model.rb.
+    DEFAULT_PYTHONUSERBASE = '/gems/python_packages'
+
+    # Packages a plugin venv must never supply itself. The scripts and
+    # microservices that use a plugin venv still run the base venv's Python
+    # binary, and CPython searches every PYTHONPATH entry ahead of the running
+    # venv's own site-packages. A plugin that declares openc3 as a dependency
+    # would therefore shadow the system library with its own copy, silently
+    # swapping the API client the script talks to COSMOS with. Reordering
+    # PYTHONPATH cannot fix this - the whole variable outranks the base venv -
+    # so the copy is removed at install time instead.
+    RESERVED_PACKAGES = ['openc3'].freeze
+
+    # Resolve a script's plugin venv and expose its packages to a child process.
+    # Returns the venv path when configured, or nil when the system environment
+    # should be used.
+    def self.configure_for_script(environment, name:, scope:, python_venv: nil)
+      venv_dir = resolve_script_venv(name: name, scope: scope, python_venv: python_venv)
+      return nil unless venv_dir
+
+      configure_environment(environment, venv_dir)
+      venv_dir
+    end
+
+    def self.configure_environment(environment, venv_dir)
+      environment['VIRTUAL_ENV'] = venv_dir
+      environment['PATH'] = "#{venv_dir}/bin:#{ENV.fetch('PATH', '')}"
+      environment['PYTHONUSERBASE'] = venv_dir
+
+      site_packages = Dir.glob("#{venv_dir}/lib/python*/site-packages").first
+      # Prefer a PYTHONPATH the caller already seeded on `environment` over the
+      # ambient one. Script.process_suite sets it to ENV['PYTHONPATH'] || '.'
+      # before calling here, and reading ENV directly would drop that value.
+      existing_pythonpath = environment['PYTHONPATH'] || ENV.fetch('PYTHONPATH', '')
+      if site_packages
+        environment['PYTHONPATH'] = existing_pythonpath.empty? ? site_packages : "#{site_packages}:#{existing_pythonpath}"
+      else
+        environment['PYTHONPATH'] = existing_pythonpath.empty? ? nil : existing_pythonpath
+      end
+
+      environment
+    end
+
+    # Remove any RESERVED_PACKAGES a plugin installed into its own venv.
+    # Returns the names that were removed so callers can report them.
+    def self.purge_reserved_packages(venv_dir)
+      return [] if venv_dir.nil? || venv_dir.empty?
+
+      purged = []
+      RESERVED_PACKAGES.each do |package|
+        next unless package_installed?(venv_dir, package)
+
+        Logger.warn("Plugin venv #{venv_dir} declares '#{package}', which would shadow the " \
+                    "system library. Removing it; the plugin will use the system #{package}.")
+        _output, status = Open3.capture2e('uv', 'pip', 'uninstall', '--python', venv_dir, package)
+        if status.success?
+          purged << package
+        else
+          Logger.error("Failed to remove '#{package}' from plugin venv #{venv_dir}")
+        end
+      end
+      purged
+    rescue => e
+      Logger.error("Could not purge reserved packages from #{venv_dir}: #{e.message}")
+      []
+    end
+
+    def self.package_installed?(venv_dir, package)
+      _output, status = Open3.capture2e('uv', 'pip', 'show', '--python', venv_dir, package)
+      status.success?
+    end
+    private_class_method :package_installed?
+
+    def self.plugin_venv_path(scope:, plugin_name:)
+      sanitized_name = "#{scope}__#{plugin_name}".tr('^a-zA-Z0-9_-', '_')
+      candidate = File.join(PLUGIN_VENVS_DIR, sanitized_name, '.venv')
+      candidate if File.directory?(candidate)
+    end
+
+    def self.resolve_script_venv(name:, scope:, python_venv: nil)
+      target_name = name.split('/')[0].to_s.upcase
+      if target_name == TargetFile::TEMP_FOLDER && python_venv
+        # File.basename strips directory components; the tr() then whitelists the
+        # name down to the character set PluginModel.plugin_venv_name builds it
+        # from. That leaves no path separators and no glob metacharacters, so
+        # the value cannot escape PLUGIN_VENVS_DIR or widen the Dir.glob in
+        # configure_environment.
+        safe_name = File.basename(python_venv.to_s).tr('^a-zA-Z0-9_-', '_')
+        # The venv name is client-supplied, so it must also be confined to the
+        # caller's scope. Venv directories are named "<scope>__<plugin>" by
+        # PluginModel.plugin_venv_name; without this check a user in one scope
+        # could name another scope's venv and run against its packages.
+        return nil unless safe_name.start_with?("#{scope}__".tr('^a-zA-Z0-9_-', '_'))
+
+        candidate = File.join(PLUGIN_VENVS_DIR, safe_name, '.venv')
+        return candidate if File.directory?(candidate)
+      else
+        target_info = TargetModel.get(name: target_name, scope: scope)
+        if target_info && target_info['plugin']
+          return plugin_venv_path(scope: scope, plugin_name: target_info['plugin'])
+        end
+      end
+      nil
+    rescue => e
+      Logger.debug("Could not resolve plugin venv for script '#{name}': #{e.message}")
+      nil
+    end
+    private_class_method :resolve_script_venv
+  end
+end

data/lib/openc3/utilities/ruby_lex_utils.rb

@@ -94,7 +94,11 @@ And so is this
       # of the file and process the last line
       if next_token.type == :EOF
         if !line.empty?
-          yield line, instrumentable, inside_begin, orig_line_no
+          # orig_line_no is normally set below (after this EOF check) but a final
+          # line that never reaches that assignment (e.g. a trailing bareword call
+          # with no parentheses and no newline at end of file) would yield nil.
+          # Fall back to the current token's start line so the line number is valid.
+          yield line, instrumentable, inside_begin, orig_line_no || token.location.start_line
         end
         break
       end

data/lib/openc3/utilities/rubygems_url.rb

@@ -0,0 +1,39 @@
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# 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 LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'uri'
+require 'openc3/utilities/logger'
+
+module OpenC3
+  class RubygemsUrl
+    DEFAULT = 'https://rubygems.org'
+
+    # Validate that a resolved rubygems_url is an http(s) URL before it is used
+    # as a Gem source. The value can come from a user-writable setting or ENV, so
+    # a malformed or non-http value is rejected and replaced with the default
+    # rather than passed through to RubyGems.
+    #
+    # @param rubygems_url [String] the resolved rubygems source url to validate
+    # @return [String] the original url if valid, otherwise DEFAULT
+    def self.validate(rubygems_url)
+      uri = URI.parse(rubygems_url)
+      unless uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+        raise URI::InvalidURIError, "not an http(s) URL"
+      end
+      rubygems_url
+    rescue URI::InvalidURIError => e
+      Logger.error("Invalid rubygems_url '#{rubygems_url}' (#{e.message}); falling back to #{DEFAULT}")
+      DEFAULT
+    end
+  end
+end