vagrant 0.2.0 → 0.3.0

data/lib/vagrant/env.rb

@@ -1,189 +0,0 @@
-module Vagrant
-  class Env
-    ROOTFILE_NAME = "Vagrantfile"
-    HOME_SUBDIRS = ["tmp", "boxes"]
-
-    # Initialize class variables used
-    @@persisted_vm = nil
-    @@root_path = nil
-    @@box = nil
-
-    extend Vagrant::Util
-
-    class << self
-      def box; @@box; end
-      def persisted_vm; @@persisted_vm; end
-      def root_path; @@root_path; end
-      def dotfile_path;File.join(root_path, Vagrant.config.vagrant.dotfile_name); end
-      def home_path; File.expand_path(Vagrant.config.vagrant.home); end
-      def tmp_path; File.join(home_path, "tmp"); end
-      def boxes_path; File.join(home_path, "boxes"); end
-
-      def load!
-        load_root_path!
-        load_config!
-        load_home_directory!
-        load_box!
-        load_config!
-        check_virtualbox!
-        load_vm!
-      end
-
-      def check_virtualbox!
-        version = VirtualBox::Command.version
-        if version.nil?
-          error_and_exit(<<-msg)
-Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.
-If VirtualBox is installed, you may need to tweak the paths to the `VBoxManage`
-application which ships with VirtualBox and the path to the global XML configuration
-which VirtualBox typically stores somewhere in your home directory.
-
-The following shows how to configure VirtualBox. This can be done in the
-Vagrantfile. Note that 90% of the time, you shouldn't need to do this if VirtualBox
-is installed. Please use the various Vagrant support lines to request more information
-if you can't get this working.
-
-VirtualBox::Command.vboxmanage = "/path/to/my/VBoxManage"
-VirtualBox::Global.vboxconfig = "~/path/to/VirtualBox.xml"
-msg
-        elsif version.to_f < 3.1
-          error_and_exit(<<-msg)
-Vagrant has detected that you have VirtualBox version #{version} installed!
-Vagrant requires that you use at least VirtualBox version 3.1. Please install
-a more recent version of VirtualBox to continue.
-msg
-        end
-      end
-
-      def load_config!
-        # Prepare load paths for config files
-        load_paths = [File.join(PROJECT_ROOT, "config", "default.rb")]
-        load_paths << File.join(box.directory, ROOTFILE_NAME) if box
-        load_paths << File.join(home_path, ROOTFILE_NAME) if Vagrant.config.vagrant.home
-        load_paths << File.join(root_path, ROOTFILE_NAME) if root_path
-
-        # Then clear out the old data
-        Config.reset!
-
-        load_paths.each do |path|
-          if File.exist?(path)
-            logger.info "Loading config from #{path}..."
-            load path
-          end
-        end
-
-        # Execute the configurations
-        Config.execute!
-      end
-
-      def load_home_directory!
-        home_dir = File.expand_path(Vagrant.config.vagrant.home)
-
-        dirs = HOME_SUBDIRS.collect { |path| File.join(home_dir, path) }
-        dirs.unshift(home_dir)
-
-        dirs.each do |dir|
-          next if File.directory?(dir)
-
-          logger.info "Creating home directory since it doesn't exist: #{dir}"
-          FileUtils.mkdir_p(dir)
-        end
-      end
-
-      def load_box!
-        return unless root_path
-
-        @@box = Box.find(Vagrant.config.vm.box) if Vagrant.config.vm.box
-      end
-
-      def load_vm!
-        return if !root_path || !File.file?(dotfile_path)
-
-        File.open(dotfile_path) do |f|
-          @@persisted_vm = Vagrant::VM.find(f.read)
-        end
-      rescue Errno::ENOENT
-        @@persisted_vm = nil
-      end
-
-      def persist_vm(vm)
-        # Save to the dotfile for this project
-        File.open(dotfile_path, 'w+') do |f|
-          f.write(vm.uuid)
-        end
-
-        # Also add to the global store
-        ActiveList.add(vm)
-      end
-
-      def depersist_vm(vm)
-        # Delete the dotfile if it exists
-        File.delete(dotfile_path) if File.exist?(dotfile_path)
-
-        # Remove from the global store
-        ActiveList.remove(vm)
-      end
-
-      def load_root_path!(path=nil)
-        path = Pathname.new(File.expand_path(path || Dir.pwd))
-
-        # Stop if we're at the root.
-        return false if path.root?
-
-        file = "#{path}/#{ROOTFILE_NAME}"
-        if File.exist?(file)
-          @@root_path = path.to_s
-          return true
-        end
-
-        load_root_path!(path.parent)
-      end
-
-      def require_root_path
-        if !root_path
-          error_and_exit(<<-msg)
-A `#{ROOTFILE_NAME}` was not found! This file is required for vagrant to run
-since it describes the expected environment that vagrant is supposed
-to manage. Please create a #{ROOTFILE_NAME} and place it in your project
-root.
-msg
-        end
-      end
-
-      def require_box
-        require_root_path
-
-        if !box
-          if !Vagrant.config.vm.box
-            error_and_exit(<<-msg)
-No base box was specified! A base box is required as a staring point
-for every vagrant virtual machine. Please specify one in your Vagrantfile
-using `config.vm.box`
-msg
-          else
-            error_and_exit(<<-msg)
-Specified box `#{Vagrant.config.vm.box}` does not exist!
-
-The box must be added through the `vagrant box add` command. Please view
-the documentation associated with the command for more information.
-msg
-          end
-        end
-      end
-
-      def require_persisted_vm
-        require_root_path
-
-        if !persisted_vm
-          error_and_exit(<<-error)
-The task you're trying to run requires that the vagrant environment
-already be created, but unfortunately this vagrant still appears to
-have no box! You can setup the environment by setting up your
-#{ROOTFILE_NAME} and running `vagrant up`
-error
-          return
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/stacked_proc_runner.rb

@@ -1,33 +0,0 @@
-module Vagrant
-  # Represents the "stacked proc runner" behavior which is used a
-  # couple places within Vagrant. This allows procs to "stack" on
-  # each other, then all execute in a single action. An example of
-  # its uses can be seen in the {Config} class.
-  module StackedProcRunner
-    # Returns the proc stack. This should always be called as the
-    # accessor of the stack. The instance variable itself should _never_
-    # be used.
-    #
-    # @return [Array<Proc>]
-    def proc_stack
-      @_proc_stack ||= []
-    end
-
-    # Adds (pushes) a proc to the stack. The actual proc added here is
-    # not executed, but merely stored.
-    #
-    # @param [Proc] block
-    def push_proc(&block)
-      proc_stack << block
-    end
-
-    # Executes all the procs on the stack, passing in the given arguments.
-    # The stack is not cleared afterwords. It is up to the user of this
-    # mixin to clear the stack by calling `proc_stack.clear`.
-    def run_procs!(*args)
-      proc_stack.each do |proc|
-        proc.call(*args)
-      end
-    end
-  end
-end

data/test/vagrant/commands_test.rb

@@ -1,269 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class CommandsTest < Test::Unit::TestCase
-  setup do
-    Vagrant::Env.stubs(:load!)
-
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-    Vagrant::Env.stubs(:persisted_vm).returns(@persisted_vm)
-    Vagrant::Env.stubs(:require_persisted_vm)
-  end
-
-  context "init" do
-    setup do
-      FileUtils.stubs(:cp)
-      @rootfile_path = File.join(Dir.pwd, Vagrant::Env::ROOTFILE_NAME)
-      @template_path = File.join(PROJECT_ROOT, "templates", Vagrant::Env::ROOTFILE_NAME)
-    end
-
-    should "error and exit if a rootfile already exists" do
-      File.expects(:exist?).with(@rootfile_path).returns(true)
-      Vagrant::Commands.expects(:error_and_exit).once
-      Vagrant::Commands.init
-    end
-
-    should "copy the templated rootfile to the current path" do
-      File.expects(:exist?).with(@rootfile_path).returns(false)
-      FileUtils.expects(:cp).with(@template_path, @rootfile_path).once
-      Vagrant::Commands.init
-    end
-  end
-
-  context "up" do
-    setup do
-      Vagrant::Env.stubs(:persisted_vm).returns(nil)
-      Vagrant::VM.stubs(:execute!)
-      Vagrant::Env.stubs(:require_box)
-    end
-
-    should "require load the environment" do
-      Vagrant::Env.expects(:load!).once
-      Vagrant::Commands.up
-    end
-
-    should "require a box" do
-      Vagrant::Env.expects(:require_box).once
-      Vagrant::Commands.up
-    end
-
-    should "call the up action on VM if it doesn't exist" do
-      Vagrant::VM.expects(:execute!).with(Vagrant::Actions::VM::Up).once
-      Vagrant::Commands.up
-    end
-
-    should "call start on the persisted vm if it exists" do
-      Vagrant::Env.stubs(:persisted_vm).returns(@persisted_vm)
-      @persisted_vm.expects(:start).once
-      Vagrant::VM.expects(:execute!).never
-      Vagrant::Commands.up
-    end
-  end
-
-  context "down" do
-    setup do
-      @persisted_vm.stubs(:destroy)
-    end
-
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.down
-    end
-
-    should "destroy the persisted VM and the VM image" do
-      @persisted_vm.expects(:destroy).once
-      Vagrant::Commands.down
-    end
-  end
-
-  context "reload" do
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.reload
-    end
-
-    should "call the `reload` action on the VM" do
-      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
-      Vagrant::Commands.reload
-    end
-  end
-
-  context "ssh" do
-    setup do
-      Vagrant::SSH.stubs(:connect)
-    end
-
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.ssh
-    end
-
-    should "connect to SSH" do
-      Vagrant::SSH.expects(:connect).once
-      Vagrant::Commands.ssh
-    end
-  end
-
-  context "halt" do
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.halt
-    end
-
-    should "call the `halt` action on the VM" do
-      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
-      Vagrant::Commands.halt
-    end
-  end
-
-  context "suspend" do
-    setup do
-      @persisted_vm.stubs(:suspend)
-      @persisted_vm.stubs(:saved?).returns(false)
-    end
-
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.suspend
-    end
-
-    should "suspend the VM" do
-      @persisted_vm.expects(:suspend).once
-      Vagrant::Commands.suspend
-    end
-  end
-
-  context "resume" do
-    setup do
-      @persisted_vm.stubs(:resume)
-      @persisted_vm.stubs(:saved?).returns(true)
-    end
-
-    should "require a persisted VM" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.resume
-    end
-
-    should "save the state of the VM" do
-      @persisted_vm.expects(:resume).once
-      Vagrant::Commands.resume
-    end
-  end
-
-  context "package" do
-    setup do
-      @persisted_vm.stubs(:package)
-      @persisted_vm.stubs(:powered_off?).returns(true)
-    end
-
-    should "require a persisted vm" do
-      Vagrant::Env.expects(:require_persisted_vm).once
-      Vagrant::Commands.package
-    end
-
-    should "error and exit if the VM is not powered off" do
-      @persisted_vm.stubs(:powered_off?).returns(false)
-      Vagrant::Commands.expects(:error_and_exit).once
-      @persisted_vm.expects(:package).never
-      Vagrant::Commands.package
-    end
-
-    should "call package on the persisted VM" do
-      @persisted_vm.expects(:package).once
-      Vagrant::Commands.package
-    end
-
-    should "pass the out path and include_files to the package method" do
-      out_path = mock("out_path")
-      include_files = mock("include_files")
-      @persisted_vm.expects(:package).with(out_path, include_files).once
-      Vagrant::Commands.package(out_path, include_files)
-    end
-
-    should "default to an empty array when not include_files are specified" do
-      out_path = mock("out_path")
-      @persisted_vm.expects(:package).with(out_path, []).once
-      Vagrant::Commands.package(out_path)
-    end
-  end
-
-  context "box" do
-    setup do
-      Vagrant::Commands.stubs(:box_foo)
-      Vagrant::Commands.stubs(:box_add)
-      Vagrant::Commands.stubs(:box_remove)
-    end
-
-    should "load the environment" do
-      Vagrant::Env.expects(:load!).once
-      Vagrant::Commands.box(["add"])
-    end
-
-    should "error and exit if the first argument is not 'add' or 'remove'" do
-      Vagrant::Commands.expects(:error_and_exit).once
-      Vagrant::Commands.box(["foo"])
-    end
-
-    should "not error and exit if the first argument is 'add' or 'remove'" do
-      commands = ["add", "remove"]
-
-      commands.each do |command|
-        Vagrant::Commands.expects(:error_and_exit).never
-        Vagrant::Commands.expects("box_#{command}".to_sym).once
-        Vagrant::Commands.box([command])
-      end
-    end
-
-    should "forward any additional arguments" do
-      Vagrant::Commands.expects(:box_add).with(1,2,3).once
-      Vagrant::Commands.box(["add",1,2,3])
-    end
-  end
-
-  context "box list" do
-    setup do
-      @boxes = ["foo", "bar"]
-
-      Vagrant::Box.stubs(:all).returns(@boxes)
-      Vagrant::Commands.stubs(:puts)
-    end
-
-    should "call all on box and sort the results" do
-      @all = mock("all")
-      @all.expects(:sort).returns(@boxes)
-      Vagrant::Box.expects(:all).returns(@all)
-      Vagrant::Commands.box_list
-    end
-  end
-
-  context "box add" do
-    setup do
-      @name = "foo"
-      @path = "bar"
-    end
-
-    should "execute the add action with the name and path" do
-      Vagrant::Box.expects(:add).with(@name, @path).once
-      Vagrant::Commands.box_add(@name, @path)
-    end
-  end
-
-  context "box remove" do
-    setup do
-      @name = "foo"
-    end
-
-    should "error and exit if the box doesn't exist" do
-      Vagrant::Box.expects(:find).returns(nil)
-      Vagrant::Commands.expects(:error_and_exit).once
-      Vagrant::Commands.box_remove(@name)
-    end
-
-    should "call destroy on the box if it exists" do
-      @box = mock("box")
-      Vagrant::Box.expects(:find).with(@name).returns(@box)
-      @box.expects(:destroy).once
-      Vagrant::Commands.box_remove(@name)
-    end
-  end
-end