vagrant 1.5.0 → 2.4.4

data/lib/vagrant/patches/fake_ftp.rb

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fake_ftp"
+
+module FakeFtp
+  class File
+    def initialize(name = nil, data = nil, type = nil,
+      last_modified_time = Time.now)
+      @created = Time.now
+      @name = name
+      @data = data
+      @bytes = data_is_bytes(data) ? data : data.bytes.length
+      @data = data_is_bytes(data) ? nil : data
+      @type = type
+      @last_modified_time = last_modified_time.utc
+    end
+
+    def data_is_bytes(d)
+      d.nil? || d.is_a?(Integer)
+    end
+
+    def data=(data)
+      @bytes = data_is_bytes(data) ? data : data.bytes.length
+      @data = data_is_bytes(data) ? nil : data
+    end
+  end
+end

data/lib/vagrant/patches/log4r.rb

@@ -0,0 +1,54 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# This adds trace level support to log4r. Since log4r
+# loggers use the trace method for checking if trace
+# information should be included in the output, we
+# make some modifications to allow the trace check to
+# still work while also supporting trace as a valid level
+require "log4r/loggerfactory"
+
+if !Log4r::Logger::LoggerFactory.respond_to?(:fake_define_methods)
+  class Log4r::Logger::LoggerFactory
+    class << self
+      def fake_set_log(logger, lname)
+        real_set_log(logger, lname)
+        if lname == "TRACE"
+          logger.instance_eval do
+            alias :trace_as_level :trace
+            def trace(*args)
+              return @trace if args.empty?
+              trace_as_level(*args)
+            end
+          end
+        end
+      end
+
+      def fake_undefine_methods(logger)
+        real_undefine_methods(logger)
+        logger.instance_eval do
+          def trace(*_)
+            @trace
+          end
+        end
+      end
+
+      alias_method :real_undefine_methods, :undefine_methods
+      alias_method :undefine_methods, :fake_undefine_methods
+      alias_method :real_set_log, :set_log
+      alias_method :set_log, :fake_set_log
+    end
+  end
+
+  class Log4r::Logger
+    # The factory allows using a previously created logger
+    # instance if it exists. Doing this prevents knocking
+    # out configuration that may have already been applied
+    # to the logger instance (like log level)
+    def self.factory(name, *args)
+      l = Log4r::Logger::Repository[name]
+      return l unless l.nil?
+      Log4r::Logger.new(name, *args)
+    end
+  end
+end

data/lib/vagrant/patches/net-ssh.rb

@@ -0,0 +1,76 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "net/ssh"
+require "net/ssh/buffer"
+
+# Set the version requirement for when net-ssh should be patched
+NET_SSH_PATCH_REQUIREMENT = Gem::Requirement.new(">= 7.0.0", "<= 7.3")
+
+# This patch provides support for properly loading ECDSA private keys
+if NET_SSH_PATCH_REQUIREMENT.satisfied_by?(Gem::Version.new(Net::SSH::Version::STRING))
+  Net::SSH::Buffer.class_eval do
+    def vagrant_read_private_keyblob(type)
+      case type
+      when /^ecdsa\-sha2\-(\w*)$/
+        curve_name_in_type = $1
+        curve_name_in_key = read_string
+
+        unless curve_name_in_type == curve_name_in_key
+          raise Net::SSH::Exception, "curve name mismatched (`#{curve_name_in_key}' with `#{curve_name_in_type}')"
+        end
+
+        public_key_oct = read_string
+        priv_key_bignum = read_bignum
+        begin
+          curvename = OpenSSL::PKey::EC::CurveNameAlias[curve_name_in_key]
+          group = OpenSSL::PKey::EC::Group.new(curvename)
+          point = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(public_key_oct, 2))
+          priv_bn = OpenSSL::BN.new(priv_key_bignum, 2)
+          asn1 = OpenSSL::ASN1::Sequence(
+            [
+              OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(0)),
+              OpenSSL::ASN1::Sequence.new(
+                [
+                  OpenSSL::ASN1::ObjectId("id-ecPublicKey"),
+                  OpenSSL::ASN1::ObjectId(curvename)
+                ]
+              ),
+              OpenSSL::ASN1::OctetString.new(
+                OpenSSL::ASN1::Sequence.new(
+                  [
+                    OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(1)),
+                    OpenSSL::ASN1::OctetString.new(priv_bn.to_s(2)),
+                    OpenSSL::ASN1::ASN1Data.new(
+                      [
+                        OpenSSL::ASN1::BitString.new(point.to_octet_string(:uncompressed)),
+                      ], 1, :CONTEXT_SPECIFIC,
+                    )
+                  ]
+                ).to_der
+              )
+            ]
+          )
+
+          key = OpenSSL::PKey::EC.new(asn1.to_der)
+
+          return key
+        rescue OpenSSL::PKey::ECError
+          raise NotImplementedError, "unsupported key type `#{type}'"
+        end
+      else
+        netssh_read_private_keyblob(type)
+      end
+    end
+
+    alias_method :netssh_read_private_keyblob, :read_private_keyblob
+    alias_method :read_private_keyblob, :vagrant_read_private_keyblob
+  end
+
+  OpenSSL::PKey::EC::Point.class_eval do
+    include Net::SSH::Authentication::PubKeyFingerprint
+    def to_pem
+      "#{ssh_type} #{self.to_bn.to_s(2)}"
+    end
+  end
+end

data/lib/vagrant/patches/rubygems.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+# This allows for effective monkey patching of the MakeMakefile
+# module when building gem extensions. When gem extensions are
+# built, the extconf.rb file is executed as a separate process.
+# To support monkey patching the MakeMakefile module, the ruby
+# executable path is adjusted to add a custom load path allowing
+# a customized mkmf.rb file to load the proper mkmf.rb file, and
+# then applying the proper patches.
+if Gem.win_platform?
+  Gem.class_eval do
+    class << self
+      def vagrant_ruby
+        cmd = ruby_ruby
+        "#{cmd} -I\"#{Vagrant.source_root.join("lib/vagrant/patches/builder")}\""
+      end
+
+      alias_method :ruby_ruby, :ruby
+      alias_method :ruby, :vagrant_ruby
+    end
+  end
+end

data/lib/vagrant/patches/timeout_error.rb

@@ -0,0 +1,5 @@
+# Adds an IO::TimeoutError for versions of ruby where it isn't defined (< 3.2). 
+if !defined?(IO::TimeoutError)
+  class IO::TimeoutError < StandardError
+  end
+end

data/lib/vagrant/plugin/manager.rb

@@ -0,0 +1,406 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "pathname"
+require "set"
+
+require_relative "../bundler"
+require_relative "../shared_helpers"
+require_relative "state_file"
+
+module Vagrant
+  module Plugin
+    # The Manager helps with installing, listing, and initializing plugins.
+    class Manager
+      # Returns the path to the [StateFile] for user plugins.
+      #
+      # @return [Pathname]
+      def self.user_plugins_file
+        Vagrant.user_data_path.join("plugins.json")
+      end
+
+      # Returns the path to the [StateFile] for system plugins.
+      def self.system_plugins_file
+        dir = Vagrant.installer_embedded_dir
+        return nil if !dir
+        Pathname.new(dir).join("plugins.json")
+      end
+
+      def self.instance
+        @instance ||= self.new(user_plugins_file)
+      end
+
+      attr_reader :user_file
+      attr_reader :system_file
+      attr_reader :local_file
+
+      # @param [Pathname] user_file
+      def initialize(user_file)
+        @logger = Log4r::Logger.new("vagrant::plugin::manager")
+        @user_file   = StateFile.new(user_file)
+
+        system_path  = self.class.system_plugins_file
+        @system_file = nil
+        @system_file = StateFile.new(system_path) if system_path && system_path.file?
+
+        @local_file = nil
+        @globalized = @localized = false
+      end
+
+      # Enable global plugins
+      #
+      # @return [Hash] list of plugins
+      def globalize!
+        @globalized = true
+        @logger.debug("Enabling globalized plugins")
+        plugins = installed_plugins
+        bundler_init(plugins, global: user_file.path)
+        plugins
+      end
+
+      # Enable environment local plugins
+      #
+      # @param [Environment] env Vagrant environment
+      # @return [Hash, nil] list of plugins
+      def localize!(env)
+        @localized = true
+        if env.local_data_path
+          @logger.debug("Enabling localized plugins")
+          @local_file = StateFile.new(env.local_data_path.join("plugins.json"))
+          Vagrant::Bundler.instance.environment_path = env.local_data_path
+          plugins = local_file.installed_plugins
+          bundler_init(plugins, local: local_file.path)
+          plugins
+        end
+      end
+
+      # @return [Boolean] local and global plugins are loaded
+      def ready?
+        @globalized && @localized
+      end
+
+      # Initialize bundler with given plugins
+      #
+      # @param [Hash] plugins List of plugins
+      # @return [nil]
+      def bundler_init(plugins, **opts)
+        if !Vagrant.plugins_init?
+          @logger.warn("Plugin initialization is disabled")
+          return nil
+        end
+
+        @logger.info("Plugins:")
+        plugins.each do |plugin_name, plugin_info|
+          installed_version = plugin_info["installed_gem_version"]
+          version_constraint = plugin_info["gem_version"]
+          installed_version = 'undefined' if installed_version.to_s.empty?
+          version_constraint = '> 0' if version_constraint.to_s.empty?
+          @logger.info(
+            "  - #{plugin_name} = [installed: " \
+              "#{installed_version} constraint: " \
+              "#{version_constraint}]"
+          )
+        end
+        begin
+          Vagrant::Bundler.instance.init!(plugins, **opts)
+        rescue StandardError, ScriptError => err
+          @logger.error("Plugin initialization error - #{err.class}: #{err}")
+          err.backtrace.each do |backtrace_line|
+            @logger.debug(backtrace_line)
+          end
+          raise Vagrant::Errors::PluginInitError, message: err.to_s
+        end
+      end
+
+      # Installs another plugin into our gem directory.
+      #
+      # @param [String] name Name of the plugin (gem)
+      # @return [Gem::Specification]
+      def install_plugin(name, **opts)
+        if opts[:env_local] && @local_file.nil?
+          raise Errors::PluginNoLocalError
+        end
+
+        if name =~ /\.gem$/
+          # If this is a gem file, then we install that gem locally.
+          local_spec = Vagrant::Bundler.instance.install_local(name, opts)
+          name       = local_spec.name
+          opts[:version] = local_spec.version.to_s
+        end
+
+        plugins = installed_plugins
+        plugins[name] = {
+          "require"     => opts[:require],
+          "gem_version" => opts[:version],
+          "sources"     => opts[:sources],
+        }
+
+        if local_spec.nil?
+          result = nil
+          install_lambda = lambda do
+            Vagrant::Bundler.instance.install(plugins, opts[:env_local]).each do |spec|
+              next if spec.name != name
+              next if result && result.version >= spec.version
+              result = spec
+            end
+          end
+
+          if opts[:verbose]
+            Vagrant::Bundler.instance.verbose(&install_lambda)
+          else
+            install_lambda.call
+          end
+        else
+          result = local_spec
+        end
+
+        if result
+          # Add the plugin to the state file
+          plugin_file = opts[:env_local] ? @local_file : @user_file
+          plugin_file.add_plugin(
+            result.name,
+            version: opts[:version],
+            require: opts[:require],
+            sources: opts[:sources],
+            env_local: !!opts[:env_local],
+            installed_gem_version: result.version.to_s
+          )
+        else
+          r = Gem::Dependency.new(name, opts[:version])
+          result = Gem::Specification.find { |s|
+            s.satisfies_requirement?(r) &&
+              s.activated?
+          }
+          raise Errors::PluginInstallFailed,
+            name: name if result.nil?
+          @logger.warn("Plugin install returned no result as no new plugins were installed.")
+        end
+        # After install clean plugin gems to remove any cruft. This is useful
+        # for removing outdated dependencies or other versions of an installed
+        # plugin if the plugin is upgraded/downgraded
+        Vagrant::Bundler.instance.clean(installed_plugins, local: !!opts[:local])
+        result
+      rescue Gem::GemNotFoundException
+        raise Errors::PluginGemNotFound, name: name
+      rescue Gem::Exception => err
+        @logger.warn("Failed to install plugin: #{err}")
+        @logger.debug("#{err.class}: #{err}\n#{err.backtrace.join("\n")}")
+        # Try and determine a cause for the failure
+        case err.message
+        when /install development tools first/
+          raise Errors::PluginNeedsDeveloperTools
+        when /library not found in default locations/
+          lib = err.message.match(/(\w+) library not found in default locations/)
+          if lib.nil?
+            raise Errors::BundlerError, message: err.message
+          end
+          raise Errors::PluginMissingLibrary,
+            library: lib.captures.first,
+            name: name
+        when /find header files for ruby/
+          raise Errors::PluginMissingRubyDev
+        else
+          raise Errors::BundlerError, message: err.message
+        end
+      end
+
+      # Uninstalls the plugin with the given name.
+      #
+      # @param [String] name
+      def uninstall_plugin(name, **opts)
+        if @system_file
+          if !@user_file.has_plugin?(name) && @system_file.has_plugin?(name)
+            raise Errors::PluginUninstallSystem,
+              name: name
+          end
+        end
+
+        if opts[:env_local] && @local_file.nil?
+          raise Errors::PluginNoLocalError
+        end
+
+        plugin_file = opts[:env_local] ? @local_file : @user_file
+
+        if !plugin_file.has_plugin?(name)
+          raise Errors::PluginNotInstalled,
+            name: name
+        end
+
+        plugin_file.remove_plugin(name)
+
+        # Clean the environment, removing any old plugins
+        Vagrant::Bundler.instance.clean(installed_plugins)
+      rescue Gem::Exception => e
+        raise Errors::BundlerError, message: e.to_s
+      end
+
+      # Updates all or a specific set of plugins.
+      def update_plugins(specific, **opts)
+        if opts[:env_local] && @local_file.nil?
+          raise Errors::PluginNoLocalError
+        end
+
+        plugin_file = opts[:env_local] ? @local_file : @user_file
+
+        result = Vagrant::Bundler.instance.update(plugin_file.installed_plugins, specific)
+        plugin_file.installed_plugins.each do |name, info|
+          matching_spec = result.detect{|s| s.name == name}
+          info = Hash[
+            info.map do |key, value|
+              [key.to_sym, value]
+            end
+          ]
+          if matching_spec
+            plugin_file.add_plugin(name, **info.merge(
+              version: "> 0",
+              installed_gem_version: matching_spec.version.to_s
+            ))
+          end
+        end
+        Vagrant::Bundler.instance.clean(installed_plugins)
+        result
+      rescue Gem::Exception => e
+        raise Errors::BundlerError, message: e.to_s
+      end
+
+      # This returns the list of plugins that should be enabled.
+      #
+      # @return [Hash]
+      def installed_plugins
+        system = {}
+        if @system_file
+          @system_file.installed_plugins.each do |k, v|
+            system[k] = v.merge("system" => true)
+          end
+        end
+        plugin_list = Util::DeepMerge.deep_merge(system, @user_file.installed_plugins)
+
+        if @local_file
+          plugin_list = Util::DeepMerge.deep_merge(plugin_list,
+            @local_file.installed_plugins)
+        end
+
+        # Sort plugins by name
+        Hash[
+          plugin_list.map{|plugin_name, plugin_info|
+            [plugin_name, plugin_info]
+          }.sort_by(&:first)
+        ]
+      end
+
+      # This returns the list of plugins that are installed as
+      # Gem::Specifications.
+      #
+      # @return [Array<Gem::Specification>]
+      def installed_specs
+        installed_plugin_info = installed_plugins
+        installed = Set.new(installed_plugin_info.keys)
+        installed_versions = Hash[
+          installed_plugin_info.map{|plugin_name, plugin_info|
+            gem_version = plugin_info["gem_version"].to_s
+            gem_version = "> 0" if gem_version.empty?
+            [plugin_name, Gem::Requirement.new(gem_version)]
+          }
+        ]
+
+        # Go through the plugins installed in this environment and
+        # get the latest version of each.
+        installed_map = {}
+        Gem::Specification.find_all.each do |spec|
+          # Ignore specs that aren't in our installed list
+          next if !installed.include?(spec.name)
+
+          next if installed_versions[spec.name] &&
+            !installed_versions[spec.name].satisfied_by?(spec.version)
+
+          # If we already have a newer version in our list of installed,
+          # then ignore it
+          next if installed_map.key?(spec.name) &&
+            installed_map[spec.name].version >= spec.version
+
+          installed_map[spec.name] = spec
+        end
+
+        installed_map.values
+      end
+
+      # Loads the requested plugins into the Vagrant runtime
+      #
+      # @param [Hash] plugins List of plugins to load
+      # @return [nil]
+      def load_plugins(plugins)
+        if !Vagrant.plugins_enabled?
+          @logger.warn("Plugin loading is disabled")
+          return
+        end
+
+        if plugins.nil?
+          @logger.debug("No plugins provided for loading")
+          return
+        end
+
+        begin
+          @logger.info("Loading plugins...")
+          plugins.each do |plugin_name, plugin_info|
+            if plugin_info["require"].to_s.empty?
+              begin
+                @logger.info("Loading plugin `#{plugin_name}` with default require: `#{plugin_name}`")
+                require plugin_name
+              rescue LoadError => err
+                if plugin_name.include?("-")
+                  plugin_slash = plugin_name.gsub("-", "/")
+                  @logger.error("Failed to load plugin `#{plugin_name}` with default require. - #{err.class}: #{err}")
+                  @logger.info("Loading plugin `#{plugin_name}` with slash require: `#{plugin_slash}`")
+                  require plugin_slash
+                else
+                  raise
+                end
+              end
+            else
+              @logger.debug("Loading plugin `#{plugin_name}` with custom require: `#{plugin_info["require"]}`")
+              require plugin_info["require"]
+            end
+            @logger.debug("Successfully loaded plugin `#{plugin_name}`.")
+          end
+          if defined?(::Bundler)
+            @logger.debug("Bundler detected in use. Loading `:plugins` group.")
+            ::Bundler.require(:plugins)
+          end
+        rescue ScriptError, StandardError => err
+          @logger.error("Plugin loading error: #{err.class} - #{err}")
+          err.backtrace.each do |backtrace_line|
+            @logger.debug(backtrace_line)
+          end
+          raise Vagrant::Errors::PluginLoadError, message: err.to_s
+        end
+        nil
+      end
+
+      # Check if the requested plugin is installed
+      #
+      # @param [String] name Name of plugin
+      # @param [String] version Specific version of the plugin
+      # @return [Boolean]
+      def plugin_installed?(name, version=nil)
+        # Make the requirement object
+        version = Gem::Requirement.new([version.to_s]) if version
+
+        # If plugins are loaded, check for match in loaded specs
+        if ready?
+          return installed_specs.any? do |s|
+            match = s.name == name
+            next match if !version
+            next match && version.satisfied_by?(s.version)
+          end
+        end
+
+        # Plugins are not loaded yet so check installed plugin data
+        plugin_info = installed_plugins[name]
+        return false if !plugin_info
+        return !!plugin_info if version.nil? || plugin_info["installed_gem_version"].nil?
+        installed_version = Gem::Version.new(plugin_info["installed_gem_version"])
+        version.satisfied_by?(installed_version)
+      end
+    end
+  end
+end