vagrant-unbundled 2.2.9.0 → 2.2.10.0

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

@@ -0,0 +1,30 @@
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitWait
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinitwait")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          cloud_init_wait_cmd = "cloud-init status --wait"
+          if !machine.config.vm.cloud_init_configs.empty?
+            if machine.communicate.test("command -v cloud-init")
+              env[:ui].output(I18n.t("vagrant.cloud_init_waiting"))
+              result = machine.communicate.sudo(cloud_init_wait_cmd, error_check: false)
+              if result != 0
+                raise Vagrant::Errors::CloudInitCommandFailed, cmd: cloud_init_wait_cmd, guest_name: machine.name
+              end
+            else
+              raise Vagrant::Errors::CloudInitNotFound, guest_name: machine.name
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module Vagrant
         def call(env)
           machine = env[:machine]
 
-          if !machine.config.vm.box
+          if !machine.config.vm.box || machine.config.vm.box.to_s.empty?
             @logger.info("Skipping HandleBox because no box is set")
             return @app.call(env)
           end

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

@@ -4,6 +4,7 @@ require "log4r"
 require "socket"
 
 require "vagrant/util/is_port_open"
+require "vagrant/util/ipv4_interfaces"
 
 module Vagrant
   module Action
@@ -26,6 +27,7 @@ module Vagrant
       #
       class HandleForwardedPortCollisions
         include Util::IsPortOpen
+        include Util::IPv4Interfaces
 
         def initialize(app, env)
           @app    = app
@@ -121,6 +123,7 @@ module Vagrant
             in_use = is_forwarded_already(extra_in_use, host_port, host_ip) ||
               call_port_checker(port_checker, host_ip, host_port) ||
               lease_check(host_ip, host_port)
+
             if in_use
               if !repair || !options[:auto_correct]
                 raise Errors::ForwardPortCollision,
@@ -243,22 +246,19 @@ module Vagrant
           return extra_in_use.fetch(hostport).include?(hostip)
         end
 
-        def ipv4_interfaces
-          Socket.getifaddrs.select do |ifaddr|
-            ifaddr.addr && ifaddr.addr.ipv4?
-          end.map do |ifaddr|
-            [ifaddr.name, ifaddr.addr.ip_address]
-          end
+        def port_check(host_ip, host_port)
+          self.class.port_check(@machine, host_ip, host_port)
         end
 
-        def port_check(host_ip, host_port)
+        def self.port_check(machine, host_ip, host_port)
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_port_collisions")
           # If no host_ip is specified, intention taken to be listen on all interfaces.
           test_host_ip = host_ip || "0.0.0.0"
           if Util::Platform.windows? && test_host_ip == "0.0.0.0"
             @logger.debug("Testing port #{host_port} on all IPv4 interfaces...")
-            available_interfaces = ipv4_interfaces.select do |interface|
+            available_interfaces = Vagrant::Util::IPv4Interfaces.ipv4_interfaces.select do |interface|
               @logger.debug("Testing #{interface[0]} with IP address #{interface[1]}")
-              !is_port_open?(interface[1], host_port)
+              !Vagrant::Util::IsPortOpen.is_port_open?(interface[1], host_port)
             end
             if available_interfaces.empty?
               @logger.debug("Cannot forward port #{host_port} on any interfaces.")
@@ -269,11 +269,11 @@ module Vagrant
             end
           else
             # Do a regular check
-            if test_host_ip == "0.0.0.0" || ipv4_interfaces.detect { |iface| iface[1] == test_host_ip }
-              is_port_open?(test_host_ip, host_port)
-            else
-              raise Errors::ForwardPortHostIPNotFound, name: @machine.name, host_ip: host_ip
+            if test_host_ip != "0.0.0.0" && !Addrinfo.ip(test_host_ip).ipv4_loopback? &&
+                Vagrant::Util::IPv4Interfaces.ipv4_interfaces.none? { |iface| iface[1] == test_host_ip }
+              @logger.warn("host IP address is not local to this device host_ip=#{test_host_ip}")
             end
+            Vagrant::Util::IsPortOpen.is_port_open?(test_host_ip, host_port)
           end
         end
 

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,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

@@ -8,13 +8,14 @@ module Vagrant
         # @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)
+        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,
@@ -26,7 +27,7 @@ module Vagrant
           machine = env[:machine]
           machine_name = machine.name if machine
 
-          @triggers.fire(@name, @timing, machine_name, @type)
+          @triggers.fire(@name, @timing, machine_name, @type, all: @all)
           # Carry on
           @app.call(env)
         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,15 +70,31 @@ 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]
@@ -77,27 +109,28 @@ module Vagrant
       # 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|
+          @prepend_hooks.each do |item|
             if options[:root]
               idx = builder.index(options[:root])
             else
               idx = 0
             end
-            builder.insert(idx, klass, *args, &block)
+            builder.insert(idx, item.middleware, *item.arguments.parameters,
+              **item.arguments.keywords, &item.arguments.block)
           end
 
           # Appends
-          @append_hooks.each do |klass, args, block|
+          @append_hooks.each do |item|
             if options[:root]
               idx = builder.index(options[:root])
-              builder.insert(idx + 1, klass, *args, &block)
+              builder.insert(idx + 1, item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
             else
-              builder.use(klass, *args, &block)
+              builder.use(item.middleware, *item.arguments.parameters,
+                **item.arguments.keywords, &item.arguments.block)
             end
           end
         end
@@ -106,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
 
@@ -115,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