vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/lib/vagrant/box.rb

@@ -57,12 +57,15 @@ module Vagrant
     # @param [Symbol] provider The provider that this box implements.
     # @param [Pathname] directory The directory where this box exists on
     #   disk.
-    def initialize(name, provider, version, directory, **opts)
+    # @param [String] metadata_url Metadata URL for box
+    # @param [Hook] hook A hook to apply to the box downloader, for example, for authentication
+    def initialize(name, provider, version, directory, metadata_url: nil, hook: nil)
       @name      = name
       @version   = version
       @provider  = provider
       @directory = directory
-      @metadata_url = opts[:metadata_url]
+      @metadata_url = metadata_url
+      @hook = hook
 
       metadata_file = directory.join("metadata.json")
       raise Errors::BoxMetadataFileNotFound, name: @name if !metadata_file.file?
@@ -120,7 +123,7 @@ module Vagrant
     #
     # @param [Hash] download_options Options to pass to the downloader.
     # @return [BoxMetadata]
-    def load_metadata(**download_options)
+    def load_metadata(download_options={})
       tf = Tempfile.new("vagrant-load-metadata")
       tf.close
 
@@ -132,7 +135,11 @@ module Vagrant
       end
 
       opts = { headers: ["Accept: application/json"] }.merge(download_options)
-      Util::Downloader.new(url, tf.path, **opts).download!
+      d = Util::Downloader.new(url, tf.path, opts)
+      if @hook
+        @hook.call(:authenticate_box_downloader, downloader: d)
+      end
+      d.download!
       BoxMetadata.new(File.open(tf.path, "r"))
     rescue Errors::DownloaderError => e
       raise Errors::BoxMetadataDownloadError,

data/lib/vagrant/box_collection.rb

@@ -325,7 +325,7 @@ module Vagrant
 
             return Box.new(
               name, provider, version_dir_map[v.to_s], provider_dir,
-              metadata_url: metadata_url,
+              metadata_url: metadata_url, hook: @hook
             )
           end
         end

data/lib/vagrant/bundler.rb

@@ -18,6 +18,155 @@ module Vagrant
   # Bundler as a way to properly resolve all dependencies of Vagrant and
   # all Vagrant-installed plugins.
   class Bundler
+    class SolutionFile
+      # @return [Pathname] path to plugin file
+      attr_reader :plugin_file
+      # @return [Pathname] path to solution file
+      attr_reader :solution_file
+      # @return [Array<Gem::Resolver::DependencyRequest>] list of required dependencies
+      attr_reader :dependency_list
+
+      # @param [Pathname] plugin_file Path to plugin file
+      # @param [Pathname] solution_file Custom path to solution file
+      def initialize(plugin_file:, solution_file: nil)
+        @logger = Log4r::Logger.new("vagrant::bundler::solution_file")
+        @plugin_file = Pathname.new(plugin_file.to_s)
+        if solution_file
+          @solution_file = Pathname.new(solution_file.to_s)
+        else
+          @solution_file = Pathname.new(@plugin_file.to_s + ".sol")
+        end
+        @valid = false
+        @dependency_list = [].freeze
+        @logger.debug("new solution file instance plugin_file=#{plugin_file} " \
+          "solution_file=#{solution_file}")
+        load
+      end
+
+      # Set the list of dependencies for this solution
+      #
+      # @param [Array<Gem::Dependency>] dependency_list List of dependencies for the solution
+      # @return [Array<Gem::Resolver::DependencyRequest>]
+      def dependency_list=(dependency_list)
+        Array(dependency_list).each do |d|
+          if !d.is_a?(Gem::Dependency)
+            raise TypeError, "Expected `Gem::Dependency` but received `#{d.class}`"
+          end
+        end
+        @dependency_list = dependency_list.map do |d|
+          Gem::Resolver::DependencyRequest.new(d, nil).freeze
+        end.freeze
+      end
+
+      # @return [Boolean] contained solution is valid
+      def valid?
+        @valid
+      end
+
+      # @return [FalseClass] invalidate this solution file
+      def invalidate!
+        @valid = false
+        @logger.debug("manually invalidating solution file #{self}")
+        @valid
+      end
+
+      # Delete the solution file
+      #
+      # @return [Boolean] true if file was deleted
+      def delete!
+        if !solution_file.exist?
+          @logger.debug("solution file does not exist. nothing to delete.")
+          return false
+        end
+        @logger.debug("deleting solution file - #{solution_file}")
+        solution_file.delete
+        true
+      end
+
+      # Store the solution file
+      def store!
+        if !plugin_file.exist?
+          @logger.debug("plugin file does not exist, not storing solution")
+          return
+        end
+        if !solution_file.dirname.exist?
+          @logger.debug("creating directory for solution file: #{solution_file.dirname}")
+          solution_file.dirname.mkpath
+        end
+        @logger.debug("writing solution file contents to disk")
+        solution_file.write({
+          dependencies: dependency_list.map { |d|
+            [d.dependency.name, d.dependency.requirements_list]
+          },
+          checksum: plugin_file_checksum,
+          vagrant_version: Vagrant::VERSION
+        }.to_json)
+        @valid = true
+      end
+
+      def to_s # :nodoc:
+        "<Vagrant::Bundler::SolutionFile:#{plugin_file}:" \
+          "#{solution_file}:#{valid? ? "valid" : "invalid"}>"
+      end
+
+      protected
+
+      # Load the solution file for the plugin path provided
+      # if it exists. Validate solution is still applicable
+      # before injecting dependencies.
+      def load
+        if !plugin_file.exist? || !solution_file.exist?
+          @logger.debug("missing file so skipping loading")
+          return
+        end
+        solution = read_solution || return
+        return if !valid_solution?(
+          checksum: solution[:checksum],
+          version: solution[:vagrant_version]
+        )
+        @logger.debug("loading solution dependency list")
+        @dependency_list = Array(solution[:dependencies]).map do |name, requirements|
+          gd = Gem::Dependency.new(name, requirements)
+          Gem::Resolver::DependencyRequest.new(gd, nil).freeze
+        end.freeze
+        @logger.debug("solution dependency list: #{dependency_list}")
+        @valid = true
+      end
+
+      # Validate the given checksum matches the plugin file
+      # checksum
+      #
+      # @param [String] checksum Checksum value to validate
+      # @return [Boolean]
+      def valid_solution?(checksum:, version:)
+        file_checksum = plugin_file_checksum
+        @logger.debug("solution validation check CHECKSUM #{file_checksum} <-> #{checksum}" \
+          " VERSION #{Vagrant::VERSION} <-> #{version}")
+        plugin_file_checksum == checksum &&
+          Vagrant::VERSION == version
+      end
+
+      # @return [String] checksum of plugin file
+      def plugin_file_checksum
+        digest = Digest::SHA256.new
+        digest.file(plugin_file.to_s)
+        digest.hexdigest
+      end
+
+      # Read contents of solution file and parse
+      #
+      # @return [Hash]
+      def read_solution
+        @logger.debug("reading solution file - #{solution_file}")
+        begin
+          hash = JSON.load(solution_file.read)
+          Vagrant::Util::HashWithIndifferentAccess.new(hash)
+        rescue => err
+          @logger.warn("failed to load solution file, ignoring (error: #{err})")
+          nil
+        end
+      end
+    end
 
     # Location of HashiCorp gem repository
     HASHICORP_GEMSTORE = "https://gems.hashicorp.com/".freeze
@@ -34,26 +183,19 @@ module Vagrant
 
     # @return [Pathname] Global plugin path
     attr_reader :plugin_gem_path
+    # @return [Pathname] Global plugin solution set path
+    attr_reader :plugin_solution_path
     # @return [Pathname] Vagrant environment specific plugin path
     attr_reader :env_plugin_gem_path
+    # @return [Pathname] Vagrant environment data path
+    attr_reader :environment_data_path
+    # @return [Array<Gem::Specification>, nil] List of builtin specs
+    attr_accessor :builtin_specs
 
     def initialize
+      @builtin_specs = []
       @plugin_gem_path = Vagrant.user_data_path.join("gems", RUBY_VERSION).freeze
       @logger = Log4r::Logger.new("vagrant::bundler")
-
-      # TODO: Remove fix when https://github.com/rubygems/rubygems/pull/2735
-      # gets merged and released
-      #
-      # Because of a rubygems bug, we need to set the gemrc file path
-      # through this method rather than relying on the environment varible
-      # GEMRC. On windows, that path gets split on `:`: and `;`, which means
-      # the drive letter gets treated as its own path. If that path exists locally,
-      # (like having a random folder called `c` where the library was invoked),
-      # it fails thinking the folder `c` is a gemrc file.
-      gemrc_val = ENV["GEMRC"]
-      ENV["GEMRC"] = ""
-      Gem.configuration = Gem::ConfigFile.new(["--config-file", gemrc_val])
-      ENV["GEMRC"] = gemrc_val
     end
 
     # Enable Vagrant environment specific plugins at given data path
@@ -61,12 +203,39 @@ module Vagrant
     # @param [Pathname] Path to Vagrant::Environment data directory
     # @return [Pathname] Path to environment specific gem directory
     def environment_path=(env_data_path)
+      if !env_data_path.is_a?(Pathname)
+        raise TypeError, "Expected `Pathname` but received `#{env_data_path.class}`"
+      end
       @env_plugin_gem_path = env_data_path.join("plugins", "gems", RUBY_VERSION).freeze
+      @environment_data_path = env_data_path
+    end
+
+    # Use the given options to create a solution file instance
+    # for use during initialization. When a Vagrant environment
+    # is in use, solution files will be stored within the environment's
+    # data directory. This is because the solution for loading global
+    # plugins is dependent on any solution generated for local plugins.
+    # When no Vagrant environment is in use (running Vagrant without a
+    # Vagrantfile), the Vagrant user data path will be used for solution
+    # storage since only the global plugins will be used.
+    #
+    # @param [Hash] opts Options passed to #init!
+    # @return [SolutionFile]
+    def load_solution_file(opts={})
+      return if !opts[:local] && !opts[:global]
+      return if opts[:local] && opts[:global]
+      return if opts[:local] && environment_data_path.nil?
+      solution_path = (environment_data_path || Vagrant.user_data_path) + "bundler"
+      solution_path += opts[:local] ? "local.sol" : "global.sol"
+      SolutionFile.new(
+        plugin_file: opts[:local] || opts[:global],
+        solution_file: solution_path
+      )
     end
 
     # Initializes Bundler and the various gem paths so that we can begin
     # loading gems.
-    def init!(plugins, repair=false)
+    def init!(plugins, repair=false, **opts)
       if !@initial_specifications
         @initial_specifications = Gem::Specification.find_all{true}
       else
@@ -74,45 +243,83 @@ module Vagrant
         Gem::Specification.reset
       end
 
-      # Add HashiCorp RubyGems source
-      if !Gem.sources.include?(HASHICORP_GEMSTORE)
-        sources = [HASHICORP_GEMSTORE] + Gem.sources.sources
-        Gem.sources.replace(sources)
+      solution_file = load_solution_file(opts)
+      @logger.debug("solution file in use for init: #{solution_file}")
+
+      solution = nil
+      composed_set = generate_vagrant_set
+
+      # Force the composed set to allow prereleases
+      if Vagrant.allow_prerelease_dependencies?
+        @logger.debug("enabling prerelease dependency matching due to user request")
+        composed_set.prerelease = true
       end
 
-      # Generate dependencies for all registered plugins
-      plugin_deps = plugins.map do |name, info|
-        Gem::Dependency.new(name, info['installed_gem_version'].to_s.empty? ? '> 0' : info['installed_gem_version'])
+      if solution_file&.valid?
+        @logger.debug("loading cached solution set")
+        solution = solution_file.dependency_list.map do |dep|
+          spec = composed_set.find_all(dep).first
+          if !spec
+            @logger.warn("failed to locate specification for dependency - #{dep}")
+            @logger.warn("invalidating solution file - #{solution_file}")
+            solution_file.invalidate!
+            break
+          end
+          dep_r = Gem::Resolver::DependencyRequest.new(dep, nil)
+          Gem::Resolver::ActivationRequest.new(spec, dep_r)
+        end
       end
 
-      @logger.debug("Current generated plugin dependency list: #{plugin_deps}")
+      if !solution_file&.valid?
+        @logger.debug("generating solution set for configured plugins")
+        # Add HashiCorp RubyGems source
+        if !Gem.sources.include?(HASHICORP_GEMSTORE)
+          sources = [HASHICORP_GEMSTORE] + Gem.sources.sources
+          Gem.sources.replace(sources)
+        end
 
-      # Load dependencies into a request set for resolution
-      request_set = Gem::RequestSet.new(*plugin_deps)
-      # Never allow dependencies to be remotely satisfied during init
-      request_set.remote = false
+        # Generate dependencies for all registered plugins
+        plugin_deps = plugins.map do |name, info|
+          Gem::Dependency.new(name, info['installed_gem_version'].to_s.empty? ? '> 0' : info['installed_gem_version'])
+        end
 
-      repair_result = nil
-      begin
-        # Compose set for resolution
-        composed_set = generate_vagrant_set
-        # Resolve the request set to ensure proper activation order
-        solution = request_set.resolve(composed_set)
-      rescue Gem::UnsatisfiableDependencyError => failure
-        if repair
-          raise failure if @init_retried
-          @logger.debug("Resolution failed but attempting to repair. Failure: #{failure}")
-          install(plugins)
-          @init_retried = true
-          retry
-        else
-          raise
+        @logger.debug("Current generated plugin dependency list: #{plugin_deps}")
+
+        # Load dependencies into a request set for resolution
+        request_set = Gem::RequestSet.new(*plugin_deps)
+        # Never allow dependencies to be remotely satisfied during init
+        request_set.remote = false
+
+        begin
+          @logger.debug("resolving solution from available specification set")
+          # Resolve the request set to ensure proper activation order
+          solution = request_set.resolve(composed_set)
+          @logger.debug("solution set for configured plugins has been resolved")
+        rescue Gem::UnsatisfiableDependencyError => failure
+          if repair
+            raise failure if @init_retried
+            @logger.debug("Resolution failed but attempting to repair. Failure: #{failure}")
+            install(plugins)
+            @init_retried = true
+            retry
+          else
+            raise
+          end
         end
       end
 
       # Activate the gems
+      @logger.debug("activating solution set")
       activate_solution(solution)
 
+      if solution_file && !solution_file.valid?
+        solution_file.dependency_list = solution.map do |activation|
+          activation.request.dependency
+        end
+        solution_file.store!
+        @logger.debug("solution set stored to - #{solution_file}")
+      end
+
       full_vagrant_spec_list = @initial_specifications +
         solution.map(&:full_spec)
 
@@ -287,7 +494,7 @@ module Vagrant
         if update[:gems] == true || (update[:gems].respond_to?(:include?) && update[:gems].include?(name))
           if Gem::Requirement.new(gem_version).exact?
             gem_version = "> 0"
-            @logger.debug("Detected exact version match for `#{name}` plugin update. Reset to loose constraint #{gem_version.inspect}.")
+            @logger.debug("Detected exact version match for `#{name}` plugin update. Reset to loosen constraint #{gem_version.inspect}.")
           end
           skips << name
         end
@@ -309,6 +516,9 @@ module Vagrant
         @logger.debug("Enabling strict dependency enforcement")
         plugin_deps += vagrant_internal_specs.map do |spec|
           next if system_plugins.include?(spec.name)
+          # If this spec is for a default plugin included in
+          # the ruby stdlib, ignore it
+          next if spec.default_gem?
           # If we are not running within the installer and
           # we are not within a bundler environment then we
           # only want activated specs
@@ -363,17 +573,25 @@ module Vagrant
         generate_builtin_set(system_plugins),
         generate_plugin_set(skips)
       )
+
+      if Vagrant.allow_prerelease_dependencies?
+        @logger.debug("enabling prerelease dependency matching based on user request")
+        request_set.prerelease = true
+        installer_set.prerelease = true
+      end
+
       @logger.debug("Generating solution set for installation.")
 
       # Generate the required solution set for new plugins
       solution = request_set.resolve(installer_set)
+
       activate_solution(solution)
 
       # Remove gems which are already installed
-      request_set.sorted_requests.delete_if do |activation_req|
-        rs_spec = activation_req.spec
-        if vagrant_internal_specs.detect{|ispec| ispec.name == rs_spec.name && ispec.version == rs_spec.version }
-          @logger.debug("Removing activation request from install. Already installed. (#{rs_spec.spec.full_name})")
+      request_set.sorted_requests.delete_if do |act_req|
+        rs = act_req.spec
+        if vagrant_internal_specs.detect{ |i| i.name == rs.name && i.version == rs.version }
+          @logger.debug("Removing activation request from install. Already installed. (#{rs.spec.full_name})")
           true
         end
       end
@@ -387,9 +605,11 @@ module Vagrant
       install_path = extra[:env_local] ? env_plugin_gem_path : plugin_gem_path
       result = request_set.install_into(install_path.to_s, true,
         ignore_dependencies: true,
-        prerelease: Vagrant.prerelease?,
-        wrappers: true
+        prerelease: Vagrant.prerelease? || Vagrant.allow_prerelease_dependencies?,
+        wrappers: true,
+        document: []
       )
+
       result = result.map(&:full_spec)
       result.each do |spec|
         existing_paths = $LOAD_PATH.find_all{|s| s.include?(spec.full_name) }
@@ -421,15 +641,35 @@ module Vagrant
     def vagrant_internal_specs
       # activate any dependencies up front so we can always
       # pin them when resolving
-      Gem::Specification.find { |s| s.name == "vagrant-unbundled" && s.activated? }.
-        runtime_dependencies.each { |d| gem d.name, *d.requirement.as_list }
+      self_spec = Gem::Specification.find { |s| s.name == "vagrant-unbundled" && s.activated? }
+      if !self_spec
+        @logger.warn("Failed to locate activated vagrant specification. Activating...")
+        self_spec = Gem::Specification.find { |s| s.name == "vagrant-unbundled" }
+        if !self_spec
+          @logger.error("Failed to locate Vagrant RubyGem specification")
+          raise Vagrant::Errors::SourceSpecNotFound
+        end
+        self_spec.activate
+        @logger.info("Activated vagrant specification version - #{self_spec.version}")
+      end
       # discover all the gems we have available
       list = {}
-      directories = [Gem::Specification.default_specifications_dir]
-      Gem::Specification.find_all{true}.each do |spec|
-        list[spec.full_name] = spec
+      if Gem.respond_to?(:default_specifications_dir)
+        spec_dir = Gem.default_specifications_dir
+      else
+        spec_dir = Gem::Specification.default_specifications_dir
       end
-      if(!defined?(::Bundler))
+      directories = [spec_dir]
+      if Vagrant.in_bundler?
+        Gem::Specification.find_all{true}.each do |spec|
+          list[spec.full_name] = spec
+        end
+      else
+        builtin_specs.each do |spec|
+          list[spec.full_name] = spec
+        end
+      end
+      if Vagrant.in_installer?
         directories += Gem::Specification.dirs.find_all do |path|
           !path.start_with?(Gem.user_dir)
         end
@@ -528,7 +768,6 @@ module Vagrant
               request.name == matcher["gem_name"]
             end
             if desired_activation_request && !desired_activation_request.full_spec.activated?
-              activation_request = desired_activation_request
               @logger.warn("Found misordered activation request for #{desired_activation_request.full_name}. Moving to solution HEAD.")
               solution.delete(desired_activation_request)
               solution.unshift(desired_activation_request)
@@ -600,12 +839,22 @@ module Vagrant
       end
 
       def find_all(req)
-        @specs.select do |spec|
-          allow_prerelease = spec.name == "vagrant-unbundled" && Vagrant.prerelease?
-          req.match?(spec, allow_prerelease)
+        r = @specs.select do |spec|
+          # When matching requests against builtin specs, we _always_ enable
+          # prerelease matching since any prerelease that's found in this
+          # set has been added explicitly and should be available for all
+          # plugins to resolve against. This includes Vagrant itself since
+          # it is considered a prerelease when in development mode
+          req.match?(spec, true)
         end.map do |spec|
           Gem::Resolver::InstalledSpecification.new(self, spec)
         end
+        # If any of the results are a prerelease, we need to mark the request
+        # to allow prereleases so the solution can be properly fulfilled
+        if r.any? { |x| x.version.prerelease? }
+          req.dependency.prerelease = true
+        end
+        r
       end
     end
 
@@ -639,7 +888,7 @@ module Vagrant
       # DependencyRequest +req+.
       def find_all(req)
         @specs.values.flatten.select do |spec|
-          req.match?(spec)
+          req.match?(spec, prerelease)
         end.map do |spec|
           source = Gem::Source::Vendor.new(@directories[spec])
           Gem::Resolver::VendorSpecification.new(self, spec, source)
@@ -649,7 +898,7 @@ module Vagrant
       ##
       # Loads a spec with the given +name+. +version+, +platform+ and +source+ are
       # ignored.
-      def load_spec (name, version, platform, source)
+      def load_spec(name, version, platform, source)
         version = Gem::Version.new(version) if !version.is_a?(Gem::Version)
         @specs.fetch(name, []).detect{|s| s.name == name && s.version == version}
       end