vagrantup 0.8.7 → 0.8.8

data/tasks/bundler.rake

@@ -0,0 +1,3 @@
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks

data/tasks/test.rake

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

data/templates/commands/init/Vagrantfile.erb

@@ -1,3 +1,6 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
 Vagrant::Config.run do |config|
   # All Vagrant configuration is done here. The most common configuration
   # options are documented and commented below. For a complete reference,

data/templates/locales/en.yml

@@ -227,7 +227,7 @@ en:
           above with their current state. For more information about a specific
           VM, run `vagrant status NAME`.
       up:
-        vm_created: "VM already created. Booting if its not already running..."
+        vm_created: "VM already created. Booting if it's not already running..."
       upgrade_to_060:
         already_done: "Environment appears to already be upgraded to 0.6.0. Doing nothing!"
         ask: "Are you sure you want to execute this command?"

data/test/acceptance/base.rb

@@ -0,0 +1,48 @@
+require "rubygems"
+require "rspec/autorun"
+
+require "log4r"
+
+# Add this directory to the load path, since it just makes
+# everything else so much easier.
+$:.unshift File.expand_path("../", __FILE__)
+
+# Load in the supporting files for our tests
+require "support/shared/base_context"
+require "support/config"
+require "support/virtualbox"
+require "support/matchers/match_output"
+
+# Do not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# If VirtualBox is currently running, fail.
+if Acceptance::VirtualBox.find_vboxsvc
+  $stderr.puts "VirtualBox must be closed and remain closed for the duration of the tests."
+  abort
+end
+
+# Enable logging if requested
+if ENV["ACCEPTANCE_LOGGING"]
+  logger = Log4r::Logger.new("acceptance")
+  logger.outputters = Log4r::Outputter.stdout
+  logger.level = Log4r.const_get(ENV["ACCEPTANCE_LOGGING"].upcase)
+  logger = nil
+end
+
+# Parse the command line options and load the global configuration.
+if !ENV.has_key?("ACCEPTANCE_CONFIG")
+  $stderr.puts "A configuration file must be passed into the acceptance test."
+  abort
+elsif !File.file?(ENV["ACCEPTANCE_CONFIG"])
+  $stderr.puts "The configuration file must exist."
+  abort
+end
+
+$acceptance_options = Acceptance::Config.new(ENV["ACCEPTANCE_CONFIG"])
+
+# Configure RSpec
+RSpec.configure do |c|
+  c.expect_with :rspec, :stdlib
+end

data/test/acceptance/box_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path("../base", __FILE__)
+
+describe "vagrant box" do
+  include_context "acceptance"
+
+  it "has no boxes by default" do
+    result = execute("vagrant", "box", "list")
+    result.stdout.should match_output(:no_boxes)
+  end
+
+  it "can add a box from a file" do
+    require_box("default")
+
+    # Add the box, which we expect to succeed
+    result = execute("vagrant", "box", "add", "foo", box_path("default"))
+    result.should be_success
+
+    # Verify that the box now shows up in the list of available boxes
+    result = execute("vagrant", "box", "list")
+    result.stdout.should match_output(:box_installed, "foo")
+  end
+
+  it "gives an error if the file doesn't exist" do
+    result = execute("vagrant", "box", "add", "foo", "/tmp/nope/nope/nope/nonono.box")
+    result.should_not be_success
+    result.stdout.should match_output(:box_path_doesnt_exist)
+  end
+
+  it "gives an error if the file is not a valid box" do
+    invalid = environment.workdir.join("nope.txt")
+    invalid.open("w+") do |f|
+      f.write("INVALID!")
+    end
+
+    result = execute("vagrant", "box", "add", "foo", invalid.to_s)
+    result.should_not be_success
+    result.stdout.should match_output(:box_invalid)
+  end
+
+  it "can add a box from an HTTP server" do
+    pending("Need to setup HTTP server functionality")
+  end
+
+  it "can remove a box" do
+    require_box("default")
+
+    # Add the box, remove the box, then verify that the box no longer
+    # shows up in the list of available boxes.
+    execute("vagrant", "box", "add", "foo", box_path("default"))
+    execute("vagrant", "box", "remove", "foo")
+    result = execute("vagrant", "box", "list")
+    result.should be_success
+    result.stdout.should match_output(:no_boxes)
+  end
+
+  it "can repackage a box" do
+    require_box("default")
+
+    original_size = File.size(box_path("default"))
+    logger.debug("Original package size: #{original_size}")
+
+    # Add the box, repackage it, and verify that a package.box is
+    # dumped of relatively similar size.
+    execute("vagrant", "box", "add", "foo", box_path("default"))
+    execute("vagrant", "box", "repackage", "foo")
+
+    # By default, repackage should dump into package.box into the CWD
+    repackaged_file = environment.workdir.join("package.box")
+    repackaged_file.file?.should be, "package.box should exist in cwd of environment"
+
+    # Compare the sizes
+    repackaged_size = repackaged_file.size
+    logger.debug("Repackaged size: #{repackaged_size}")
+    size_diff = (repackaged_size - original_size).abs
+    size_diff.should be < 1000, "Sizes should be very similar"
+  end
+end

data/test/acceptance/destroy_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path("../base", __FILE__)
+require "support/shared/command_examples"
+
+describe "vagrant destroy" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "destroy"]
+
+  it "succeeds and ignores if the VM is not created" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+
+    result = assert_execute("vagrant", "destroy")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+
+  it "is able to destroy a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    # Destroy the VM and assert that it worked properly (seemingly)
+    result = assert_execute("vagrant", "destroy")
+    result.stdout.should match_output(:vm_destroyed)
+
+    # Assert that the VM no longer is created
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "not created")
+  end
+
+  # TODO:
+  # it is able to destroy a halted virtual machine
+  # it is able to destroy a suspended virtual machine
+end

data/test/acceptance/halt_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path("../base", __FILE__)
+require "support/shared/command_examples"
+
+describe "vagrant halt" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "halt"]
+
+  it "succeeds and ignores if the VM is not created" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+
+    result = assert_execute("vagrant", "halt")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+
+  it "is able to halt a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    # Halt the VM and assert that it worked properly (seemingly)
+    result = assert_execute("vagrant", "halt")
+    result.stdout.should match_output(:vm_halt_graceful)
+
+    # Assert that the VM is no longer running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "powered off")
+  end
+
+  it "is able to force halt a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    # Halt the VM and assert that it worked properly (seemingly)
+    result = assert_execute("vagrant", "halt", "--force")
+    result.stdout.should match_output(:vm_halt_force)
+
+    # Assert that the VM is no longer running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "powered off")
+  end
+
+  it "is able to come back up after the machine has been halted" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+    assert_execute("vagrant", "halt")
+
+    # Assert that the VM is no longer running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "powered off")
+
+    assert_execute("vagrant", "up")
+
+    # Assert that the VM is once again running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "running")
+  end
+
+  # TODO:
+  # halt behavior on suspend machine
+  # halt behavior if machine is already powered off
+end

data/test/acceptance/init_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path("../base", __FILE__)
+
+describe "vagrant init" do
+  include_context "acceptance"
+
+  it "creates a Vagrantfile in the working directory" do
+    vagrantfile = environment.workdir.join("Vagrantfile")
+    vagrantfile.exist?.should_not be, "Vagrantfile shouldn't exist initially"
+
+    result = execute("vagrant", "init")
+    result.should be_success
+    vagrantfile.exist?.should be, "Vagrantfile should exist"
+  end
+
+  it "creates a Vagrantfile with the box set to the given argument" do
+    vagrantfile = environment.workdir.join("Vagrantfile")
+
+    result = execute("vagrant", "init", "foo")
+    result.should be_success
+    vagrantfile.read.should match(/config.vm.box = "foo"$/)
+  end
+
+  it "creates a Vagrantfile with the box URL set to the given argument" do
+    vagrantfile = environment.workdir.join("Vagrantfile")
+
+    result = execute("vagrant", "init", "foo", "bar")
+    result.should be_success
+
+    contents = vagrantfile.read
+    contents.should match(/config.vm.box = "foo"$/)
+    contents.should match(/config.vm.box_url = "bar"$/)
+  end
+end

data/test/acceptance/resume_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../base", __FILE__)
+require "support/shared/command_examples"
+
+describe "vagrant resume" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "resume"]
+
+  it "succeeds and ignores if the VM is not created" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+
+    result = assert_execute("vagrant", "resume")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+end

data/test/acceptance/ssh_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path("../base", __FILE__)
+require "support/shared/command_examples"
+
+describe "vagrant ssh" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "ssh"]
+  it_behaves_like "a command that requires a virtual machine", ["vagrant", "ssh"]
+
+  it "is able to SSH into a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    outputted = false
+    result = assert_execute("vagrant", "ssh") do |io_type, data|
+      if io_type == :stdin and !outputted
+        data.puts("echo hello")
+        data.puts("exit")
+        outputted = true
+      end
+    end
+
+    result.stdout.chomp.should eql("hello"), "Vagrant should bring up a VM to be able to SSH into."
+  end
+
+  it "is able to execute a single command via the command line" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    result = assert_execute("vagrant", "ssh", "-c", "echo foo")
+    result.stdout.should == "foo\n"
+  end
+
+  # TODO:
+  # SSH should fail if the VM is not running
+end

data/test/acceptance/support/config.rb

@@ -0,0 +1,42 @@
+require "yaml"
+
+require "log4r"
+
+module Acceptance
+  # This represents a configuration object for acceptance tests.
+  class Config
+    attr_reader :vagrant_path
+    attr_reader :vagrant_version
+    attr_reader :env
+    attr_reader :box_directory
+
+    def initialize(path)
+      @logger = Log4r::Logger.new("acceptance::config")
+      @logger.info("Loading configuration from: #{path}")
+      options = YAML.load_file(path)
+      @logger.info("Loaded: #{options.inspect}")
+
+      @vagrant_path    = options["vagrant_path"]
+      @vagrant_version = options["vagrant_version"]
+      @env             = options["env"]
+      @box_directory   = options["box_directory"]
+
+      # Verify the configuration object.
+      validate
+    end
+
+    # This method verifies the configuration and makes sure that
+    # all the configuration is available and appears good. This
+    # method will raise an ArgumentError in the case that anything
+    # is wrong.
+    def validate
+      if !@vagrant_path || !File.file?(@vagrant_path)
+        raise ArgumentError, "'vagrant_path' must point to the `vagrant` executable"
+      elsif !@vagrant_version
+        raise ArgumentError, "`vagrant_version' must be set to the version of the `vagrant` executable"
+      elsif !@box_directory || !File.directory?(@box_directory)
+        raise ArgumentError, "`box_directory` must be set to a folder containing boxes for the tests."
+      end
+    end
+  end
+end

data/test/acceptance/support/isolated_environment.rb

@@ -0,0 +1,226 @@
+require "fileutils"
+require "pathname"
+
+require "log4r"
+require "childprocess"
+
+require File.expand_path("../tempdir", __FILE__)
+require File.expand_path("../virtualbox", __FILE__)
+
+module Acceptance
+  # This class manages an isolated environment for Vagrant to
+  # run in. It creates a temporary directory to act as the
+  # working directory as well as sets a custom home directory.
+  class IsolatedEnvironment
+    attr_reader :homedir
+    attr_reader :workdir
+
+    # Initializes an isolated environment. You can pass in some
+    # options here to configure runing custom applications in place
+    # of others as well as specifying environmental variables.
+    #
+    # @param [Hash] apps A mapping of application name (such as "vagrant")
+    #   to an alternate full path to the binary to run.
+    # @param [Hash] env Additional environmental variables to inject
+    #   into the execution environments.
+    def initialize(apps=nil, env=nil)
+      @logger = Log4r::Logger.new("acceptance::isolated_environment")
+
+      @apps = apps || {}
+      @env  = env || {}
+
+      # Create a temporary directory for our work
+      @tempdir = Tempdir.new("vagrant")
+      @logger.info("Initialize isolated environment: #{@tempdir.path}")
+
+      # Setup the home and working directories
+      @homedir = Pathname.new(File.join(@tempdir.path, "home"))
+      @workdir = Pathname.new(File.join(@tempdir.path, "work"))
+
+      @homedir.mkdir
+      @workdir.mkdir
+
+      # Set the home directory and virtualbox home directory environmental
+      # variables so that Vagrant and VirtualBox see the proper paths here.
+      @env["HOME"] = @homedir.to_s
+      @env["VBOX_USER_HOME"] = @homedir.to_s
+    end
+
+    # Executes a command in the context of this isolated environment.
+    # Any command executed will therefore see our temporary directory
+    # as the home directory.
+    def execute(command, *argN)
+      command = replace_command(command)
+
+      # Get the hash options passed to this method
+      options = argN.last.is_a?(Hash) ? argN.pop : {}
+      timeout = options.delete(:timeout)
+
+      # Build a child process to run this command. For the stdout/stderr
+      # we use pipes so that we can select() on it and block and stream
+      # data in as it comes.
+      @logger.info("Executing: #{command} #{argN.inspect}. Output will stream in...")
+      process = ChildProcess.build(command, *argN)
+      stdout, stdout_writer = IO.pipe
+      process.io.stdout = stdout_writer
+
+      stderr, stderr_writer = IO.pipe
+      process.io.stderr = stderr_writer
+      process.duplex = true
+
+      @env.each do |k, v|
+        process.environment[k] = v
+      end
+
+      Dir.chdir(@workdir.to_s) do
+        process.start
+        process.io.stdin.sync = true
+      end
+
+      # Close our side of the pipes, since we're just reading
+      stdout_writer.close
+      stderr_writer.close
+
+      # Create a hash to store all the data we see.
+      io_data = { stdout => "", stderr => "" }
+
+      # Record the start time for timeout purposes
+      start_time = Time.now.to_i
+
+      @logger.debug("Selecting on IO...")
+      while true
+        results = IO.select([stdout, stderr],
+                            [process.io.stdin], nil, timeout || 5)
+
+        # Check if we have exceeded our timeout from waiting on a select()
+        raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+        # Check the readers first to see if they're ready
+        readers = results[0]
+        if !readers.empty?
+          begin
+            readers.each do |r|
+              data = r.read_nonblock(1024)
+              io_data[r] += data
+              io_name = r == stdout ? "stdout" : "stderr"
+              @logger.debug(data)
+              yield io_name.to_sym, data if block_given?
+            end
+          rescue IO::WaitReadable
+            # This just means the IO wasn't actually ready and we should
+            # wait some more. So we just let this pass through.
+          rescue EOFError
+            # Process exited, so break out of this while loop
+            break
+          end
+        end
+
+        # Check if the process exited in order to break the loop before
+        # we try to see if any stdin is ready.
+        break if process.exited?
+
+        # Check the writers to see if they're ready, and notify any listeners
+        if !results[1].empty?
+          yield :stdin, process.io.stdin if block_given?
+        end
+      end
+
+      # Continually try to wait for the process to end, but do so asynchronously
+      # so that we can also check to see if we have exceeded a timeout.
+      begin
+        # If a timeout is not set, we set a very large timeout to
+        # simulate "forever"
+        @logger.debug("Waiting for process to exit...")
+        remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+        remaining = 0 if remaining < 0
+        process.poll_for_exit(remaining)
+      rescue ChildProcess::TimeoutError
+        raise TimeoutExceeded, process.pid
+      end
+
+      @logger.debug("Exit status: #{process.exit_code}")
+      return ExecuteProcess.new(process.exit_code, io_data[stdout], io_data[stderr])
+    end
+
+    # Closes the environment, cleans up the temporary directories, etc.
+    def close
+      # Only delete virtual machines if VBoxSVC is running, meaning
+      # that something related to VirtualBox started running in this
+      # environment.
+      delete_virtual_machines if VirtualBox.find_vboxsvc
+
+      # Delete the temporary directory
+      @logger.info("Removing isolated environment: #{@tempdir.path}")
+      FileUtils.rm_rf(@tempdir.path)
+    end
+
+    def delete_virtual_machines
+      # Delete all virtual machines
+      @logger.debug("Finding all virtual machines")
+      execute("VBoxManage", "list", "vms").stdout.lines.each do |line|
+        data = /^"(?<name>.+?)" {(?<uuid>.+?)}$/.match(line)
+
+        begin
+          @logger.debug("Removing VM: #{data[:name]}")
+
+          # We add a timeout onto this because sometimes for seemingly no
+          # reason it will simply freeze, although the VM is successfully
+          # "aborted." The timeout gets around this strange behavior.
+          execute("VBoxManage", "controlvm", data[:uuid], "poweroff", :timeout => 5)
+        rescue TimeoutExceeded => e
+          @logger.info("Failed to poweroff VM '#{data[:uuid]}'. Killing process.")
+
+          # Kill the process and wait a bit for it to disappear
+          Process.kill('KILL', e.pid)
+          Process.waitpid2(e.pid)
+        end
+
+        sleep 0.5
+
+        result = execute("VBoxManage", "unregistervm", data[:uuid], "--delete")
+        raise Exception, "VM unregistration failed!" if result.exit_status != 0
+      end
+
+      @logger.info("Removed all virtual machines")
+    end
+
+    # This replaces a command with a replacement defined when this
+    # isolated environment was initialized. If nothing was defined,
+    # then the command itself is returned.
+    def replace_command(command)
+      return @apps[command] if @apps.has_key?(command)
+      return command
+    end
+  end
+
+  # This class represents a process which has run via the IsolatedEnvironment.
+  # This is a readonly structure that can be used to inspect the exit status,
+  # stdout, stderr, etc. from the process which ran.
+  class ExecuteProcess
+    attr_reader :exit_status
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(exit_status, stdout, stderr)
+      @exit_status = exit_status
+      @stdout      = stdout
+      @stderr      = stderr
+    end
+
+    def success?
+      @exit_status == 0
+    end
+  end
+
+  # This exception is raised if the timeout for a process is exceeded.
+  class TimeoutExceeded < StandardError
+    attr_reader :pid
+
+    def initialize(pid)
+      @pid = pid
+
+      super()
+    end
+  end
+end
+