9bc1ea5f04
This moves out the concept of a "default VM" from the Environment class and makes it the responsibility of the V1 configuration that at least one VM is defined on it. This lets the configuration ultimately decide what a "default" implementation is.
540 lines
18 KiB
Ruby
540 lines
18 KiB
Ruby
require 'fileutils'
|
|
require 'pathname'
|
|
require 'set'
|
|
|
|
require 'log4r'
|
|
|
|
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_HOME = "~/.vagrant.d"
|
|
DEFAULT_RC = "~/.vagrantrc"
|
|
|
|
# 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
|
|
|
|
# This is a set of the vagrantrc files already loaded so that they
|
|
# are only loaded once.
|
|
@@loaded_rc = Set.new
|
|
|
|
# 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
|
|
|
|
# Activate the plugins
|
|
activate_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(File.expand_path(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
|
|
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
|
|
if host_klass.nil? || host_klass == :detect
|
|
hosts = {}
|
|
Vagrant.plugin("1").registered.each do |plugin|
|
|
hosts = hosts.merge(plugin.host.to_hash)
|
|
end
|
|
|
|
# Get the flattened list of available hosts
|
|
host_klass = Hosts.detect(hosts)
|
|
end
|
|
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::VERSIONS, Config::VERSIONS_ORDER)
|
|
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.config_procs)
|
|
end
|
|
|
|
# We activate plugins here because the files which we're loading
|
|
# configuration from may have defined new plugins as well.
|
|
activate_plugins
|
|
|
|
# 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
|
|
|
|
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
|
|
inner_load[subvm, boxes.find(config.vm.box)]
|
|
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}")
|
|
|
|
# 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
|
|
|
|
# This finds all the current plugins and activates them. This is an
|
|
# idempotent call so it is safe to call this as much as you need.
|
|
def activate_plugins
|
|
Vagrant.plugin("1").registered.each do |plugin|
|
|
plugin.activate!
|
|
end
|
|
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}:#{ENV["GEM_PATH"]}"
|
|
::Gem.clear_paths
|
|
|
|
# Load the plugins
|
|
rc_path = File.expand_path(ENV["VAGRANT_RC"] || DEFAULT_RC)
|
|
if File.file?(rc_path) && @@loaded_rc.add?(rc_path)
|
|
@logger.debug("Loading RC file: #{rc_path}")
|
|
load rc_path
|
|
else
|
|
@logger.debug("RC file not found. Not loading: #{rc_path}")
|
|
end
|
|
end
|
|
end
|
|
end
|