vagrant-unbundled 2.2.7.0 → 2.2.16.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

@@ -49,6 +49,7 @@ module Vagrant
               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/synced_folders.rb

@@ -128,6 +128,22 @@ module Vagrant
             # Save the synced folders
             save_synced_folders(env[:machine], original_folders, **save_opts)
           end
+
+          # Persist the mounts by adding them to fstab (only if the guest is available)
+          begin
+            persist_mount = env[:machine].guest.capability?(:persist_mount_shared_folder)
+          rescue Errors::MachineGuestNotReady
+            persist_mount = false
+          end
+          if persist_mount
+            # Persist the mounts by adding them to fstab
+            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}")
+        @logger.info("Running action: #{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

data/lib/vagrant/action/warden.rb

@@ -1,7 +1,5 @@
 require "log4r"
 require 'vagrant/util/experimental'
-require 'vagrant/action/builtin/before_trigger'
-require 'vagrant/action/builtin/after_trigger'
 
 module Vagrant
   module Action
@@ -47,21 +45,12 @@ module Vagrant
           raise Errors::VagrantInterrupt if env[:interrupted]
           action = @actions.shift
           @logger.info("Calling IN action: #{action}")
-
-          if !action.is_a?(Proc) && env[:hook]
-            hook_name = action.class.name.split("::").last.
-              gsub(/([a-z])([A-Z])/, '\1_\2').gsub('-', '_').downcase
-          end
-
-          env[:hook].call("before_#{hook_name}".to_sym) if hook_name
           @stack.unshift(action).first.call(env)
-          env[:hook].call("after_#{hook_name}".to_sym) if hook_name
-
           raise Errors::VagrantInterrupt if env[:interrupted]
           @logger.info("Calling OUT action: #{action}")
-        rescue SystemExit
-          # This means that an "exit" or "abort" was called. In these cases,
-          # we just exit immediately.
+        rescue SystemExit, NoMemoryError
+          # This means that an "exit" or "abort" was called, or we have run out
+          # of memory. In these cases, we just exit immediately.
           raise
         rescue Exception => e
           # We guard this so that the Warden only outputs this once for
@@ -103,26 +92,34 @@ module Vagrant
       # A somewhat confusing function which simply initializes each
       # middleware properly to call the next middleware in the sequence.
       def finalize_action(action, env)
-        klass, args, block = action
+        if action.is_a?(Builder::StackItem)
+          klass = action.middleware
+          args = action.arguments.parameters
+          keywords = action.arguments.keywords
+          block = action.arguments.block
+        else
+          klass = action
+          args = []
+          keywords = {}
+        end
 
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class.
-        args ||= []
+        args = nil if args.empty?
+        keywords = nil if keywords.empty?
 
         if klass.is_a?(Class)
-          # A action klass which is to be instantiated with the
-          # app, env, and any arguments given
-
-          # We wrap the action class in two Trigger method calls so that
-          # action triggers can fire before and after each given action in the stack.
-          klass_name = klass.name
-          [Vagrant::Action::Builtin::BeforeTriggerAction.new(self, env,
-                                                             klass_name,
-                                                             @triggers),
-           klass.new(self, env, *args, &block),
-           Vagrant::Action::Builtin::AfterTriggerAction.new(self, env,
-                                                            klass_name,
-                                                            @triggers)]
+          # NOTE: We need to detect if we are passing args and/or
+          #       keywords and do it explicitly. Earlier versions
+          #       are not as lax about splatting keywords when the
+          #       target method is not expecting them.
+          if args && keywords
+            klass.new(self, env, *args, **keywords, &block)
+          elsif args
+            klass.new(self, env, *args, &block)
+          elsif keywords
+            klass.new(self, env, **keywords, &block)
+          else
+            klass.new(self, env, &block)
+          end
         elsif klass.respond_to?(:call)
           # Make it a lambda which calls the item then forwards
           # up the chain