vagrant-unbundled 1.8.1.2 → 1.8.4.1

data/plugins/providers/virtualbox/action/import_master.rb

@@ -1,75 +1,81 @@
-require "log4r"
-
-require "digest/md5"
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class ImportMaster
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::create_master")
-        end
-
-        def call(env)
-          # If we don't have a box, nothing to do
-          if !env[:machine].box
-            return @app.call(env)
-          end
-
-          # Do the import while locked so that nobody else imports
-          # a master at the same time. This is a no-op if we already
-          # have a master that exists.
-          lock_key = Digest::MD5.hexdigest(env[:machine].box.name)
-          env[:machine].env.lock(lock_key, retry: true) do
-            import_master(env)
-          end
-
-          # If we got interrupted, then the import could have been
-          # interrupted and its not a big deal. Just return out.
-          if env[:interrupted]
-            @logger.info("Import of master VM was interrupted -> exiting.")
-            return
-          end
-
-          # Import completed successfully. Continue the chain
-          @app.call(env)
-        end
-
-        protected
-
-        def import_master(env)
-          master_id_file = env[:machine].box.directory.join("master_id")
-
-          # Read the master ID if we have it in the file.
-          env[:clone_id] = master_id_file.read.chomp if master_id_file.file?
-
-          # If we have the ID and the VM exists already, then we
-          # have nothing to do. Success!
-          if env[:clone_id] && env[:machine].provider.driver.vm_exists?(env[:clone_id])
-            @logger.info(
-              "Master VM for '#{env[:machine].box.name}' already exists " +
-              " (id=#{env[:clone_id]}) - skipping import step.")
-            return
-          end
-
-          env[:ui].info(I18n.t("vagrant.actions.vm.clone.setup_master"))
-          env[:ui].detail(I18n.t("vagrant.actions.vm.clone.setup_master_detail"))
-
-          # Import the virtual machine
-          import_env = env[:action_runner].run(Import, env.dup.merge(skip_machine: true))
-          env[:clone_id] = import_env[:machine_id]
-
-          @logger.info(
-            "Imported box #{env[:machine].box.name} as master vm " +
-            "with id #{env[:clone_id]}")
-
-          @logger.debug("Writing id of master VM '#{env[:clone_id]}' to #{master_id_file}")
-          master_id_file.open("w+") do |f|
-            f.write(env[:clone_id])
-          end
-        end
-      end
-    end
-  end
-end
+require "log4r"
+
+require "digest/md5"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ImportMaster
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::create_master")
+        end
+
+        def call(env)
+          # If we don't have a box, nothing to do
+          if !env[:machine].box
+            return @app.call(env)
+          end
+
+          # Do the import while locked so that nobody else imports
+          # a master at the same time. This is a no-op if we already
+          # have a master that exists.
+          lock_key = Digest::MD5.hexdigest(env[:machine].box.name)
+          env[:machine].env.lock(lock_key, retry: true) do
+            import_master(env)
+          end
+
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          if env[:interrupted]
+            @logger.info("Import of master VM was interrupted -> exiting.")
+            return
+          end
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        protected
+
+        def import_master(env)
+          master_id_file = env[:machine].box.directory.join("master_id")
+
+          # Read the master ID if we have it in the file.
+          env[:clone_id] = master_id_file.read.chomp if master_id_file.file?
+
+          # If we have the ID and the VM exists already, then we
+          # have nothing to do. Success!
+          if env[:clone_id] && env[:machine].provider.driver.vm_exists?(env[:clone_id])
+            @logger.info(
+              "Master VM for '#{env[:machine].box.name}' already exists " +
+              " (id=#{env[:clone_id]}) - skipping import step.")
+            return
+          else
+            if env.delete(:clone_id)
+              @logger.info("Deleting previous reference for master VM" +
+                "'#{env[:machine].box.name}' (id=#{env[:clone_id]}) - " +
+                "maybe it was removed manually")
+            end
+          end
+
+          env[:ui].info(I18n.t("vagrant.actions.vm.clone.setup_master"))
+          env[:ui].detail(I18n.t("vagrant.actions.vm.clone.setup_master_detail"))
+
+          # Import the virtual machine
+          import_env = env[:action_runner].run(Import, env.dup.merge(skip_machine: true))
+          env[:clone_id] = import_env[:machine_id]
+
+          @logger.info(
+            "Imported box #{env[:machine].box.name} as master vm " +
+            "with id #{env[:clone_id]}")
+
+          @logger.debug("Writing id of master VM '#{env[:clone_id]}' to #{master_id_file}")
+          master_id_file.open("w+") do |f|
+            f.write(env[:clone_id])
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package.rb

@@ -1,6 +1,4 @@
-require 'fileutils'
-
-require 'vagrant/action/general/package'
+require_relative "../../../../lib/vagrant/action/general/package"
 
 module VagrantPlugins
   module ProviderVirtualBox
@@ -10,33 +8,7 @@ module VagrantPlugins
         # called in the unit tests.
         alias_method :general_call, :call
         def call(env)
-          # Setup the temporary directory
-          @temp_dir = env[:tmp_path].join(Time.now.to_i.to_s)
-          env["export.temp_dir"] = @temp_dir
-          FileUtils.mkpath(env["export.temp_dir"])
-
-          # Just match up a couple environmental variables so that
-          # the superclass will do the right thing. Then, call the
-          # superclass
-          env["package.directory"] = env["export.temp_dir"]
-
           general_call(env)
-
-          # Always call recover to clean up the temp dir
-          clean_temp_dir
-        end
-
-        def recover(env)
-          clean_temp_dir
-          super
-        end
-
-        protected
-
-        def clean_temp_dir
-          if @temp_dir && File.exist?(@temp_dir)
-            FileUtils.rm_rf(@temp_dir)
-          end
         end
       end
     end

data/plugins/providers/virtualbox/action/package_setup_files.rb

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PackageSetupFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+              file: from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package_setup_folders.rb

@@ -0,0 +1,38 @@
+require "fileutils"
+
+require_relative "../../../../lib/vagrant/action/general/package"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PackageSetupFolders
+        include Vagrant::Util::Presence
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env["package.output"] ||= "package.box"
+          env["package.directory"] ||= Dir.mktmpdir("vagrant-package-", env[:tmp_path])
+
+          # Match up a couple environmental variables so that the other parts of
+          # Vagrant will do the right thing.
+          env["export.temp_dir"] = env["package.directory"]
+
+          Vagrant::Action::General::Package.validate!(
+            env["package.output"], env["package.directory"])
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          dir = env["package.directory"]
+          if File.exist?(dir)
+            FileUtils.rm_rf(dir)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -37,7 +37,27 @@ module VagrantPlugins
         # The ! indicates that this method modifies its argument.
         def add_ips_to_env!(env)
           adapter, host_ip = find_host_only_adapter
-          machine_ip       = read_static_machine_ips || read_dynamic_machine_ip(adapter)
+          machine_ip       = read_static_machine_ips
+
+          if !machine_ip
+            # No static IP, attempt to use the dynamic IP.
+            machine_ip = read_dynamic_machine_ip(adapter)
+          else
+            # We have static IPs, also attempt to read any dynamic IPs.
+            # If there is no dynamic IP on the adapter, it doesn't matter. We
+            # already have a static IP.
+            begin
+              dynamic_ip = read_dynamic_machine_ip(adapter)
+            rescue Vagrant::Errors::NFSNoGuestIP
+              dynamic_ip = nil
+            end
+
+            # If we found a dynamic IP and we didn't include it in the
+            # machine_ip array yet, do so.
+            if dynamic_ip && !machine_ip.include?(dynamic_ip)
+              machine_ip.push(dynamic_ip)
+            end
+          end
 
           raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
 
@@ -70,6 +90,8 @@ module VagrantPlugins
         def read_static_machine_ips
           ips = []
           @machine.config.vm.networks.each do |type, options|
+            options = scoped_hash_override(options, :virtualbox)
+
             if type == :private_network && options[:type] != :dhcp && options[:ip].is_a?(String)
               ips << options[:ip]
             end

data/plugins/providers/virtualbox/action/setup_package_files.rb

@@ -1,49 +1,15 @@
+require "log4r"
+
+require_relative "package_setup_files"
+
 module VagrantPlugins
   module ProviderVirtualBox
     module Action
-      class SetupPackageFiles
-        def initialize(app, env)
-          @app = app
-
-          env["package.include"] ||= []
-          env["package.vagrantfile"] ||= nil
-        end
-
-        def call(env)
-          files = {}
-          env["package.include"].each do |file|
-            source = Pathname.new(file)
-            dest   = nil
-
-            # If the source is relative then we add the file as-is to the include
-            # directory. Otherwise, we copy only the file into the root of the
-            # include directory. Kind of strange, but seems to match what people
-            # expect based on history.
-            if source.relative?
-              dest = source
-            else
-              dest = source.basename
-            end
-
-            # Assign the mapping
-            files[file] = dest
-          end
-
-          if env["package.vagrantfile"]
-            # Vagrantfiles are treated special and mapped to a specific file
-            files[env["package.vagrantfile"]] = "_Vagrantfile"
-          end
-
-          # Verify the mapping
-          files.each do |from, _|
-            raise Vagrant::Errors::PackageIncludeMissing,
-              file: from if !File.exist?(from)
-          end
-
-          # Save the mapping
-          env["package.files"] = files
-
-          @app.call(env)
+      class SetupPackageFiles < PackageSetupFiles
+        def initialize(*)
+          @logger = Log4r::Logger.new("vagrant::plugins::virtualbox::setup_package_files")
+          @logger.warn { "SetupPackageFiles has been renamed to PackageSetupFiles" }
+          super
         end
       end
     end

data/plugins/providers/virtualbox/driver/version_4_1.rb

@@ -34,6 +34,17 @@ module VagrantPlugins
           end
         end
 
+        def clonevm(master_id, snapshot_name)
+          machine_name = "temp_clone_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
+          args = ["--register", "--name", machine_name]
+          if snapshot_name
+            args += ["--snapshot", snapshot_name, "--options", "link"]
+          end
+
+          execute("clonevm", master_id, *args)
+          return get_machine_id(machine_name)
+        end
+
         def create_dhcp_server(network, options)
           execute("dhcpserver", "add", "--ifname", network,
                   "--ip", options[:dhcp_ip],
@@ -71,6 +82,86 @@ module VagrantPlugins
           }
         end
 
+        def create_snapshot(machine_id, snapshot_name)
+          execute("snapshot", machine_id, "take", snapshot_name)
+        end
+
+        def delete_snapshot(machine_id, snapshot_name)
+          # Start with 0%
+          last = 0
+          total = ""
+          yield 0 if block_given?
+
+          # Snapshot and report the % progress
+          execute("snapshot", machine_id, "delete", snapshot_name) do |type, data|
+            if type == :stderr
+              # Append the data so we can see the full view
+              total << data.gsub("\r", "")
+
+              # Break up the lines. We can't get the progress until we see an "OK"
+              lines = total.split("\n")
+
+              # The progress of the import will be in the last line. Do a greedy
+              # regular expression to find what we're looking for.
+              match = /.+(\d{2})%/.match(lines.last)
+              if match
+                current = match[1].to_i
+                if current > last
+                  last = current
+                  yield current if block_given?
+                end
+              end
+            end
+          end
+        end
+
+        def list_snapshots(machine_id)
+          output = execute(
+            "snapshot", machine_id, "list", "--machinereadable",
+            retryable: true)
+
+          result = []
+          output.split("\n").each do |line|
+            if line =~ /^SnapshotName.*?="(.+?)"$/i
+              result << $1.to_s
+            end
+          end
+
+          result.sort
+        rescue Vagrant::Errors::VBoxManageError => e
+          d = e.extra_data
+          return [] if d[:stderr].include?("does not have") || d[:stdout].include?("does not have")
+          raise
+        end
+
+        def restore_snapshot(machine_id, snapshot_name)
+          # Start with 0%
+          last = 0
+          total = ""
+          yield 0 if block_given?
+
+          execute("snapshot", machine_id, "restore", snapshot_name) do |type, data|
+            if type == :stderr
+              # Append the data so we can see the full view
+              total << data.gsub("\r", "")
+
+              # Break up the lines. We can't get the progress until we see an "OK"
+              lines = total.split("\n")
+
+              # The progress of the import will be in the last line. Do a greedy
+              # regular expression to find what we're looking for.
+              match = /.+(\d{2})%/.match(lines.last)
+              if match
+                current = match[1].to_i
+                if current > last
+                  last = current
+                  yield current if block_given?
+                end
+              end
+            end
+          end
+        end
+
         def delete
           execute("unregistervm", @uuid, "--delete")
         end
@@ -167,6 +258,13 @@ module VagrantPlugins
           execute("modifyvm", @uuid, *args) if !args.empty?
         end
 
+        def get_machine_id(machine_name)
+          output = execute("list", "vms", retryable: true)
+          match = /^"#{Regexp.escape(machine_name)}" \{(.+?)\}$/.match(output)
+          return match[1].to_s if match
+          nil
+        end
+
         def halt
           execute("controlvm", @uuid, "poweroff")
         end
@@ -524,9 +622,9 @@ module VagrantPlugins
                 "--name", name,
                 "--transient")
 
-            execute(
-              "setextradata", @uuid,
-              "VBoxInternal2/SharedFoldersEnableSymlinksCreate/#{name}")
+              execute(
+                "setextradata", @uuid,
+                "VBoxInternal2/SharedFoldersEnableSymlinksCreate/#{name}")
             rescue Vagrant::Errors::VBoxManageError => e
               if e.extra_data[:stderr].include?("VBOX_E_FILE_ERROR")
                 # The folder doesn't exist. ignore.
@@ -563,9 +661,9 @@ module VagrantPlugins
             result = raw("showvminfo", uuid)
             return true if result.exit_code == 0
 
-            # GH-2479: Sometimes this happens. In this case, retry. If
-            # we don't see this text, the VM really probably doesn't exist.
-            return false if !result.stderr.include?("CO_E_SERVER_EXEC_FAILURE")
+            # If vboxmanage returned VBOX_E_OBJECT_NOT_FOUND,
+            # then the vm truly does not exist. Any other error might be transient
+            return false if result.stderr.include?("VBOX_E_OBJECT_NOT_FOUND")
 
             # Sleep a bit though to give VirtualBox time to fix itself
             sleep 2