vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/vm.rb

@@ -1,100 +1,98 @@
+require 'log4r'
+
 module Vagrant
   class VM
     include Vagrant::Util
 
+    attr_reader :uuid
     attr_reader :env
     attr_reader :name
     attr_reader :vm
-
-    class << self
-      # Finds a virtual machine by a given UUID and either returns
-      # a Vagrant::VM object or returns nil.
-      def find(uuid, env=nil, name=nil)
-        vm = VirtualBox::VM.find(uuid)
-        new(:vm => vm, :env => env, :name => name)
+    attr_reader :box
+    attr_reader :config
+    attr_reader :driver
+
+    def initialize(name, env, config, opts=nil)
+      @logger = Log4r::Logger.new("vagrant::vm")
+
+      @name   = name
+      @vm     = nil
+      @env    = env
+      @config = config
+      @box    = env.boxes.find(config.vm.box)
+
+      opts ||= {}
+      if opts[:base]
+        # The name is the ID we use.
+        @uuid = name
+      else
+        # Load the UUID if its saved.
+        active = env.local_data[:active] || {}
+        @uuid = active[@name.to_s]
       end
-    end
-
-    def initialize(opts=nil)
-      defaults = {
-        :vm => nil,
-        :env => nil,
-        :name => nil
-      }
 
-      opts = defaults.merge(opts || {})
+      # Reload ourselves to get the state
+      reload!
 
-      @vm = opts[:vm]
-      @name = opts[:name]
-
-      if !opts[:env].nil?
-        # We have an environment, so we create a new child environment
-        # specifically for this VM. This step will load any custom
-        # config and such.
-        @env = Vagrant::Environment.new({
-          :cwd => opts[:env].cwd,
-          :parent => opts[:env],
-          :vm => self
-        }).load!
-
-        # Load the associated system.
-        load_system!
-      end
-
-      @loaded_system_distro = false
+      # Load the associated guest.
+      load_guest!
+      @loaded_guest_distro = false
     end
 
-    # Loads the system associated with the VM. The system class is
+    # Loads the guest associated with the VM. The guest class is
     # responsible for OS-specific functionality. More information
-    # can be found by reading the documentation on {Vagrant::Systems::Base}.
+    # can be found by reading the documentation on {Vagrant::Guest::Base}.
     #
     # **This method should never be called manually.**
-    def load_system!(system=nil)
-      system ||= env.config.vm.system
-      env.logger.info("vm: #{name}") { "Loading system: #{system}" }
-
-      if system.is_a?(Class)
-        raise Errors::VMSystemError, :_key => :invalid_class, :system => system.to_s if !(system <= Systems::Base)
-        @system = system.new(self)
-      elsif system.is_a?(Symbol)
-        # Hard-coded internal systems
-        mapping = {
-          :debian  => Systems::Debian,
-          :ubuntu  => Systems::Ubuntu,
-          :freebsd => Systems::FreeBSD,
-          :gentoo  => Systems::Gentoo,
-          :redhat  => Systems::Redhat,
-          :suse    => Systems::Suse,
-          :linux   => Systems::Linux,
-          :solaris => Systems::Solaris,
-          :arch    => Systems::Arch
-        }
-
-        raise Errors::VMSystemError, :_key => :unknown_type, :system => system.to_s if !mapping.has_key?(system)
-        @system = mapping[system].new(self)
+    def load_guest!(guest=nil)
+      guest ||= config.vm.guest
+      @logger.info("Loading guest: #{guest}")
+
+      if guest.is_a?(Class)
+        raise Errors::VMGuestError, :_key => :invalid_class, :system => guest.to_s if !(guest <= Systems::Base)
+        @guest = guest.new(self)
+      elsif guest.is_a?(Symbol)
+        guest_klass = Vagrant.guests.get(guest)
+        raise Errors::VMGuestError, :_key => :unknown_type, :system => guest.to_s if !guest_klass
+        @guest = guest_klass.new(self)
       else
-        raise Errors::VMSystemError, :unspecified
+        raise Errors::VMGuestError, :unspecified
       end
     end
 
-    # Returns the system for this VM, loading the distro of the system if
+    # Returns a channel object to communicate with the virtual
+    # machine.
+    def channel
+      @channel ||= Communication::SSH.new(self)
+    end
+
+    # Returns the guest for this VM, loading the distro of the system if
     # we can.
-    def system
-      if !@loaded_system_distro && created? && vm.running?
-        # Load the system distro for the first time
-        result = @system.distro_dispatch
-        load_system!(result)
-        @loaded_system_distro = true
+    def guest
+      if !@loaded_guest_distro && state == :running
+        # Load the guest distro for the first time
+        result = @guest.distro_dispatch
+        load_guest!(result)
+        @loaded_guest_distro = true
       end
 
-      @system
+      @guest
     end
 
-    # Access the {Vagrant::SSH} object associated with this VM.
-    # On the initial call, this will initialize the object. On
-    # subsequent calls it will reuse the existing object.
+    # Access the {Vagrant::SSH} object associated with this VM, which
+    # is used to get SSH credentials with the virtual machine.
     def ssh
-      @ssh ||= SSH.new(env)
+      @ssh ||= SSH.new(self)
+    end
+
+    # Returns the state of the VM as a symbol.
+    #
+    # @return [Symbol]
+    def state
+      return :not_created if !@uuid
+      state = @driver.read_state
+      return :not_created if !state
+      return state
     end
 
     # Returns a boolean true if the VM has been created, otherwise
@@ -102,19 +100,17 @@ module Vagrant
     #
     # @return [Boolean]
     def created?
-      !vm.nil?
+      state != :not_created
     end
 
     # Sets the currently active VM for this VM. If the VM is a valid,
     # created virtual machine, then it will also update the local data
     # to persist the VM. Otherwise, it will remove itself from the
     # local data (if it exists).
-    def vm=(value)
-      @vm = value
+    def uuid=(value)
       env.local_data[:active] ||= {}
-
-      if value && value.uuid
-        env.local_data[:active][name.to_s] = value.uuid
+      if value
+        env.local_data[:active][name.to_s] = value
       else
         env.local_data[:active].delete(name.to_s)
       end
@@ -122,60 +118,78 @@ module Vagrant
       # Commit the local data so that the next time vagrant is initialized,
       # it realizes the VM exists
       env.local_data.commit
-    end
 
-    def uuid
-      vm ? vm.uuid : nil
+      # Store the uuid and reload the instance
+      @uuid = value
+      reload!
     end
 
     def reload!
-      @vm = VirtualBox::VM.find(@vm.uuid)
+      begin
+        @driver = Driver::VirtualBox.new(@uuid)
+      rescue Driver::VirtualBox::VMNotFound
+        # Clear the UUID since this VM doesn't exist. Note that this calls
+        # back into `reload!` but shouldn't ever result in infinite
+        # recursion since `@uuid` will be nil.
+        self.uuid = nil
+      end
     end
 
     def package(options=nil)
-      env.actions.run(:package, { "validate" => false }.merge(options || {}))
+      run_action(:package, { "validate" => false }.merge(options || {}))
     end
 
     def up(options=nil)
-      env.actions.run(:up, options)
+      run_action(:up, options)
     end
 
     def start(options=nil)
-      raise Errors::VMInaccessible if !@vm.accessible?
-      return if @vm.running?
-      return resume if @vm.saved?
+      return if state == :running
+      return resume if state == :saved
 
-      env.actions.run(:start, options)
+      run_action(:start, options)
     end
 
     def halt(options=nil)
-      env.actions.run(:halt, options)
+      run_action(:halt, options)
     end
 
     def reload
-      env.actions.run(:reload)
+      run_action(:reload)
     end
 
     def provision
-      env.actions.run(:provision)
+      run_action(:provision)
     end
 
     def destroy
-      env.actions.run(:destroy)
+      run_action(:destroy)
     end
 
     def suspend
-      env.actions.run(:suspend)
+      run_action(:suspend)
     end
 
     def resume
-      env.actions.run(:resume)
+      run_action(:resume)
     end
 
-    def saved?
-      @vm.saved?
+    def ui
+      return @_ui if defined?(@_ui)
+      @_ui = @env.ui.dup
+      @_ui.resource = @name
+      @_ui
     end
 
-    def powered_off?; @vm.powered_off? end
+    protected
+
+    def run_action(name, options=nil)
+      options = {
+        :vm => self,
+        :ui => ui
+      }.merge(options || {})
+
+      env.action_runner.run(name, options)
+    end
   end
 end

data/lib/vagrant.rb

@@ -1,7 +1,36 @@
+# Enable logging if it is requested. We do this before
+# anything else so that we can setup the output before
+# any logging occurs.
+if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
+  # Require Log4r and define the levels we'll be using
+  require 'log4r'
+  require 'log4r/config'
+  Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+  level = nil
+  begin
+    level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+  rescue NameError
+    # This means that the logging constant wasn't found,
+    # which is fine. We just keep `level` as `nil`. But
+    # we tell the user.
+    $stderr.puts "Invalid VAGRANT_LOG level is set: #{ENV["VAGRANT_LOG"]}"
+  end
+
+  # Set the logging level on all "vagrant" namespaced
+  # logs as long as we have a valid level.
+  if level
+    logger = Log4r::Logger.new("vagrant")
+    logger.outputters = Log4r::Outputter.stdout
+    logger.level = level
+    logger = nil
+  end
+end
+
 require 'pathname'
+require 'childprocess'
 require 'json'
 require 'i18n'
-require 'virtualbox'
 
 # OpenSSL must be loaded here since when it is loaded via `autoload`
 # there are issues with ciphers not being properly loaded.
@@ -12,13 +41,19 @@ module Vagrant
   autoload :Box,           'vagrant/box'
   autoload :BoxCollection, 'vagrant/box_collection'
   autoload :CLI,           'vagrant/cli'
+  autoload :Command,       'vagrant/command'
+  autoload :Communication, 'vagrant/communication'
   autoload :Config,        'vagrant/config'
   autoload :DataStore,     'vagrant/data_store'
   autoload :Downloaders,   'vagrant/downloaders'
+  autoload :Driver,        'vagrant/driver'
   autoload :Environment,   'vagrant/environment'
   autoload :Errors,        'vagrant/errors'
+  autoload :Guest,         'vagrant/guest'
   autoload :Hosts,         'vagrant/hosts'
   autoload :Plugin,        'vagrant/plugin'
+  autoload :Provisioners,  'vagrant/provisioners'
+  autoload :Registry,      'vagrant/registry'
   autoload :SSH,           'vagrant/ssh'
   autoload :TestHelpers,   'vagrant/test_helpers'
   autoload :UI,            'vagrant/ui'
@@ -30,15 +65,107 @@ module Vagrant
   def self.source_root
     @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
   end
+
+  # Global registry of commands that are available via the CLI.
+  #
+  # This registry is used to look up the sub-commands that are available
+  # to Vagrant.
+  def self.commands
+    @commands ||= Registry.new
+  end
+
+  # Global registry of config keys that are available.
+  #
+  # This registry is used to look up the keys for `config` objects.
+  # For example, `config.vagrant` looks up the `:vagrant` config key
+  # for the configuration class to use.
+  def self.config_keys
+    @config_keys ||= Registry.new
+  end
+
+  # Global registry of available host classes and shortcut symbols
+  # associated with them.
+  #
+  # This registry is used to look up the shorcuts for `config.vagrant.host`,
+  # or to query all hosts for automatically detecting the host system.
+  # The registry is global to all of Vagrant.
+  def self.hosts
+    @hosts ||= Registry.new
+  end
+
+  # Global registry of available guest classes and shortcut symbols
+  # associated with them.
+  #
+  # This registry is used to look up the shortcuts for `config.vm.guest`.
+  def self.guests
+    @guests ||= Registry.new
+  end
+
+  # Global registry of provisioners.
+  #
+  # This registry is used to look up the provisioners provided for
+  # `config.vm.provision`.
+  def self.provisioners
+    @provisioners ||= Registry.new
+  end
 end
 
 # # Default I18n to load the en locale
 I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
 
+# Register the built-in commands
+Vagrant.commands.register(:box)          { Vagrant::Command::Box }
+Vagrant.commands.register(:destroy)      { Vagrant::Command::Destroy }
+Vagrant.commands.register(:halt)         { Vagrant::Command::Halt }
+Vagrant.commands.register(:init)         { Vagrant::Command::Init }
+Vagrant.commands.register(:package)      { Vagrant::Command::Package }
+Vagrant.commands.register(:provision)    { Vagrant::Command::Provision }
+Vagrant.commands.register(:reload)       { Vagrant::Command::Reload }
+Vagrant.commands.register(:resume)       { Vagrant::Command::Resume }
+Vagrant.commands.register(:ssh)          { Vagrant::Command::SSH }
+Vagrant.commands.register(:"ssh-config") { Vagrant::Command::SSHConfig }
+Vagrant.commands.register(:status)       { Vagrant::Command::Status }
+Vagrant.commands.register(:suspend)      { Vagrant::Command::Suspend }
+Vagrant.commands.register(:up)           { Vagrant::Command::Up }
+
+# Register the built-in config keys
+Vagrant.config_keys.register(:vagrant) { Vagrant::Config::VagrantConfig }
+Vagrant.config_keys.register(:ssh)     { Vagrant::Config::SSHConfig }
+Vagrant.config_keys.register(:nfs)     { Vagrant::Config::NFSConfig }
+Vagrant.config_keys.register(:vm)      { Vagrant::Config::VMConfig }
+Vagrant.config_keys.register(:package) { Vagrant::Config::PackageConfig }
+
+# Register the built-in hosts
+Vagrant.hosts.register(:arch)    { Vagrant::Hosts::Arch }
+Vagrant.hosts.register(:bsd)     { Vagrant::Hosts::BSD }
+Vagrant.hosts.register(:fedora)  { Vagrant::Hosts::Fedora }
+Vagrant.hosts.register(:freebsd) { Vagrant::Hosts::FreeBSD }
+Vagrant.hosts.register(:linux)   { Vagrant::Hosts::Linux }
+Vagrant.hosts.register(:windows) { Vagrant::Hosts::Windows }
+
+# Register the built-in guests
+Vagrant.guests.register(:arch)    { Vagrant::Guest::Arch }
+Vagrant.guests.register(:debian)  { Vagrant::Guest::Debian }
+Vagrant.guests.register(:freebsd) { Vagrant::Guest::FreeBSD }
+Vagrant.guests.register(:gentoo)  { Vagrant::Guest::Gentoo }
+Vagrant.guests.register(:linux)   { Vagrant::Guest::Linux }
+Vagrant.guests.register(:redhat)  { Vagrant::Guest::Redhat }
+Vagrant.guests.register(:solaris) { Vagrant::Guest::Solaris }
+Vagrant.guests.register(:suse)    { Vagrant::Guest::Suse }
+Vagrant.guests.register(:ubuntu)  { Vagrant::Guest::Ubuntu }
+
+# Register the built-in provisioners
+Vagrant.provisioners.register(:chef_solo)     { Vagrant::Provisioners::ChefSolo }
+Vagrant.provisioners.register(:chef_client)   { Vagrant::Provisioners::ChefClient }
+Vagrant.provisioners.register(:puppet)        { Vagrant::Provisioners::Puppet }
+Vagrant.provisioners.register(:puppet_server) { Vagrant::Provisioners::PuppetServer }
+Vagrant.provisioners.register(:shell)         { Vagrant::Provisioners::Shell }
+
+# Register the built-in systems
+Vagrant.config_keys.register(:freebsd) { Vagrant::Guest::FreeBSD::FreeBSDConfig }
+Vagrant.config_keys.register(:linux)   { Vagrant::Guest::Linux::LinuxConfig }
+Vagrant.config_keys.register(:solaris) { Vagrant::Guest::Solaris::SolarisConfig }
+
 # Load the things which must be loaded before anything else.
-require 'vagrant/command'
-require 'vagrant/provisioners'
-require 'vagrant/systems'
 require 'vagrant/version'
-Vagrant::Action.builtin!
 Vagrant::Plugin.load!

data/tasks/acceptance.rake

@@ -12,7 +12,7 @@ namespace :acceptance do
   desc "Downloads the boxes required for running the acceptance tests."
   task :boxes, :directory do |t, args|
     # Create the directory where the boxes will be downloaded
-    box_dir = Pathname.new(args[:directory] || File.expand_path("../../test/tmp/boxes", __FILE__))
+    box_dir = Pathname.new(args[:directory] || File.expand_path("../../boxes", __FILE__))
     box_dir.mkpath
     puts "Boxes will be placed in: #{box_dir}"
 
@@ -73,10 +73,10 @@ namespace :acceptance do
   desc "Generates the configuration for acceptance tests from current source."
   task :config, :box_dir do |t, args|
     require File.expand_path("../../lib/vagrant/version", __FILE__)
-    require File.expand_path('../../test/acceptance/support/tempdir', __FILE__)
+    require File.expand_path('../../test/support/tempdir', __FILE__)
 
     # Get the directory for the boxes
-    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../test/tmp/boxes", __FILE__))
+    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../boxes", __FILE__))
 
     # Generate the binstubs for the Vagrant binary
     tempdir = Tempdir.new

data/tasks/test.rake

@@ -2,12 +2,17 @@ require 'rake/testtask'
 require 'rspec/core/rake_task'
 
 namespace :test do
-  Rake::TestTask.new do |t|
+  RSpec::Core::RakeTask.new do |t|
     t.name = "unit"
-    t.libs << "test/unit"
     t.pattern = "test/unit/**/*_test.rb"
   end
 
+  Rake::TestTask.new do |t|
+    t.name = "unit_old"
+    t.libs << "test/unit_legacy"
+    t.pattern = "test/unit_legacy/**/*_test.rb"
+  end
+
   RSpec::Core::RakeTask.new do |t|
     t.name = "acceptance"
     t.pattern = "test/acceptance/**/*_test.rb"

data/templates/commands/init/Vagrantfile.erb

@@ -16,13 +16,20 @@ Vagrant::Config.run do |config|
   # Boot with a GUI so you can see the screen. (Default is headless)
   # config.vm.boot_mode = :gui
 
-  # Assign this VM to a host only network IP, allowing you to access it
-  # via the IP.
-  # config.vm.network "33.33.33.10"
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "33.33.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
 
   # Forward a port from the guest to the host, which allows for outside
   # computers to access the VM, whereas host only networking does not.
-  # config.vm.forward_port "http", 80, 8080
+  # config.vm.forward_port 80, 8080
 
   # Share an additional folder to the guest VM. The first argument is
   # an identifier, the second is the path on the guest to mount the

data/templates/guests/arch/network_dhcp.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+interface=eth<%= options[:interface] %>
+address=
+netmask=
+gateway=
+#VAGRANT-END

data/templates/guests/arch/network_static.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+interface=eth<%= options[:interface] %>
+address=<%= options[:ip]%>
+netmask=<%= options[:netmask] %>
+gateway=
+#VAGRANT-END

data/templates/guests/debian/network_dhcp.erb

@@ -0,0 +1,6 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet dhcp
+    post-up route del default dev $IFACE
+#VAGRANT-END

data/templates/guests/debian/network_static.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet static
+      address <%= options[:ip] %>
+      netmask <%= options[:netmask] %>
+#VAGRANT-END

data/templates/guests/gentoo/network_dhcp.erb

@@ -0,0 +1,4 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+config_eth<%= options[:interface] %>="dhcp"
+#VAGRANT-END

data/templates/guests/gentoo/network_static.erb

@@ -0,0 +1,4 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+config_eth<%= options[:interface] %>=("<%= options[:ip] %> netmask <%= options[:netmask] %>")
+#VAGRANT-END

data/templates/guests/redhat/network_dhcp.erb

@@ -0,0 +1,6 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+BOOTPROTO=dhcp
+ONBOOT=yes
+DEVICE=eth<%= options[:interface] %>
+#VAGRANT-END

data/templates/guests/redhat/network_static.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+BOOTPROTO=static
+IPADDR=<%= options[:ip] %>
+NETMASK=<%= options[:netmask] %>
+DEVICE=eth<%= options[:interface] %>
+#VAGRANT-END