vagrant-unbundled 2.2.6.1 → 2.2.10.0

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

@@ -0,0 +1,36 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware is used with Call to test if this machine
+      # has available provisioners
+      class HasProvisioner
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::has_provisioner")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          if machine.provider.capability?(:has_communicator)
+            has_communicator = machine.provider.capability(:has_communicator)
+          else
+            has_communicator = true
+          end
+
+          env[:skip] = []
+          if !has_communicator
+            machine.config.vm.provisioners.each do |p|
+              if p.communicator_required
+                env[:skip].push(p)
+                @logger.info("Skipping running provisioner #{p.name || 'no name'}, type: #{p.type}")
+                p.run = :never
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -25,12 +25,31 @@ module Vagrant
             # Store in the type map so that --provision-with works properly
             @_provisioner_types[result] = provisioner.type
 
+            # Set top level provisioner name to provisioner configs name if top level name not set.
+            # This is mostly for handling the shell provisioner, if a user has set its name like:
+            #
+            #   config.vm.provision "shell", name: "my_provisioner"
+            #
+            # Where `name` is a shell config option, not a top level provisioner class option
+            #
+            # Note: `name` is set to a symbol, since it is converted to one via #Config::VM.provision
+            provisioner_name = provisioner.name
+            if !provisioner_name
+              if provisioner.config.respond_to?(:name) &&
+                  provisioner.config.name
+                provisioner_name = provisioner.config.name.to_sym
+              end
+            else
+              provisioner_name = provisioner_name.to_sym
+            end
+
             # Build up the options
             options = {
-              name: provisioner.name,
+              name: provisioner_name,
               run:  provisioner.run,
               before:  provisioner.before,
               after:  provisioner.after,
+              communicator_required: provisioner.communicator_required,
             }
 
             # Return the result

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

@@ -72,7 +72,7 @@ module Vagrant
         #
         # @param [Machine] machine The machine that the folders belong to
         # @param [Hash] folders The result from a {#synced_folders} call.
-        def save_synced_folders(machine, folders, **opts)
+        def save_synced_folders(machine, folders, opts={})
           if opts[:merge]
             existing = cached_synced_folders(machine)
             if existing
@@ -97,11 +97,8 @@ module Vagrant
             end
           end
 
-          folder_data = JSON.dump(folders)
-
-          # Scrub any register credentials from the synced folders
-          # configuration data to prevent accidental leakage
-          folder_data = Util::CredentialScrubber.desensitize(folder_data)
+          # Remove implementation instances
+          folder_data = JSON.dump(folders.to_h)
 
           machine.data_dir.join("synced_folders").open("w") do |f|
             f.write(folder_data)
@@ -124,7 +121,7 @@ module Vagrant
           end
 
           config_folders = config.synced_folders
-          folders = {}
+          folders = Vagrant::Plugin::V2::SyncedFolder::Collection.new
 
           # Determine all the synced folders as well as the implementation
           # they're going to use.
@@ -181,8 +178,10 @@ module Vagrant
 
           # Apply the scoped hash overrides to get the options
           folders.dup.each do |impl_name, fs|
+            impl = plugins[impl_name].first.new._initialize(machine, impl_name)
             new_fs = {}
             fs.each do |id, data|
+              data[:plugin] = impl
               id         = data[:id] if data[:id]
               new_fs[id] = scoped_hash_override(data, impl_name)
             end
@@ -190,7 +189,7 @@ module Vagrant
             folders[impl_name] = new_fs
           end
 
-          return folders
+          folders
         end
 
         # This finds the difference between two lists of synced folder
@@ -239,26 +238,26 @@ module Vagrant
         protected
 
         def cached_synced_folders(machine)
-          JSON.parse(machine.data_dir.join("synced_folders").read).tap do |r|
-            # We have to do all sorts of things to make the proper things
-            # symbols and
-            r.keys.each do |k|
-              r[k].each do |ik, v|
-                v.keys.each do |vk|
-                  v[vk.to_sym] = v[vk]
-                  v.delete(vk)
-                end
+          import = JSON.parse(machine.data_dir.join("synced_folders").read)
+          import.each do |type, folders|
+            impl = plugins[type.to_sym].first.new._initialize(machine, type.to_sym)
+            folders.each { |_, v| v[:plugin] = impl }
+          end
+          # Symbolize the keys we want as symbols
+          import.keys.dup.each do |k|
+            import[k].values.each do |item|
+              item.keys.dup.each do |ik|
+                item[ik.to_sym] = item.delete(ik)
               end
-
-              r[k.to_sym] = r[k]
-              r.delete(k)
             end
+            import[k.to_sym] = import.delete(k)
           end
+          Vagrant::Plugin::V2::SyncedFolder::Collection[import]
         rescue Errno::ENOENT
           # If the file doesn't exist, we probably just have a machine created
           # by a version of Vagrant that didn't cache shared folders. Report no
           # shared folders to be safe.
-          return {}
+          Vagrant::Plugin::V2::SyncedFolder::Collection.new
         end
       end
     end

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

@@ -10,15 +10,19 @@ module Vagrant
       class SetHostname
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::set_hostname")
         end
 
         def call(env)
           @app.call(env)
 
           hostname = env[:machine].config.vm.hostname
-          if !hostname.nil?
+          allow_hosts_modification = env[:machine].config.vm.allow_hosts_modification
+          if !hostname.nil? && allow_hosts_modification
             env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
             env[:machine].guest.capability(:change_host_name, hostname)
+          else
+            @logger.info("`allow_hosts_modification` set to false. Hosts modification has been disabled, skiping changing hostname.")
           end
         end
       end

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

@@ -36,17 +36,35 @@ module Vagrant
 
           # Get the command and wrap it in a login shell
           command = ShellQuote.escape(env[:ssh_run_command], "'")
-          command = "#{env[:machine].config.ssh.shell} -c '#{command}'"
+
+          if env[:machine].config.vm.communicator == :winssh
+            shell = env[:machine].config.winssh.shell
+          else
+            shell = env[:machine].config.ssh.shell
+          end
+
+          if shell == "cmd"
+            # Add an extra space to the command so cmd.exe quoting works
+            # properly
+            command = "#{shell} /C #{command} "
+          elsif shell == "powershell"
+            command = "$ProgressPreference = \"SilentlyContinue\"; #{command}"
+            command = Base64.strict_encode64(command.encode("UTF-16LE", "UTF-8"))
+            command = "#{shell} -encodedCommand #{command}"
+          else
+            command = "#{shell} -c '#{command}'"
+          end
 
           # Execute!
           opts = env[:ssh_opts] || {}
           opts[:extra_args] ||= []
 
           # Allow the user to specify a tty or non-tty manually, but if they
-          # don't then we default to a TTY
+          # don't then we default to a TTY unless they are using WinSSH
           if !opts[:extra_args].include?("-t") &&
               !opts[:extra_args].include?("-T") &&
-              env[:tty]
+              env[:tty] &&
+              env[:machine].config.vm.communicator != :winssh
             opts[:extra_args] << "-t"
           end
 

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

@@ -128,6 +128,16 @@ module Vagrant
             # Save the synced folders
             save_synced_folders(env[:machine], original_folders, **save_opts)
           end
+
+          # Persist the mounts by adding them to fstab
+          if env[:machine].guest.capability?(:persist_mount_shared_folder)
+            if env[:machine].config.vm.allow_fstab_modification
+              fstab_folders = original_folders
+            else
+              fstab_folders = nil
+            end
+            env[:machine].guest.capability(:persist_mount_shared_folder, fstab_folders)
+          end
         end
       end
     end

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

@@ -0,0 +1,37 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This class is used within the Builder class for injecting triggers into
+      # different parts of the call stack.
+      class Trigger
+        # @param [Class, String, Symbol] name Name of trigger to fire
+        # @param [Vagrant::Plugin::V2::Triger] triggers Trigger object
+        # @param [Symbol] timing When trigger should fire (:before/:after)
+        # @param [Symbol] type Type of trigger
+        def initialize(app, env, name, triggers, timing, type=:action, all: false)
+          @app         = app
+          @env         = env
+          @triggers    = triggers
+          @name        = name
+          @timing      = timing
+          @type        = type
+          @all         = all
+
+          if ![:before, :after].include?(timing)
+            raise ArgumentError,
+              "Invalid value provided for `timing` (allowed: :before or :after)"
+          end
+        end
+
+        def call(env)
+          machine = env[:machine]
+          machine_name = machine.name if machine
+
+          @triggers.fire(@name, @timing, machine_name, @type, all: @all)
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/hook.rb

@@ -7,23 +7,23 @@ module Vagrant
       # This is a hash of the middleware to prepend to a certain
       # other middleware.
       #
-      # @return [Hash<Class, Array<Class>>]
+      # @return [Hash<Class, Array<Builder::StackItem>>]
       attr_reader :before_hooks
 
       # This is a hash of the middleware to append to a certain other
       # middleware.
       #
-      # @return [Hash<Class, Array<Class>>]
+      # @return [Hash<Class, Array<Builder::StackItem>>]
       attr_reader :after_hooks
 
       # This is a list of the hooks to just prepend to the beginning
       #
-      # @return [Array<Class>]
+      # @return [Array<Builder::StackItem>]
       attr_reader :prepend_hooks
 
       # This is a list of the hooks to just append to the end
       #
-      # @return [Array<Class>]
+      # @return [Array<Builder::StackItem>]
       attr_reader :append_hooks
 
       def initialize
@@ -37,16 +37,32 @@ module Vagrant
       #
       # @param [Class] existing The existing middleware.
       # @param [Class] new The new middleware.
-      def before(existing, new, *args, &block)
-        @before_hooks[existing] << [new, args, block]
+      def before(existing, new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @before_hooks[existing] << item
       end
 
       # Add a middleware after an existing middleware.
       #
       # @param [Class] existing The existing middleware.
       # @param [Class] new The new middleware.
-      def after(existing, new, *args, &block)
-        @after_hooks[existing] << [new, args, block]
+      def after(existing, new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @after_hooks[existing] << item
       end
 
       # Append a middleware to the end of the stack. Note that if the
@@ -54,33 +70,68 @@ module Vagrant
       # be run.
       #
       # @param [Class] new The middleware to append.
-      def append(new, *args, &block)
-        @append_hooks << [new, args, block]
+      def append(new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @append_hooks << item
       end
 
       # Prepend a middleware to the beginning of the stack.
       #
       # @param [Class] new The new middleware to prepend.
-      def prepend(new, *args, &block)
-        @prepend_hooks << [new, args, block]
+      def prepend(new, *args, **keywords, &block)
+        item = Builder::StackItem.new(
+          middleware: new,
+          arguments: Builder::MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+        @prepend_hooks << item
+      end
+
+      # @return [Boolean]
+      def empty?
+        before_hooks.empty? &&
+          after_hooks.empty? &&
+          prepend_hooks.empty? &&
+          append_hooks.empty?
       end
 
       # This applies the given hook to a builder. This should not be
       # called directly.
       #
       # @param [Builder] builder
-      def apply(builder, options=nil)
-        options ||= {}
-
+      def apply(builder, options={})
         if !options[:no_prepend_or_append]
           # Prepends first
-          @prepend_hooks.each do |klass, args, block|
-            builder.insert(0, klass, *args, &block)
+          @prepend_hooks.each do |item|
+            if options[:root]
+              idx = builder.index(options[:root])
+            else
+              idx = 0
+            end
+            builder.insert(idx, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
           end
 
           # Appends
-          @append_hooks.each do |klass, args, block|
-            builder.use(klass, *args, &block)
+          @append_hooks.each do |item|
+            if options[:root]
+              idx = builder.index(options[:root])
+              builder.insert(idx + 1, item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
+            else
+              builder.use(item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
+            end
           end
         end
 
@@ -88,8 +139,9 @@ module Vagrant
         @before_hooks.each do |key, list|
           next if !builder.index(key)
 
-          list.each do |klass, args, block|
-            builder.insert_before(key, klass, *args, &block)
+          list.each do |item|
+            builder.insert_before(key, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
           end
         end
 
@@ -97,8 +149,9 @@ module Vagrant
         @after_hooks.each do |key, list|
           next if !builder.index(key)
 
-          list.each do |klass, args, block|
-            builder.insert_after(key, klass, *args, &block)
+          list.each do |item|
+            builder.insert_after(key, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
           end
         end
       end

data/lib/vagrant/action/runner.rb

@@ -34,30 +34,19 @@ module Vagrant
         environment.merge!(@lazy_globals.call) if @lazy_globals
         environment.merge!(options || {})
 
-        if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-          # NOTE: Triggers are initialized later in the Action::Runer because of
-          # how `@lazy_globals` are evaluated. Rather than trying to guess where
-          # the `env` is coming from, we can wait until they're merged into a single
-          # hash above.
-          env = environment[:env]
-          machine = environment[:machine]
-          machine_name = machine.name if machine
+        # NOTE: Triggers are initialized later in the Action::Runer because of
+        # how `@lazy_globals` are evaluated. Rather than trying to guess where
+        # the `env` is coming from, we can wait until they're merged into a single
+        # hash above.
+        env = environment[:env]
+        machine = environment[:machine]
 
-          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
-          triggers = Vagrant::Plugin::V2::Trigger.new(env, env.vagrantfile.config.trigger, machine, ui)
-        end
-
-        # Setup the action hooks
-        hooks = Vagrant.plugin("2").manager.action_hooks(environment[:action_name])
-        if !hooks.empty?
-          @logger.info("Preparing hooks for middleware sequence...")
-          environment[:action_hooks] = hooks.map do |hook_proc|
-            Hook.new.tap do |h|
-              hook_proc.call(h)
-            end
-          end
+        environment[:triggers] = machine.triggers if machine
 
-          @logger.info("#{environment[:action_hooks].length} hooks defined.")
+        if env
+          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+          environment[:triggers] ||= Vagrant::Plugin::V2::Trigger.
+            new(env, env.vagrantfile.config.trigger, machine, ui)
         end
 
         # Run the action chain in a busy block, marking the environment as
@@ -95,14 +84,10 @@ module Vagrant
 
         action_name = environment[:action_name]
 
-        triggers.fire_triggers(action_name, :before, machine_name, :hook) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-
         # We place a process lock around every action that is called
         @logger.info("Running action: #{environment[:action_name]} #{callable_id}")
         Util::Busy.busy(int_callback) { callable.call(environment) }
 
-        triggers.fire_triggers(action_name, :after, machine_name, :hook) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
-
         # Return the environment in case there are things in there that
         # the caller wants to use.
         environment