vagrant 1.0.7 → 1.5.0

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

@@ -1,23 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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)\.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

@@ -1,54 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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