boxcar 0.10005.1

data/lib/vagrant/action/vm/package.rb

@@ -0,0 +1,23 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  module Action
+    module VM
+      # A subclass of {General::Package} which simply makes sure that
+      # the package directory is set to the directory which the VM
+      # was exported to.
+      class Package < General::Package
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          # 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)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/package_vagrantfile.rb

@@ -0,0 +1,36 @@
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Action
+    module VM
+      # Puts a generated Vagrantfile into the package directory so that
+      # it can be included in the package.
+      class PackageVagrantfile
+        # For TemplateRenderer
+        include Util
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+          create_vagrantfile
+          @app.call(env)
+        end
+
+        # This method creates the auto-generated Vagrantfile at the root of the
+        # box. This Vagrantfile contains the MAC address so that the user doesn't
+        # have to worry about it.
+        def create_vagrantfile
+          File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
+            f.write(TemplateRenderer.render("package_Vagrantfile", {
+              :base_mac => @env["vm"].driver.read_mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/provision.rb

@@ -0,0 +1,61 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module VM
+      class Provision
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::provision")
+          @app = app
+
+          env["provision.enabled"] = true if !env.has_key?("provision.enabled")
+        end
+
+        def call(env)
+          @env = env
+
+          provisioners = nil
+
+          # We set this here so that even if this value is changed in the future,
+          # it stays constant to what we expect here in this moment.
+          enabled = env["provision.enabled"]
+          # Instantiate and prepare the provisioners. Preparation must happen here
+          # so that shared folders and such can properly take effect.
+          provisioners = enabled_provisioners
+          provisioners.map { |p| p.prepare }
+
+          @app.call(env)
+
+          if enabled
+            # Take prepared provisioners and run the provisioning
+            provisioners.each do |instance|
+              @env[:ui].info I18n.t("vagrant.actions.vm.provision.beginning",
+                                    :provisioner => instance.class)
+              instance.provision!
+            end
+          end
+        end
+
+        def enabled_provisioners
+          enabled = []
+          @env[:vm].config.vm.provisioners.each do |provisioner|
+            if @env["provision.types"]
+              # If we've specified types of provisioners to enable, then we
+              # only use those provisioners, and skip any that we haven't
+              # specified.
+              if !@env["provision.types"].include?(provisioner.shortcut.to_s)
+                @logger.debug("Skipping provisioner: #{provisioner.shortcut}")
+                next
+              end
+            end
+
+            enabled << provisioner.provisioner.new(@env, provisioner.config)
+          end
+
+          # Return the enable provisioners
+          enabled
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/provisioner_cleanup.rb

@@ -0,0 +1,26 @@
+module Vagrant
+  module Action
+    module VM
+      class ProvisionerCleanup
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          enabled_provisioners.each do |instance|
+            instance.cleanup
+          end
+
+          @app.call(env)
+        end
+
+        def enabled_provisioners
+          @env[:vm].config.vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/prune_nfs_exports.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class PruneNFSExports
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:host]
+            valid_ids = env[:vm].driver.read_vms
+            env[:host].nfs_prune(valid_ids)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/resume.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:vm].state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/sane_defaults.rb

@@ -0,0 +1,78 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module VM
+      # This middleware enforces some sane defaults on the virtualbox
+      # VM which help with performance, stability, and in some cases
+      # behavior.
+      class SaneDefaults
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
+          @app = app
+        end
+
+        def call(env)
+          # Set the env on an instance variable so we can access it in
+          # helpers.
+          @env = env
+
+          # Enable the host IO cache on the sata controller. Note that
+          # if this fails then its not a big deal, so we don't raise any
+          # errors. The Host IO cache vastly improves disk IO performance
+          # for VMs.
+          command = [
+            "storagectl", env[:vm].uuid,
+            "--name", "SATA Controller",
+            "--hostiocache", "on"
+          ]
+          attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
+
+          enable_dns_proxy = true
+          begin
+            contents = File.read("/etc/resolv.conf")
+
+            if contents =~ /^nameserver 127\.0\.0\.1$/
+              # The use of both natdnsproxy and natdnshostresolver break on
+              # Ubuntu 12.04 that uses resolvconf with localhost. When used
+              # VirtualBox will give the client dns server 10.0.2.3, while
+              # not binding to that address itself. Therefore disable this
+              # feature if host uses the resolvconf server 127.0.0.1
+              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1")
+              enable_dns_proxy = false
+            end
+          rescue Errno::ENOENT; end
+
+          # Enable/disable the NAT DNS proxy as necessary
+          if enable_dns_proxy
+            command = [
+              "modifyvm", env[:vm].uuid,
+              "--natdnsproxy1", "on"
+            ]
+            attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
+          else
+            command = [ "modifyvm", env[:vm].uuid, "--natdnsproxy1", "off" ]
+            attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
+            command = [ "modifyvm", env[:vm].uuid, "--natdnshostresolver1", "off" ]
+            attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This is just a helper method that executes a single command, logs
+        # the given string to the log, and also includes the exit status in
+        # the log message.
+        #
+        # @param [Array] command Command to run
+        # @param [String] log Log message to write.
+        def attempt_and_log(command, log)
+          result = @env[:vm].driver.execute_command(command)
+          @logger.info("#{log} (exit status = #{result.exit_code})")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/setup_package_files.rb

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module Vagrant
+  module Action
+    module VM
+      # Sets up the mapping of files to copy into the package and verifies
+      # that the files can be properly copied.
+      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 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/lib/vagrant/action/vm/share_folders.rb

@@ -0,0 +1,114 @@
+require 'pathname'
+
+require 'log4r'
+
+module Vagrant
+  module Action
+    module VM
+      class ShareFolders
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+
+          mount_shared_folders
+        end
+
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
+        def shared_folders
+          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
+            key, value = data
+
+            next acc if value[:disabled]
+
+            # This to prevent overwriting the actual shared folders data
+            value = value.dup
+            acc[key] = value
+            acc
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |name, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+              end
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |name, data|
+            folders << {
+              :name => name,
+              :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
+              :transient => data[:transient]
+            }
+          end
+
+          @env[:vm].driver.share_folders(folders)
+        end
+
+        def mount_shared_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |name, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
+            end
+          end
+
+          # Go through each folder and mount
+          folders.each do |name, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                    :name => name,
+                                    :guest_path => data[:guestpath]))
+
+              # Dup the data so we can pass it to the guest API
+              data = data.dup
+
+              # Calculate the owner and group
+              data[:owner] ||= @env[:vm].config.ssh.username
+              data[:group] ||= @env[:vm].config.ssh.username
+
+              # Mount the actual folder
+              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                    :name => name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/suspend.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class Suspend
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:vm].state == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
+            env[:vm].driver.suspend
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end