vagrant-unbundled 2.2.19.0 → 2.3.2.0

data/lib/vagrant/action/builder.rb

@@ -28,6 +28,36 @@ module Vagrant
       # @return [Array]
       attr_reader :stack
 
+      # Action Hooks allow plugin authors to inject their code wherever they
+      # want in the action stack. The methods they get are:
+      #
+      #   - prepend/append, which puts their middleware at the beginning or end
+      #     of the whole stack
+      #   - before/after, which attaches their middleware to an existing item
+      #     in the stack
+      #
+      # Applying Action Hooks properly gets tricky because the action stack
+      # becomes deeply nested with things like Action::Builtin::Call and
+      # Builder#use(other_builder). The way it breaks down is:
+      #
+      #  - prepend/append hooks should be applied only at the top level stack,
+      #    so they run once at the beginning or end
+      #  - before/after hooks should be applied in every sub-builder, because
+      #    they will only actually attach if they find their target sibling
+      #
+      # We achieve this behavior by tracking if we are a "primary" Builder, and
+      # only running prepend/append operations when we are.
+      #
+      # Note this difference only applies to action_hooks registered with
+      # machine action names and not action_hooks which reference middleware
+      # directly, which only support prepend/append and are handled in
+      # #apply_dynamic_updates.
+      #
+      # @return [Boolean] true if this is a primary / top-level Builder
+      # @see Vagrant::Action::PrimaryRunner
+      # @see Vagrant::Action::Hook
+      attr_accessor :primary
+
       # This is a shortcut for a middleware sequence with only one item
       # in it. For a description of the arguments and the documentation, please
       # see {#use} instead.
@@ -39,6 +69,7 @@ module Vagrant
 
       def initialize
         @stack = []
+        @logger = Log4r::Logger.new("vagrant::action::builder")
       end
 
       # Implement a custom copy that copies the stack variable over so that
@@ -311,7 +342,11 @@ module Vagrant
         return self if hook.empty?
 
         # Apply all the hooks to the new builder instance
-        hook.apply(self)
+        hook.apply(self, {
+          # Only primary builders run prepend/append, otherwise nested builders
+          # would duplicate hooks. See explanation at self#primary.
+          no_prepend_or_append: !primary,
+        })
 
         self
       end

data/lib/vagrant/action/builtin/box_add.rb

@@ -205,7 +205,7 @@ module Vagrant
             return if @download_interrupted
 
             File.open(metadata_path) do |f|
-              metadata = BoxMetadata.new(f)
+              metadata = BoxMetadata.new(f, url: authenticated_url)
             end
           rescue Errors::DownloaderError => e
             raise if !expanded
@@ -518,7 +518,7 @@ module Vagrant
                   return false
                 end
 
-                BoxMetadata.new(f)
+                BoxMetadata.new(f, url: url)
               end
               return true
             rescue Errors::BoxMetadataMalformed

data/lib/vagrant/action/builtin/mixin_synced_folders.rb

@@ -7,6 +7,8 @@ module Vagrant
   module Action
     module Builtin
       module MixinSyncedFolders
+        autoload :Remote, "vagrant/action/builtin/remote/mixin_synced_folders"
+
         include Vagrant::Util::ScopedHashOverride
 
         # This goes over all the registered synced folder types and returns

data/lib/vagrant/action/builtin/remote/mixin_synced_folders.rb

@@ -0,0 +1,39 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This module enables MixinSyncedFolder for server mode
+      module Remote
+
+        module MixinSyncedFolders
+          # Add an attribute accesor for the basis_client
+          # when applied to the MixinSyncedFolders class
+          def self.prepended(klass)
+            klass.class_eval do
+              attr_accessor :basis_client
+            end
+          end
+
+          # This should never be called?
+          def default_synced_folder_type(machine, plugins)
+            nil
+          end
+
+          # Synced folder management happens on the vagrant server. 
+          # Do nothing here
+          def save_synced_folders(machine, folders, opts={})
+            nil
+          end
+
+          # This returns the set of shared folders that should be done for
+          # this machine. It returns the folders in a hash keyed by the
+          # implementation class for the synced folders.
+          #
+          # @return [Hash<Symbol, Hash<String, Hash>>]
+          def synced_folders(machine, **opts)
+            machine.synced_folders
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/remote/ssh_run.rb

@@ -0,0 +1,18 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This module enables SSHRun for server mode
+      module Remote
+        module SSHRun
+          def _raw_ssh_exec(env, info, opts)
+            # The Util::SSH package in remote mode expects to be able to
+            # interact with a UI instead of raw stdin/stderr so the action
+            # needs to pass that down.
+            opts[:ui] = env[:ui]
+            super(env, info, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_run.rb

@@ -70,11 +70,15 @@ module Vagrant
 
           opts[:extra_args] << command
           opts[:subprocess] = true
-          env[:ssh_run_exit_status] = Util::SSH.exec(info, opts)
+          env[:ssh_run_exit_status] = _raw_ssh_exec(env, info, opts)
 
           # Call the next middleware
           @app.call(env)
         end
+
+        def _raw_ssh_exec(env, info, opts)
+          Util::SSH.exec(info, opts)
+        end
       end
     end
   end

data/lib/vagrant/action/primary_runner.rb

@@ -0,0 +1,15 @@
+module Vagrant
+  module Action
+    # A PrimaryRunner is a special kind of "top-level" Action::Runner - it
+    # informs any Action::Builders it interacts with that they are also
+    # primary. This allows Builders to distinguish whether or not they are
+    # nested, which they need to know for proper action_hook handling.
+    #
+    # @see Vagrant::Action::Builder#primary
+    class PrimaryRunner < Runner
+      def primary?
+        true
+      end
+    end
+  end
+end

data/lib/vagrant/action/runner.rb

@@ -9,12 +9,20 @@ module Vagrant
     class Runner
       @@reported_interrupt = false
 
+      # @param globals [Hash] variables for the env to be passed to the action
+      # @yieldreturn [Hash] lazy-loaded vars merged into the env before action run
       def initialize(globals=nil, &block)
         @globals      = globals || {}
         @lazy_globals = block
         @logger       = Log4r::Logger.new("vagrant::action::runner")
       end
 
+      # @see PrimaryRunner
+      # @see Vagrant::Action::Builder#primary
+      def primary?
+        false
+      end
+
       def run(callable_id, options=nil)
         callable = callable_id
         if !callable.kind_of?(Builder)
@@ -28,6 +36,10 @@ module Vagrant
             "Argument to run must be a callable object or registered action."
         end
 
+        if callable.is_a?(Builder)
+          callable.primary = self.primary?
+        end
+
         # Create the initial environment with the options given
         environment = {}
         environment.merge!(@globals)

data/lib/vagrant/action.rb

@@ -2,14 +2,20 @@ require 'vagrant/action/builder'
 
 module Vagrant
   module Action
-    autoload :Builder,     'vagrant/action/builder'
-    autoload :Hook,        'vagrant/action/hook'
-    autoload :Runner,      'vagrant/action/runner'
-    autoload :Warden,      'vagrant/action/warden'
+    autoload :Builder,       'vagrant/action/builder'
+    autoload :Hook,          'vagrant/action/hook'
+    autoload :Runner,        'vagrant/action/runner'
+    autoload :PrimaryRunner, 'vagrant/action/primary_runner'
+    autoload :Warden,        'vagrant/action/warden'
 
     # Builtin contains middleware classes that are shipped with Vagrant-core
     # and are thus available to all plugins as a "standard library" of sorts.
     module Builtin
+      module Remote
+        autoload :MixinSyncedFolders, "vagrant/action/builtin/remote/mixin_synced_folders"
+        autoload :SSHRun, "vagrant/action/builtin/remote/ssh_run"
+      end
+
       autoload :BoxAdd,    "vagrant/action/builtin/box_add"
       autoload :BoxCheckOutdated, "vagrant/action/builtin/box_check_outdated"
       autoload :BoxRemove, "vagrant/action/builtin/box_remove"

data/lib/vagrant/box/remote.rb

@@ -0,0 +1,80 @@
+module Vagrant
+  class Box
+    # This module enables the Box for server mode
+    module Remote
+
+      # Add an attribute reader for the client
+      # when applied to the Box class
+      def self.prepended(klass)
+        klass.class_eval do
+          attr_reader :client
+        end
+      end
+
+      # This is used to initialize a box.
+      #
+      # @param [String] name Logical name of the box.
+      # @param [Symbol] provider The provider that this box implements.
+      # @param [Pathname] directory The directory where this box exists on
+      #   disk.
+      # @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, client: nil)
+        @logger = Log4r::Logger.new("vagrant::box")
+
+        @name      = name
+        @version   = version
+        @provider  = provider
+        @directory = directory
+        @metadata_url = metadata_url
+        @hook = hook
+
+        if client.nil?
+          raise ArgumentError,
+            "Remote client is required for `#{self.class.name}'"
+        end
+        @client = client
+        @metadata = client.box_metadata
+      end
+
+      def destroy!
+        client.destroy
+      end
+
+      def in_use?(index)
+        client.machines(index.to_proto)
+      end
+
+      def has_update?(version=nil, **opts)
+        update_info = client.update_info(version)
+        if update_info.nil?
+          return nil
+        end
+        metadata = update_info[0]
+        new_version = update_info[1]
+        new_provider = update_info[2]
+        [
+          BoxMetadata.new(nil, client: metadata),
+          BoxMetadata::Version.new({"version" => new_version}, ver: new_version, client: metadata), 
+          BoxMetadata::Provider.new({"name" => new_provider}, client: metadata),
+        ]
+      end
+
+      def automatic_update_check_allowed?
+        client.automatic_update_check_allowed
+      end
+
+      def repackage(path)
+        client.repackage(path)
+      end
+
+      def <=>(other)
+        client.compare(other.to_proto)
+      end
+
+      def to_proto
+        client.proto
+      end
+    end
+  end
+end

data/lib/vagrant/box.rb

@@ -16,6 +16,11 @@ module Vagrant
   class Box
     include Comparable
 
+    autoload :Remote, "vagrant/box/remote"
+
+    # The required fields in a boxes `metadata.json` file
+    REQUIRED_METADATA_FIELDS = ["provider"]
+
     # Number of seconds to wait between checks for box updates
     BOX_UPDATE_CHECK_INTERVAL = 3600
 
@@ -72,6 +77,7 @@ module Vagrant
 
       begin
         @metadata = JSON.parse(directory.join("metadata.json").read)
+        validate_metadata_json(@metadata)
       rescue JSON::ParserError
         raise Errors::BoxMetadataCorrupted, name: @name
       end
@@ -79,6 +85,18 @@ module Vagrant
       @logger = Log4r::Logger.new("vagrant::box")
     end
 
+    def validate_metadata_json(metadata)
+      metatdata_fields = metadata.keys
+      REQUIRED_METADATA_FIELDS.each do |field|
+        if !metatdata_fields.include?(field)
+          raise Errors::BoxMetadataMissingRequiredFields,
+            name: @name,
+            required_field: field,
+            all_fields: REQUIRED_METADATA_FIELDS.join(", ")
+        end
+      end
+    end
+
     # This deletes the box. This is NOT undoable.
     def destroy!
       # Delete the directory to delete the box.
@@ -140,7 +158,7 @@ module Vagrant
         @hook.call(:authenticate_box_downloader, downloader: d)
       end
       d.download!
-      BoxMetadata.new(File.open(tf.path, "r"))
+      BoxMetadata.new(File.open(tf.path, "r"), url: url)
     rescue Errors::DownloaderError => e
       raise Errors::BoxMetadataDownloadError,
         message: e.extra_data[:message]

data/lib/vagrant/box_collection/remote.rb

@@ -0,0 +1,53 @@
+module Vagrant
+  class BoxCollection
+    # This module enables the BoxCollection for server mode
+    module Remote
+
+      # Add an attribute reader for the client
+      # when applied to the BoxCollection class
+      def self.prepended(klass)
+        klass.class_eval do
+          attr_reader :client
+        end
+      end
+     
+      def initialize(directory, options=nil)
+        @client = options[:client]
+        if @client.nil?
+          raise ArgumentError,
+            "Remote client is required for `#{self.class.name}'"
+        end
+        @hook      = options[:hook]
+        @logger    = Log4r::Logger.new("vagrant::box_collection")
+      end
+
+      # @return [Vagrant::Box]
+      def add(path, name, version, **opts)
+        client.add(
+          path, name, version, opts[:force], opts[:metadata_url], opts[:providers]
+        )
+      end
+
+
+      # @return [Array] Array of `[name, version, provider]` of the boxes
+      #   installed on this system.
+      def all
+        all_boxes = client.all
+        boxes = []
+        all_boxes.each do |b|
+          boxes << [b.name, b.version, b.provider]
+        end
+        boxes
+      end
+
+      # @return [Box] The box found, or `nil` if not found.
+      def find(name, providers, version)
+        client.find(name, providers, version)
+      end
+
+      def clean(name)
+        client.clean(name)
+      end
+    end
+  end
+end

data/lib/vagrant/box_collection.rb

@@ -17,6 +17,8 @@ module Vagrant
     VAGRANT_SLASH = "-VAGRANTSLASH-".freeze
     VAGRANT_COLON = "-VAGRANTCOLON-".freeze
 
+    autoload :Remote, "vagrant/box_collection/remote"
+
     # The directory where the boxes in this collection are stored.
     #
     # A box collection matches a very specific folder structure that Vagrant
@@ -274,7 +276,12 @@ module Vagrant
 
       # Build up the requirements we have
       requirements = version.to_s.split(",").map do |v|
-        Gem::Requirement.new(v.strip)
+        begin
+          Gem::Requirement.new(v.strip)
+        rescue Gem::Requirement::BadRequirementError
+          raise Errors::BoxVersionInvalid,
+                version: v.strip
+        end
       end
 
       with_collection_lock do

data/lib/vagrant/box_metadata/remote.rb

@@ -0,0 +1,97 @@
+module Vagrant
+  class BoxMetadata
+    # This module enables the BoxMetadata for server mode
+    module Remote
+
+      # Add an attribute reader for the client
+      # when applied to the BoxMetadata class
+      def self.prepended(klass)
+        klass.class_eval do
+          attr_reader :client
+        end
+      end
+
+      attr_accessor :name
+      attr_accessor :description
+
+      # @param [IO] io An IO object to read the metadata from.
+      def initialize(io, url: nil, client: nil)
+        @logger = Log4r::Logger.new("vagrant::box")
+
+        if !client.nil? 
+          # Use client if available
+          @client = client
+        else
+          # If client is not available, then try to load from url
+          if url.nil?
+            raise ArgumentError,
+              "Metadata URL is required for `#{self.class.name}' if a client is not provided"
+          end
+          @client = Vagrant.plugin("2").remote_manager.core_plugin_manager.get_plugin("boxmetadata")
+          @client.load_metadata(url)
+        end
+        @name = @client.name
+      end
+
+      def version(version, **opts)
+        providers = nil
+        providers = Array(opts[:provider]) || []
+
+        v = @client.version(version, providers)
+        Version.new(v, ver: v[:version], client: @client)
+      end
+
+      def versions(**opts)
+        provider = nil
+        provider = opts[:provider].to_sym if opts[:provider]
+        v = @client.list_versions(provider)
+        # Sort so the last element of the list is the latest version. 
+        v.sort.map(&:to_s)
+      end
+
+      class Version
+        attr_accessor :version
+
+        def initialize(raw=nil, ver: nil, client: nil)
+          return if raw.nil?
+          @logger = Log4r::Logger.new("vagrant::box::version")
+
+          @version = ver
+          if client.nil?
+            raise ArgumentError,
+              "Remote client is required for `#{self.class.name}'"
+          end
+          @client = client
+        end
+
+        def provider(name)
+          p = @client.provider(@version, name)
+          Provider.new(p, client: @client)
+        end
+
+        def providers
+          @client.list_providers(@version)
+        end
+
+        class Provider
+          attr_accessor :name
+          attr_accessor :url
+          attr_accessor :checksum
+          attr_accessor :checksum_type
+
+          def initialize(raw, client: nil)
+            @name = raw[:name]
+            @url  = raw[:url]
+            @checksum = raw[:checksum]
+            @checksum_type = raw[:checksum_type]
+            if client.nil?
+              raise ArgumentError,
+                "Remote client is required for `#{self.class.name}'"
+            end
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/box_metadata.rb

@@ -5,6 +5,9 @@ module Vagrant
   # it should have, a description of it, the versions it has, and
   # more.
   class BoxMetadata
+
+    autoload :Remote, "vagrant/box_metadata/remote"
+
     # The name that the box should be if it is added.
     #
     # @return [String]
@@ -19,7 +22,7 @@ module Vagrant
     # IO.
     #
     # @param [IO] io An IO object to read the metadata from.
-    def initialize(io)
+    def initialize(io, **_)
       begin
         @raw = JSON.load(io)
       rescue JSON::ParserError => e
@@ -96,7 +99,7 @@ module Vagrant
       # @return [String]
       attr_accessor :version
 
-      def initialize(raw=nil)
+      def initialize(raw=nil, **_)
         return if !raw
 
         @version = raw["version"]
@@ -146,7 +149,7 @@ module Vagrant
       # @return [String]
       attr_accessor :checksum_type
 
-      def initialize(raw)
+      def initialize(raw, **_)
         @name = raw["name"]
         @url  = raw["url"]
         @checksum = raw["checksum"]

data/lib/vagrant/bundler.rb

@@ -258,7 +258,12 @@ module Vagrant
       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
+          spec = composed_set.find_all(dep).select do |dep_spec|
+            next(true) unless Gem.loaded_specs.has_key?(dep_spec.name)
+
+            Gem.loaded_specs[dep_spec.name].version.eql?(dep_spec.version)
+          end.first
+
           if !spec
             @logger.warn("failed to locate specification for dependency - #{dep}")
             @logger.warn("invalidating solution file - #{solution_file}")

data/lib/vagrant/config/loader.rb

@@ -86,7 +86,7 @@ module Vagrant
 
         unknown_sources = @sources.keys - order
         if !unknown_sources.empty?
-          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
+          @logger.warn("Unknown config sources: #{unknown_sources.inspect}")
         end
 
         # Get the current version config class to use
@@ -200,6 +200,51 @@ module Vagrant
         [current_config_klass.finalize(result), warnings, errors]
       end
 
+      # This method is used for doing partial loads of the
+      # Vagrantfile. It will load the contents of a single
+      # location and return the config. No merging is performed
+      # and no finalization is applied.
+      #
+      # @param key [Symbol] name of location
+      # @return [Object] configuration
+      # @note: This will load either version, but we assume a v2 result
+      # @todo(spox): check version and raise error on v1
+      def partial_load(key)
+        raise KeyError,
+              "Unknown path key provided (#{key})" if !@sources.key?(key)
+
+        version, proc = @sources[key].first
+        @logger.debug("Loading from: #{key} (evaluating)")
+
+        # Get the proper version loader for this version and load
+        version_loader = @versions.get(version)
+        raise KeyError,
+              "Failed to create loader for requested version: #{version}" if version_loader.nil?
+
+        begin
+          version_config = version_loader.load(proc)
+        rescue NameError => e
+          line = "(unknown)"
+          path = "(unknown)"
+          if e.backtrace && e.backtrace[0]
+            backtrace_tokens = e.backtrace[0].split(":")
+            path = e.backtrace.first.slice(0, e.backtrace.first.rindex(':')).rpartition(':').first
+            backtrace_tokens.each do |part|
+              if part =~ /\d+/
+                line = part.to_i
+                break
+              end
+            end
+          end
+
+          raise Errors::VagrantfileNameError,
+                path: path,
+                line: line,
+                message: e.message.sub(/' for .*$/, "'") + "\n#{e.backtrace.join("\n")}" + "\nVersion #{version.inspect} loader: #{version_loader.inspect} versions: #{@versions.inspect}"
+        end
+        version_config
+      end
+
       protected
 
       # This returns an array of `Proc` objects for the given source.