vagrant 1.0.7 → 1.5.0

data/lib/vagrant/driver/virtualbox_base.rb

@@ -1,326 +0,0 @@
-require 'log4r'
-
-require 'vagrant/util/busy'
-require 'vagrant/util/platform'
-require 'vagrant/util/retryable'
-require 'vagrant/util/subprocess'
-
-module Vagrant
-  module Driver
-    # Base class for all VirtualBox drivers.
-    #
-    # This class provides useful tools for things such as executing
-    # VBoxManage and handling SIGINTs and so on.
-    class VirtualBoxBase
-      # Include this so we can use `Subprocess` more easily.
-      include Vagrant::Util
-      include Vagrant::Util::Retryable
-
-      def initialize
-        @logger = Log4r::Logger.new("vagrant::driver::virtualbox_base")
-
-        # This flag is used to keep track of interrupted state (SIGINT)
-        @interrupted = false
-
-        # Set the path to VBoxManage
-        @vboxmanage_path = "VBoxManage"
-
-        if Util::Platform.windows?
-          @logger.debug("Windows. Trying VBOX_INSTALL_PATH for VBoxManage")
-
-          # On Windows, we use the VBOX_INSTALL_PATH environmental
-          # variable to find VBoxManage.
-          if ENV.has_key?("VBOX_INSTALL_PATH")
-            # The path usually ends with a \ but we make sure here
-            path = ENV["VBOX_INSTALL_PATH"]
-            path += "\\" if !path.end_with?("\\")
-            @vboxmanage_path = "#{path}VBoxManage.exe"
-          end
-        end
-
-        @logger.info("VBoxManage path: #{@vboxmanage_path}")
-      end
-
-      # Clears the forwarded ports that have been set on the virtual machine.
-      def clear_forwarded_ports
-      end
-
-      # Clears the shared folders that have been set on the virtual machine.
-      def clear_shared_folders
-      end
-
-      # Creates a DHCP server for a host only network.
-      #
-      # @param [String] network Name of the host-only network.
-      # @param [Hash] options Options for the DHCP server.
-      def create_dhcp_server(network, options)
-      end
-
-      # Creates a host only network with the given options.
-      #
-      # @param [Hash] options Options to create the host only network.
-      # @return [Hash] The details of the host only network, including
-      #   keys `:name`, `:ip`, and `:netmask`
-      def create_host_only_network(options)
-      end
-
-      # Deletes the virtual machine references by this driver.
-      def delete
-      end
-
-      # Deletes any host only networks that aren't being used for anything.
-      def delete_unused_host_only_networks
-      end
-
-      # Discards any saved state associated with this VM.
-      def discard_saved_state
-      end
-
-      # Enables network adapters on the VM.
-      #
-      # The format of each adapter specification should be like so:
-      #
-      # {
-      #   :type     => :hostonly,
-      #   :hostonly => "vboxnet0",
-      #   :mac_address => "tubes"
-      # }
-      #
-      # This must support setting up both host only and bridged networks.
-      #
-      # @param [Array<Hash>] adapters Array of adapters to enable.
-      def enable_adapters(adapters)
-      end
-
-      # Execute a raw command straight through to VBoxManage.
-      #
-      # @param [Array] command Command to execute.
-      def execute_command(command)
-      end
-
-      # Exports the virtual machine to the given path.
-      #
-      # @param [String] path Path to the OVF file.
-      # @yield [progress] Yields the block with the progress of the export.
-      def export(path)
-      end
-
-      # Forwards a set of ports for a VM.
-      #
-      # This will not affect any previously set forwarded ports,
-      # so be sure to delete those if you need to.
-      #
-      # The format of each port hash should be the following:
-      #
-      #     {
-      #       :name => "foo",
-      #       :hostport => 8500,
-      #       :guestport => 80,
-      #       :adapter => 1,
-      #       :protocol => "tcp"
-      #     }
-      #
-      # Note that "adapter" and "protocol" are optional and will default
-      # to 1 and "tcp" respectively.
-      #
-      # @param [Array<Hash>] ports An array of ports to set. See documentation
-      #   for more information on the format.
-      def forward_ports(ports)
-      end
-
-      # Halts the virtual machine (pulls the plug).
-      def halt
-      end
-
-      # Imports the VM from an OVF file.
-      #
-      # @param [String] ovf Path to the OVF file.
-      # @return [String] UUID of the imported VM.
-      def import(ovf)
-      end
-
-      # Returns a list of forwarded ports for a VM.
-      #
-      # @param [String] uuid UUID of the VM to read from, or `nil` if this
-      #   VM.
-      # @param [Boolean] active_only If true, only VMs that are running will
-      #   be checked.
-      # @return [Array<Array>]
-      def read_forwarded_ports(uuid=nil, active_only=false)
-      end
-
-      # Returns a list of bridged interfaces.
-      #
-      # @return [Hash]
-      def read_bridged_interfaces
-      end
-
-      # Returns the guest additions version that is installed on this VM.
-      #
-      # @return [String]
-      def read_guest_additions_version
-      end
-
-      # Returns a list of available host only interfaces.
-      #
-      # @return [Hash]
-      def read_host_only_interfaces
-      end
-
-      # Returns the MAC address of the first network interface.
-      #
-      # @return [String]
-      def read_mac_address
-      end
-
-      # Returns the folder where VirtualBox places it's VMs.
-      #
-      # @return [String]
-      def read_machine_folder
-      end
-
-      # Returns a list of network interfaces of the VM.
-      #
-      # @return [Hash]
-      def read_network_interfaces
-      end
-
-      # Returns the current state of this VM.
-      #
-      # @return [Symbol]
-      def read_state
-      end
-
-      # Returns a list of all forwarded ports in use by active
-      # virtual machines.
-      #
-      # @return [Array]
-      def read_used_ports
-      end
-
-      # Returns a list of all UUIDs of virtual machines currently
-      # known by VirtualBox.
-      #
-      # @return [Array<String>]
-      def read_vms
-      end
-
-      # Sets the MAC address of the first network adapter.
-      #
-      # @param [String] mac MAC address without any spaces/hyphens.
-      def set_mac_address(mac)
-      end
-
-      # Share a set of folders on this VM.
-      #
-      # @param [Array<Hash>] folders
-      def share_folders(folders)
-      end
-
-      # Reads the SSH port of this VM.
-      #
-      # @param [Integer] expected Expected guest port of SSH.
-      def ssh_port(expected)
-      end
-
-      # Starts the virtual machine.
-      #
-      # @param [String] mode Mode to boot the VM. Either "headless"
-      #   or "gui"
-      def start(mode)
-      end
-
-      # Suspend the virtual machine.
-      def suspend
-      end
-
-      # Verifies that the driver is ready to accept work.
-      #
-      # This should raise a VagrantError if things are not ready.
-      def verify!
-      end
-
-      # Verifies that an image can be imported properly.
-      #
-      # @param [String] path Path to an OVF file.
-      # @return [Boolean]
-      def verify_image(path)
-      end
-
-      # Checks if a VM with the given UUID exists.
-      #
-      # @return [Boolean]
-      def vm_exists?(uuid)
-      end
-
-      # Execute the given subcommand for VBoxManage and return the output.
-      def execute(*command, &block)
-        # Get the options hash if it exists
-        opts = {}
-        opts = command.pop if command.last.is_a?(Hash)
-
-        tries = 0
-        tries = 3 if opts[:retryable]
-
-        # Variable to store our execution result
-        r = nil
-
-        retryable(:on => Errors::VBoxManageError, :tries => tries, :sleep => 1) do
-          # Execute the command
-          r = raw(*command, &block)
-
-          # If the command was a failure, then raise an exception that is
-          # nicely handled by Vagrant.
-          if r.exit_code != 0
-            if @interrupted
-              @logger.info("Exit code != 0, but interrupted. Ignoring.")
-            else
-              raise Errors::VBoxManageError, :command => command.inspect
-            end
-          else
-            # Sometimes, VBoxManage fails but doesn't actual return a non-zero
-            # exit code. For this we inspect the output and determine if an error
-            # occurred.
-            if r.stderr =~ /VBoxManage: error:/
-              @logger.info("VBoxManage error text found, assuming error.")
-              raise Errors::VBoxManageError, :command => command.inspect
-            end
-          end
-        end
-
-        # Return the output, making sure to replace any Windows-style
-        # newlines with Unix-style.
-        r.stdout.gsub("\r\n", "\n")
-      end
-
-      # Executes a command and returns the raw result object.
-      def raw(*command, &block)
-        int_callback = lambda do
-          @interrupted = true
-          @logger.info("Interrupted.")
-        end
-
-        # The following is a workaround for a combined VirtualBox and
-        # Mac OS X 10.8 bug:
-        #
-        # Remove the DYLD_LIBRARY_PATH environmental variable on Mac. This
-        # is to fix a bug in Mac OS X 10.8 where a warning is printed to the
-        # console if this is set when executing certain programs, which
-        # can cause some VBoxManage commands to break because they work
-        # by just reading stdout and don't expect the OS to just inject
-        # garbage into it.
-        old_dyld_lib_path = ENV.delete("DYLD_LIBRARY_PATH")
-        old_ld_lib_path   = ENV.delete("LD_LIBRARY_PATH")
-
-        Util::Busy.busy(int_callback) do
-          Subprocess.execute(@vboxmanage_path, *command, &block)
-        end
-      ensure
-        # Reset the library path if it was set before. See above comments
-        # for more information on why this was unset in the first place.
-        ENV["DYLD_LIBRARY_PATH"] = old_dyld_lib_path if old_dyld_lib_path
-        ENV["LD_LIBRARY_PATH"]   = old_ld_lib_path if old_ld_lib_path
-      end
-    end
-  end
-end

data/lib/vagrant/environment.rb

@@ -1,522 +0,0 @@
-require 'pathname'
-require 'fileutils'
-
-require 'log4r'
-require 'rubygems'  # This is needed for plugin loading below.
-
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-
-module Vagrant
-  # Represents a single Vagrant environment. A "Vagrant environment" is
-  # defined as basically a folder with a "Vagrantfile." This class allows
-  # access to the VMs, CLI, etc. all in the scope of this environment.
-  class Environment
-    HOME_SUBDIRS = ["tmp", "boxes", "gems"]
-    DEFAULT_VM = :default
-    DEFAULT_HOME = "~/.vagrant.d"
-
-    # The `cwd` that this environment represents
-    attr_reader :cwd
-
-    # The valid name for a Vagrantfile for this environment.
-    attr_reader :vagrantfile_name
-
-    # The {UI} object to communicate with the outside world.
-    attr_reader :ui
-
-    # The directory to the "home" folder that Vagrant will use to store
-    # global state.
-    attr_reader :home_path
-
-    # The directory where temporary files for Vagrant go.
-    attr_reader :tmp_path
-
-    # The directory where boxes are stored.
-    attr_reader :boxes_path
-
-    # The path where the plugins are stored (gems)
-    attr_reader :gems_path
-
-    # The path to the default private key
-    attr_reader :default_private_key_path
-
-    # Initializes a new environment with the given options. The options
-    # is a hash where the main available key is `cwd`, which defines where
-    # the environment represents. There are other options available but
-    # they shouldn't be used in general. If `cwd` is nil, then it defaults
-    # to the `Dir.pwd` (which is the cwd of the executing process).
-    def initialize(opts=nil)
-      opts = {
-        :cwd => nil,
-        :vagrantfile_name => nil,
-        :lock_path => nil,
-        :ui_class => nil,
-        :home_path => nil
-      }.merge(opts || {})
-
-      # Set the default working directory to look for the vagrantfile
-      opts[:cwd] ||= ENV["VAGRANT_CWD"] if ENV.has_key?("VAGRANT_CWD")
-      opts[:cwd] ||= Dir.pwd
-      opts[:cwd] = Pathname.new(opts[:cwd])
-      raise Errors::EnvironmentNonExistentCWD if !opts[:cwd].directory?
-
-      # Set the Vagrantfile name up. We append "Vagrantfile" and "vagrantfile" so that
-      # those continue to work as well, but anything custom will take precedence.
-      opts[:vagrantfile_name] ||= []
-      opts[:vagrantfile_name] = [opts[:vagrantfile_name]] if !opts[:vagrantfile_name].is_a?(Array)
-      opts[:vagrantfile_name] += ["Vagrantfile", "vagrantfile"]
-
-      # Set instance variables for all the configuration parameters.
-      @cwd    = opts[:cwd]
-      @vagrantfile_name = opts[:vagrantfile_name]
-      @lock_path = opts[:lock_path]
-      @home_path = opts[:home_path]
-
-      ui_class = opts[:ui_class] || UI::Silent
-      @ui      = ui_class.new("vagrant")
-
-      @loaded = false
-      @lock_acquired = false
-
-      @logger = Log4r::Logger.new("vagrant::environment")
-      @logger.info("Environment initialized (#{self})")
-      @logger.info("  - cwd: #{cwd}")
-
-      # Setup the home directory
-      setup_home_path
-      @tmp_path = @home_path.join("tmp")
-      @boxes_path = @home_path.join("boxes")
-      @gems_path  = @home_path.join("gems")
-
-      # Setup the default private key
-      @default_private_key_path = @home_path.join("insecure_private_key")
-      copy_insecure_private_key
-
-      # Load the plugins
-      load_plugins
-    end
-
-    #---------------------------------------------------------------
-    # Helpers
-    #---------------------------------------------------------------
-
-    # The path to the `dotfile`, which contains the persisted UUID of
-    # the VM if it exists.
-    #
-    # @return [Pathname]
-    def dotfile_path
-      return nil if !root_path
-      root_path.join(config.global.vagrant.dotfile_name)
-    end
-
-    # Returns the collection of boxes for the environment.
-    #
-    # @return [BoxCollection]
-    def boxes
-      @_boxes ||= BoxCollection.new(boxes_path, action_runner)
-    end
-
-    # Returns the VMs associated with this environment.
-    #
-    # @return [Hash<Symbol,VM>]
-    def vms
-      load! if !loaded?
-      @vms ||= load_vms!
-    end
-
-    # Returns the VMs associated with this environment, in the order
-    # that they were defined.
-    #
-    # @return [Array<VM>]
-    def vms_ordered
-      return @vms.values if !multivm?
-      @vms_enum ||= config.global.vm.defined_vm_keys.map { |name| @vms[name] }
-    end
-
-    # Returns the primary VM associated with this environment. This
-    # method is only applicable for multi-VM environments. This can
-    # potentially be nil if no primary VM is specified.
-    #
-    # @return [VM]
-    def primary_vm
-      return vms.values.first if !multivm?
-
-      config.global.vm.defined_vms.each do |name, subvm|
-        return vms[name] if subvm.options[:primary]
-      end
-
-      nil
-    end
-
-    # Returns a boolean whether this environment represents a multi-VM
-    # environment or not. This will work even when called on child
-    # environments.
-    #
-    # @return [Bool]
-    def multivm?
-      vms.length > 1 || vms.keys.first != DEFAULT_VM
-    end
-
-    # Makes a call to the CLI with the given arguments as if they
-    # came from the real command line (sometimes they do!). An example:
-    #
-    #     env.cli("package", "--vagrantfile", "Vagrantfile")
-    #
-    def cli(*args)
-      CLI.new(args.flatten, self).execute
-    end
-
-    # Returns the host object associated with this environment.
-    #
-    # @return [Hosts::Base]
-    def host
-      return @host if defined?(@host)
-
-      # Attempt to figure out the host class. Note that the order
-      # matters here, so please don't touch. Specifically: The symbol
-      # check is done after the detect check because the symbol check
-      # will return nil, and we don't want to trigger a detect load.
-      host_klass = config.global.vagrant.host
-      host_klass = Hosts.detect(Vagrant.hosts) if host_klass.nil? || host_klass == :detect
-      host_klass = Vagrant.hosts.get(host_klass) if host_klass.is_a?(Symbol)
-
-      # If no host class is detected, we use the base class.
-      host_klass ||= Hosts::Base
-
-      @host ||= host_klass.new(@ui)
-    end
-
-    # Action runner for executing actions in the context of this environment.
-    #
-    # @return [Action::Runner]
-    def action_runner
-      @action_runner ||= Action::Runner.new(action_registry) do
-        {
-          :action_runner  => action_runner,
-          :box_collection => boxes,
-          :global_config  => config.global,
-          :host           => host,
-          :root_path      => root_path,
-          :tmp_path       => tmp_path,
-          :ui             => @ui
-        }
-      end
-    end
-
-    # Action registry for registering new actions with this environment.
-    #
-    # @return [Registry]
-    def action_registry
-      # For now we return the global built-in actions registry. In the future
-      # we may want to create an isolated registry that inherits from this
-      # global one, but for now there isn't a use case that calls for it.
-      Vagrant.actions
-    end
-
-    # Loads on initial access and reads data from the global data store.
-    # The global data store is global to Vagrant everywhere (in every environment),
-    # so it can be used to store system-wide information. Note that "system-wide"
-    # typically means "for this user" since the location of the global data
-    # store is in the home directory.
-    #
-    # @return [DataStore]
-    def global_data
-      @global_data ||= DataStore.new(File.expand_path("global_data.json", home_path))
-    end
-
-    # Loads (on initial access) and reads data from the local data
-    # store. This file is always at the root path as the file "~/.vagrant"
-    # and contains a JSON dump of a hash. See {DataStore} for more
-    # information.
-    #
-    # @return [DataStore]
-    def local_data
-      @local_data ||= DataStore.new(dotfile_path)
-    end
-
-    # The root path is the path where the top-most (loaded last)
-    # Vagrantfile resides. It can be considered the project root for
-    # this environment.
-    #
-    # @return [String]
-    def root_path
-      return @root_path if defined?(@root_path)
-
-      root_finder = lambda do |path|
-        # Note: To remain compatible with Ruby 1.8, we have to use
-        # a `find` here instead of an `each`.
-        found = vagrantfile_name.find do |rootfile|
-          File.exist?(File.join(path.to_s, rootfile))
-        end
-
-        return path if found
-        return nil if path.root? || !File.exist?(path)
-        root_finder.call(path.parent)
-      end
-
-      @root_path = root_finder.call(cwd)
-    end
-
-    # This returns the path which Vagrant uses to determine the location
-    # of the file lock. This is specific to each operating system.
-    def lock_path
-      @lock_path || tmp_path.join("vagrant.lock")
-    end
-
-    # This locks Vagrant for the duration of the block passed to this
-    # method. During this time, any other environment which attempts
-    # to lock which points to the same lock file will fail.
-    def lock
-      # This allows multiple locks in the same process to be nested
-      return yield if @lock_acquired
-
-      File.open(lock_path, "w+") do |f|
-        # The file locking fails only if it returns "false." If it
-        # succeeds it returns a 0, so we must explicitly check for
-        # the proper error case.
-        raise Errors::EnvironmentLockedError if f.flock(File::LOCK_EX | File::LOCK_NB) === false
-
-        begin
-          # Mark that we have a lock
-          @lock_acquired = true
-
-          yield
-        ensure
-          # We need to make sure that no matter what this is always
-          # reset to false so we don't think we have a lock when we
-          # actually don't.
-          @lock_acquired = false
-        end
-      end
-    end
-
-    #---------------------------------------------------------------
-    # Config Methods
-    #---------------------------------------------------------------
-
-    # The configuration object represented by this environment. This
-    # will trigger the environment to load if it hasn't loaded yet (see
-    # {#load!}).
-    #
-    # @return [Config::Container]
-    def config
-      load! if !loaded?
-      @config
-    end
-
-    #---------------------------------------------------------------
-    # Load Methods
-    #---------------------------------------------------------------
-
-    # Returns a boolean representing if the environment has been
-    # loaded or not.
-    #
-    # @return [Bool]
-    def loaded?
-      !!@loaded
-    end
-
-    # Loads this entire environment, setting up the instance variables
-    # such as `vm`, `config`, etc. on this environment. The order this
-    # method calls its other methods is very particular.
-    def load!
-      if !loaded?
-        @loaded = true
-        @logger.info("Loading configuration...")
-        load_config!
-      end
-
-      self
-    end
-
-    # Reloads the configuration of this environment.
-    def reload!
-      # Reload the configuration
-      load_config!
-
-      # Clear the VMs because this can now be diferent due to configuration
-      @vms = nil
-    end
-
-    # Loads this environment's configuration and stores it in the {#config}
-    # variable. The configuration loaded by this method is specified to
-    # this environment, meaning that it will use the given root directory
-    # to load the Vagrantfile into that context.
-    def load_config!
-      # Initialize the config loader
-      config_loader = Config::Loader.new
-      config_loader.load_order = [:default, :box, :home, :root, :vm]
-
-      inner_load = lambda do |*args|
-        # This is for Ruby 1.8.7 compatibility. Ruby 1.8.7 doesn't allow
-        # default arguments for lambdas, so we get around by doing a *args
-        # and setting the args here.
-        subvm = args[0]
-        box   = args[1]
-
-        # Default Vagrantfile first. This is the Vagrantfile that ships
-        # with Vagrant.
-        config_loader.set(:default, File.expand_path("config/default.rb", Vagrant.source_root))
-
-        if box
-          # We load the box Vagrantfile
-          box_vagrantfile = find_vagrantfile(box.directory)
-          config_loader.set(:box, box_vagrantfile) if box_vagrantfile
-        end
-
-        if home_path
-          # Load the home Vagrantfile
-          home_vagrantfile = find_vagrantfile(home_path)
-          config_loader.set(:home, home_vagrantfile) if home_vagrantfile
-        end
-
-        if root_path
-          # Load the Vagrantfile in this directory
-          root_vagrantfile = find_vagrantfile(root_path)
-          config_loader.set(:root, root_vagrantfile) if root_vagrantfile
-        end
-
-        if subvm
-          # We have subvm configuration, so set that up as well.
-          config_loader.set(:vm, subvm.proc_stack)
-        end
-
-        # Execute the configuration stack and store the result as the final
-        # value in the config ivar.
-        config_loader.load
-      end
-
-      # For the global configuration, we only need to load the configuration
-      # in a single pass, since nothing is conditional on the configuration.
-      global = inner_load.call
-
-      # For each virtual machine represented by this environment, we have
-      # to load the configuration in two-passes. We do this because the
-      # first pass is used to determine the box for the VM. The second pass
-      # is used to also load the box Vagrantfile.
-      defined_vm_keys = global.vm.defined_vm_keys.dup
-      defined_vms     = global.vm.defined_vms.dup
-
-      # If this isn't a multi-VM environment, then setup the default VM
-      # to simply be our configuration.
-      if defined_vm_keys.empty?
-        defined_vm_keys << DEFAULT_VM
-        defined_vms[DEFAULT_VM] = Config::VMConfig::SubVM.new
-      end
-
-      vm_configs = defined_vm_keys.map do |vm_name|
-        @logger.debug("Loading configuration for VM: #{vm_name}")
-
-        subvm = defined_vms[vm_name]
-
-        # First pass, first run.
-        config = inner_load[subvm]
-
-        # Second pass, with the box
-        config = inner_load[subvm, boxes.find(config.vm.box)]
-        config.vm.name = vm_name
-
-        # Return the final configuration for this VM
-        config
-      end
-
-      # Finally, we have our configuration. Set it and forget it.
-      @config = Config::Container.new(global, vm_configs)
-    end
-
-    # Loads the persisted VM (if it exists) for this environment.
-    def load_vms!
-      result = {}
-
-      # Load all the virtual machine instances.
-      config.vms.each do |name|
-        result[name] = Vagrant::VM.new(name, self, config.for_vm(name))
-      end
-
-      result
-    end
-
-    # This sets the `@home_path` variable properly.
-    #
-    # @return [Pathname]
-    def setup_home_path
-      @home_path = Pathname.new(File.expand_path(@home_path ||
-                                                 ENV["VAGRANT_HOME"] ||
-                                                 DEFAULT_HOME))
-      @logger.info("Home path: #{@home_path}")
-
-      # If the setup_version file exists, then we can't load because we're
-      # not forward compatible. It means they ran a future version of Vagrant.
-      raise Errors::IncompatibleWithFutureVersion, :path => @home_path.to_s if \
-        @home_path.join("setup_version").file?
-
-      # Setup the array of necessary home directories
-      dirs = [@home_path]
-      dirs += HOME_SUBDIRS.collect { |subdir| @home_path.join(subdir) }
-
-      # Go through each required directory, creating it if it doesn't exist
-      dirs.each do |dir|
-        next if File.directory?(dir)
-
-        begin
-          @logger.info("Creating: #{dir}")
-          FileUtils.mkdir_p(dir)
-        rescue Errno::EACCES
-          raise Errors::HomeDirectoryNotAccessible, :home_path => @home_path.to_s
-        end
-      end
-    end
-
-    protected
-
-    # This method copies the private key into the home directory if it
-    # doesn't already exist.
-    #
-    # This must be done because `ssh` requires that the key is chmod
-    # 0600, but if Vagrant is installed as a separate user, then the
-    # effective uid won't be able to read the key. So the key is copied
-    # to the home directory and chmod 0600.
-    def copy_insecure_private_key
-      if !@default_private_key_path.exist?
-        @logger.info("Copying private key to home directory")
-        FileUtils.cp(File.expand_path("keys/vagrant", Vagrant.source_root),
-                     @default_private_key_path)
-      end
-
-      if !Util::Platform.windows?
-        # On Windows, permissions don't matter as much, so don't worry
-        # about doing chmod.
-        if Util::FileMode.from_octal(@default_private_key_path.stat.mode) != "600"
-          @logger.info("Changing permissions on private key to 0600")
-          @default_private_key_path.chmod(0600)
-        end
-      end
-    end
-
-    # Finds the Vagrantfile in the given directory.
-    #
-    # @param [Pathname] path Path to search in.
-    # @return [Pathname]
-    def find_vagrantfile(search_path)
-      @vagrantfile_name.each do |vagrantfile|
-        current_path = search_path.join(vagrantfile)
-        return current_path if current_path.exist?
-      end
-
-      nil
-    end
-
-    # Loads the Vagrant plugins by properly setting up RubyGems so that
-    # our private gem repository is on the path.
-    def load_plugins
-      # Add our private gem path to the gem path and reset the paths
-      # that Rubygems knows about.
-      ENV["GEM_PATH"] = "#{@gems_path}#{::File::PATH_SEPARATOR}#{ENV["GEM_PATH"]}"
-      ::Gem.clear_paths
-
-      # Load the plugins
-      Plugin.load!
-    end
-  end
-end