bmabey-vagrant 0.2.0

data/lib/vagrant/util/errors.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module Vagrant
+  module Util
+    # This class is responsible for outputting errors. It retrieves the errors,
+    # based on their key, from the error file, and then outputs it.
+    class Errors
+      @@errors = nil
+
+      class <<self
+        # Resets the internal errors hash to nil, forcing a reload on the next
+        # access of {errors}.
+        def reset!
+          @@errors = nil
+        end
+
+        # Returns the hash of errors from the error YML files. This only loads once,
+        # then returns a cached value until {reset!} is called.
+        #
+        # @return [Hash]
+        def errors
+          @@errors ||= YAML.load_file(File.join(PROJECT_ROOT, "templates", "errors.yml"))
+        end
+
+        # Renders the error with the given key and data parameters and returns
+        # the rendered result.
+        #
+        # @return [String]
+        def error_string(key, data = {})
+          template = errors[key] || "Unknown error key: #{key}"
+          TemplateRenderer.render_string(template, data)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/stacked_proc_runner.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # 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
+end

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+require 'erb'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class <<self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      def initialize(template, data = {})
+        super()
+
+        data[:template] = template
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Renders the template using the class intance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        ERB.new(template).result(binding)
+      end
+
+      # Returns the full path to the template, taking into accoun the gem directory
+      # and adding the `.erb` extension to the end.
+      #
+      # @return [String]
+      def full_template_path
+        File.join(PROJECT_ROOT, 'templates', "#{template}.erb")
+      end
+    end
+  end
+end

data/lib/vagrant/vm.rb

@@ -0,0 +1,61 @@
+module Vagrant
+  class VM < Actions::Runner
+    include Vagrant::Util
+
+    attr_accessor :env
+    attr_accessor :vm
+    attr_accessor :from
+
+    class << self
+      # Finds a virtual machine by a given UUID and either returns
+      # a Vagrant::VM object or returns nil.
+      def find(uuid)
+        vm = VirtualBox::VM.find(uuid)
+        return nil if vm.nil?
+        new(vm)
+      end
+    end
+
+    def initialize(vm=nil)
+      @vm = vm
+    end
+
+    def uuid
+      vm ? vm.uuid : nil
+    end
+
+    def reload!
+      @vm = VirtualBox::VM.find(@vm.uuid)
+    end
+
+    def package(out_path, include_files=[])
+      add_action(Actions::VM::Export)
+      add_action(Actions::VM::Package, out_path, include_files)
+      execute!
+    end
+
+    def start
+      return if @vm.running?
+
+      execute!(Actions::VM::Start)
+    end
+
+    def destroy
+      execute!(Actions::VM::Down)
+    end
+
+    def suspend
+      execute!(Actions::VM::Suspend)
+    end
+
+    def resume
+      execute!(Actions::VM::Resume)
+    end
+
+    def saved?
+      @vm.saved?
+    end
+
+    def powered_off?; @vm.powered_off? end
+  end
+end

data/templates/Vagrantfile.erb

@@ -0,0 +1,8 @@
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. For a detailed explanation
+  # and listing of configuration options, please view the documentation
+  # online.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "<%= default_box %>"
+end

data/templates/errors.yml

@@ -0,0 +1,117 @@
+:box_already_exists: "This box appears to already exist! Please call `vagrant box remove <%= box_name %>`
+    \nand then try to add it again."
+:box_add_already_exists: "A box with the name '<%= box_name %>' already exists, please use another name or use `vagrant box remove <%= box_name %>`"
+:box_download_unknown_type: "Unknown URI type for box download."
+:box_remove_doesnt_exist: "The box you're attempting to remove does not exist!"
+:box_specified_doesnt_exist: "Specified box `<%= box_name %>` does not exist!
+
+    \nThe box must be added through the `vagrant box add` command. Please view
+    \nthe documentation associated with the command for more information."
+:box_not_specified: "No base box was specified! A base box is required as a staring point
+    \nfor every vagrant virtual machine. Please specify one in your Vagrantfile
+    \nusing `config.vm.box`"
+:chef_base_invalid_provisioner: "Vagrant::Provisioners::Chef is not a valid provisioner! Use ChefSolo or ChefServer instead."
+:chef_server_url_required: "Chef server provisioning requires that the `config.chef.chef_server_url` be set to the
+    \nURL of your chef server. Examples include \"http://12.12.12.12:4000\" and
+    \n\"http://myserver.com:4000\" (the port of course can be different, but 4000 is the default)"
+:chef_server_validation_key_required: "Chef server provisioning requires that the `config.chef.validation_key_path` configuration
+    \nbe set to a path on your local machine of the validation key used to register the
+    \nVM with the chef server."
+:chef_server_validation_key_doesnt_exist: "The validation key set for `config.chef.validation_key_path` does not exist! This
+    \nfile needs to exist so it can be uploaded to the virtual machine. It is
+    \ncurrently set to \"<%= Vagrant.config.chef.validation_key_path %>\""
+:command_box_invalid: "Please specify a valid action to take on the boxes, either
+    \n`add` or `remove`. Examples:
+
+    \nvagrant box add name uri
+    \nvagrant box remove name
+    \nvagrant box list"
+:dotfile_error: "The dotfile which Vagrant uses to store the UUID of the project's
+    \nvirtual machine already exists and is not a file! The dotfile is
+    \ncurrently configured to be `<%= env.dotfile_path %>`
+
+    \nTo change this value, please see `config.vagrant.dotfile_name`
+
+    \nThis often exists if you're trying to create a Vagrant virtual
+    \nenvironment from your home directory. To resolve this, you can either
+    \nmodify the configuration a bit, or simply use a different directory."
+:downloader_file_doesnt_exist: "The given box does not exist on the file system:\n
+
+    \n<%= source_url %>"
+:environment_not_created: "The task you're trying to run requires that the vagrant environment
+    \nalready be created, but unfortunately this vagrant still appears to
+    \nhave no box! You can setup the environment by setting up your
+    \n<%= Vagrant::Environment::ROOTFILE_NAME %> and running `vagrant up`"
+:package_include_file_doesnt_exist: "File specified to include: '<%= filename %>' does not exist!"
+:package_requires_export: "Package must be used in conjunction with export."
+:provisioner_invalid_class: "Provisioners must be an instance of Vagrant::Provisioners::Base"
+:provisioner_unknown_type: "Unknown provisioner type: <%= provisioner %>"
+:rootfile_already_exists: "It looks like this directory is already setup for vagrant! (A <%= Vagrant::Environment::ROOTFILE_NAME %>
+    \nalready exists.)"
+:rootfile_not_found: "A `<%= Vagrant::Environment::ROOTFILE_NAME %>` was not found! This file is required for vagrant to run
+    \nsince it describes the expected environment that vagrant is supposed
+    \nto manage. Please create a `<%= Vagrant::Environment::ROOTFILE_NAME %>` and place it in your project
+    \nroot."
+:ssh_bad_permissions: "The private key to connect to this box via SSH has invalid permissions
+    \nset on it. The permissions of the private key should be set to 0600, otherwise SSH will
+    \nignore the key. Vagrant tried to do this automatically for you but failed. Please set the
+    \npermissions on the following file to 0600 and then try running this command again:
+
+    \n<%= key_path %>"
+:virtualbox_import_failure: "The VM import failed! Try running `VBoxManage import` on the box file manually for more verbose error output."
+:virtualbox_invalid_version: "Vagrant has detected that you have VirtualBox version <%= version %> installed!
+    \nVagrant requires that you use at least VirtualBox version 3.1. Please install
+    \na more recent version of VirtualBox to continue."
+:virtualbox_not_detected: "Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.
+    \nIf VirtualBox is installed, you may need to tweak the paths to the `VBoxManage`
+    \napplication which ships with VirtualBox and the path to the global XML configuration
+    \nwhich VirtualBox typically stores somewhere in your home directory.
+
+    \nThe following shows how to configure VirtualBox. This can be done in the
+    \nVagrantfile. Note that 90% of the time, you shouldn't need to do this if VirtualBox
+    \nis installed. Please use the various Vagrant support lines to request more information
+    \nif you can't get this working.
+
+    \nVirtualBox::Command.vboxmanage = \"/path/to/my/VBoxManage\"
+    \nVirtualBox::Global.vboxconfig = \"~/path/to/VirtualBox.xml\""
+:virtualbox_xml_not_detected: "Vagrant couldn't find your global VirtualBox.xml file!
+
+    \nIf you just recently installed VirtualBox, make sure you've launched
+    \nit at least once, since the initial launch will typically create this
+    \nfile.
+
+    \nOtherwise, you may need to set the path to the VirtualBox.xml file
+    \nmanually. Note that 90% of people should never have to do this, so
+    \ndon't be afraid to use the various Vagrant support lines to ask for
+    \nhelp. To set the path manually:
+
+    \nVirtualBox::Global.vboxconfig = \"/path/to/VirtualBox.xml\""
+:vm_failed_to_boot: "Failed to connect to VM! Failed to boot?"
+:vm_not_running: "VM is not running! Nothing to shut down!"
+:vm_not_running_for_suspend: "The vagrant virtual environment you are trying to suspend must be running to be suspended."
+:vm_not_suspended: "The vagrant virtual environment you are trying to resume is not in a suspended state."
+:vm_port_collision: "Vagrant cannot forward the specified ports on this VM, since they
+    \nwould collide with another VirtualBox virtual machine's forwarded
+    \nports! The \"<%= name %>\" forwarded port (<%= hostport %>) is already in use on the host
+    \nmachine.
+
+    \nTo fix this, modify your current projects Vagrantfile to use another
+    \nport. Example, where '1234' would be replaced by a unique host port:
+
+    \nconfig.vm.forward_port(\"<%= name %>\", <%= guestport %>, 1234)"
+:vm_power_off_to_move_hd: "The virtual machine must be powered off to move its disk."
+:vm_power_off_to_package: "The vagrant virtual environment you are trying to package must be powered off."
+:vm_mount_fail: "Failed to mount shared folders. vboxsf was not available."
+:vm_ssh_auth_failed: "SSH authentication failed! While this could be due to a variety of reasons,
+    \nthe two most common are: private key path is incorrect or you're using a box
+    \nwhich was built for Vagrant 0.1.x.
+
+    \nVagrant 0.2.x dropped support for password-based authentication. If you're
+    \ntring to `vagrant up` a box which does not support Vagrant's private/public
+    \nkeypair, then this error will be raised. To resolve this, read the guide
+    \non converting base boxes from password-based to keypairs here:
+
+    \nhttp://vagrantup.com/docs/converting_password_to_key_ssh.html
+
+    \nIf the box was built for 0.2.x and contains a custom public key, perhaps
+    \nthe path to the private key is incorrect. Check your `config.ssh.private_key_path`."

data/test/test_helper.rb

@@ -0,0 +1,163 @@
+begin
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  # Fallback on doing the resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+# ruby-debug, not necessary, but useful if we have it
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'vagrant')
+require 'contest'
+require 'mocha'
+
+class Test::Unit::TestCase
+  # Mocks an environment, setting it up with the given config.
+  def mock_environment
+    environment = Vagrant::Environment.new
+
+    Vagrant::Config.reset!(environment)
+
+    Vagrant::Config.run do |config|
+      config.vagrant.dotfile_name = ".vagrant"
+
+      config.ssh.username = "foo"
+      config.ssh.password = "bar"
+      config.ssh.host = "baz"
+      config.ssh.forwarded_port_key = "ssh"
+      config.ssh.max_tries = 10
+      config.ssh.timeout = 10
+      config.ssh.private_key_path = '~/foo'
+
+      config.vm.box = "foo"
+      config.vm.box_ovf = "box.ovf"
+      config.vm.base_mac = "42"
+      config.vm.project_directory = "/vagrant"
+      config.vm.disk_image_format = 'VMDK'
+      config.vm.forward_port("ssh", 22, 2222)
+      config.vm.shared_folder_uid = nil
+      config.vm.shared_folder_gid = nil
+
+      config.package.name = 'vagrant'
+      config.package.extension = '.box'
+
+      # Chef
+      config.chef.chef_server_url = "http://localhost:4000"
+      config.chef.validation_key_path = "validation.pem"
+      config.chef.client_key_path = "/zoo/foo/bar.pem"
+      config.chef.cookbooks_path = "cookbooks"
+      config.chef.provisioning_path = "/tmp/vagrant-chef"
+      config.chef.json = {
+        :recipes => ["vagrant_main"]
+      }
+
+      config.vagrant.home = '~/.home'
+    end
+
+    if block_given?
+      Vagrant::Config.run do |config|
+        yield config
+      end
+    end
+
+    config = Vagrant::Config.execute!
+
+    environment.instance_variable_set(:@config, config)
+    environment
+  end
+
+  # Clears the previous config and sets up the new config
+  def mock_config
+    Vagrant::Config.reset!
+
+    Vagrant::Config.run do |config|
+      config.vagrant.dotfile_name = ".vagrant"
+
+      config.ssh.username = "foo"
+      config.ssh.password = "bar"
+      config.ssh.host = "baz"
+      config.ssh.forwarded_port_key = "ssh"
+      config.ssh.max_tries = 10
+      config.ssh.timeout = 10
+      config.ssh.private_key_path = '~/foo'
+
+      config.vm.box = "foo"
+      config.vm.box_ovf = "box.ovf"
+      config.vm.base_mac = "42"
+      config.vm.project_directory = "/vagrant"
+      config.vm.disk_image_format = 'VMDK'
+      config.vm.forward_port("ssh", 22, 2222)
+      config.vm.shared_folder_uid = nil
+      config.vm.shared_folder_gid = nil
+
+      config.package.name = 'vagrant'
+      config.package.extension = '.box'
+
+      # Chef
+      config.chef.chef_server_url = "http://localhost:4000"
+      config.chef.validation_key_path = "validation.pem"
+      config.chef.client_key_path = "/zoo/foo/bar.pem"
+      config.chef.cookbooks_path = "cookbooks"
+      config.chef.provisioning_path = "/tmp/vagrant-chef"
+      config.chef.json = {
+        :recipes => ["vagrant_main"]
+      }
+
+      config.vagrant.home = '~/.home'
+    end
+
+    if block_given?
+      Vagrant::Config.run do |config|
+        yield config
+      end
+    end
+
+    if block_given?
+      Vagrant::Config.run do |config|
+        yield config
+      end
+    end
+
+    Vagrant::Config.execute!
+  end
+
+  # Sets up the mocks and instantiates an action for testing
+  def mock_action(action_klass, *args)
+    vm = mock("vboxvm")
+    mock_vm = mock("vm")
+    action = action_klass.new(mock_vm, *args)
+    stub_default_action_dependecies(action)
+
+    mock_vm.stubs(:vm).returns(vm)
+    mock_vm.stubs(:vm=)
+    mock_vm.stubs(:invoke_callback)
+    mock_vm.stubs(:invoke_around_callback).yields
+    mock_vm.stubs(:actions).returns([action])
+    mock_vm.stubs(:env).returns(mock_environment)
+
+    [mock_vm, vm, action]
+  end
+
+  def stub_default_action_dependecies(mock, klass=MockAction)
+    mock.stubs(:precedes).returns([])
+    mock.stubs(:follows).returns([])
+  end
+
+  # Sets up the mocks and stubs for a downloader
+  def mock_downloader(downloader_klass)
+    tempfile = mock("tempfile")
+    tempfile.stubs(:write)
+
+    [downloader_klass.new, tempfile]
+  end
+end
+
+class MockAction; end
+class MockActionOther; end
+