vagrant 0.5.4 → 0.6.0

data/lib/vagrant/errors.rb

@@ -0,0 +1,306 @@
+# This file contains all of the internal errors in Vagrant's core
+# commands, actions, etc.
+
+module Vagrant
+  # This module contains all of the internal errors in Vagrant's core.
+  # These errors are _expected_ errors and as such don't typically represent
+  # bugs in Vagrant itself. These are meant as a way to detect errors and
+  # display them in a user-friendly way.
+  #
+  # # Defining a new Error
+  #
+  # To define a new error, inherit from {VagrantError}, which lets Vagrant
+  # know that this is an expected error, and also gives you some helpers for
+  # providing exit codes and error messages. An example is shown below, then
+  # it is explained:
+  #
+  #     class MyError < Vagrant::Errors::VagrantError
+  #       error_key "my_error"
+  #     end
+  #
+  # This creates an error with an I18n error key of "my_error." {VagrantError}
+  # uses I18n to look up error messages, in the "vagrant.errors" namespace. So
+  # in the above, the error message would be the translation of "vagrant.errors.my_error"
+  #
+  # If you don't want to use I18n, you can override the {#initialize} method and
+  # set your own error message.
+  #
+  # # Raising an Error
+  #
+  # To raise an error, it is nothing special, just raise it like any normal
+  # exception:
+  #
+  #     raise MyError.new
+  #
+  # Eventually this exception will bubble out to the `vagrant` binary which
+  # will show a nice error message. And if it is raised in the middle of a
+  # middleware sequence, then {Action::Warden} will catch it and begin the
+  # recovery process prior to exiting.
+  module Errors
+    # Main superclass of any errors in Vagrant. This provides some
+    # convenience methods for setting the status code and error key.
+    # The status code is used by the `vagrant` executable as the
+    # error code, and the error key is used as a default message from
+    # I18n.
+    class VagrantError < StandardError
+      @@used_codes = []
+
+      def self.status_code(code = nil)
+        if code
+          raise "Status code already in use: #{code}"  if @@used_codes.include?(code)
+          @@used_codes << code
+        end
+
+        define_method(:status_code) { code }
+      end
+
+      def self.error_key(key=nil, namespace=nil)
+        define_method(:error_key) { key }
+        error_namespace(namespace) if namespace
+      end
+
+      def self.error_namespace(namespace)
+        define_method(:error_namespace) { namespace }
+      end
+
+      def initialize(message=nil, *args)
+        message = { :_key => message } if message && !message.is_a?(Hash)
+        message = { :_key => error_key, :_namespace => error_namespace }.merge(message || {})
+        message = translate_error(message)
+
+        super
+      end
+
+      # The default error namespace which is used for the error key.
+      # This can be overridden here or by calling the "error_namespace"
+      # class method.
+      def error_namespace; "vagrant.errors"; end
+
+      # The key for the error message. This should be set using the
+      # {error_key} method but can be overridden here if needed.
+      def error_key; nil; end
+
+      protected
+
+      def translate_error(opts)
+        return nil if !opts[:_key]
+        I18n.t("#{opts[:_namespace]}.#{opts[:_key]}", opts)
+      end
+    end
+
+    class BaseVMNotFound < VagrantError
+      status_code(18)
+      error_key(:base_vm_not_found)
+    end
+
+    class BoxAlreadyExists < VagrantError
+      status_code(14)
+      error_key(:already_exists, "vagrant.actions.box.unpackage")
+    end
+
+    class BoxDownloadUnknownType < VagrantError
+      status_code(13)
+      error_key(:unknown_type, "vagrant.actions.box.download")
+    end
+
+    class BoxNotFound < VagrantError
+      status_code(2)
+      error_key(:box_not_found)
+    end
+
+    class BoxNotSpecified < VagrantError
+      status_code(22)
+      error_key(:not_specified, "vagrant.actions.vm.check_box")
+    end
+
+    class BoxSpecifiedDoesntExist < VagrantError
+      status_code(23)
+      error_key(:does_not_exist, "vagrant.actions.vm.check_box")
+    end
+
+    class BoxVerificationFailed < VagrantError
+      status_code(15)
+      error_key(:failed, "vagrant.actions.box.verify")
+    end
+
+    class CLIMissingEnvironment < VagrantError
+      status_code(1)
+      error_key(:cli_missing_env)
+    end
+
+    class ConfigValidationFailed < VagrantError
+      status_code(42)
+      error_key(:config_validation)
+    end
+
+    class DownloaderFileDoesntExist < VagrantError
+      status_code(37)
+      error_key(:file_missing, "vagrant.downloaders.file")
+    end
+
+    class DownloaderHTTPSocketError < VagrantError
+      status_code(38)
+      error_key(:socket_error, "vagrant.downloaders.http")
+    end
+
+    class ForwardPortAutolistEmpty < VagrantError
+      status_code(27)
+      error_key(:auto_empty, "vagrant.actions.vm.forward_ports")
+    end
+
+    class ForwardPortBelowThreshold < VagrantError
+      status_code(25)
+      error_key(:below_threshold_error, "vagrant.actions.vm.forward_ports")
+    end
+
+    class ForwardPortCollision < VagrantError
+      status_code(26)
+      error_key(:collision_error, "vagrant.actions.vm.forward_ports")
+    end
+
+    class MultiVMEnvironmentRequired < VagrantError
+      status_code(5)
+      error_key(:multi_vm_required)
+    end
+
+    class MultiVMTargetRequired < VagrantError
+      status_code(7)
+      error_key(:multi_vm_target_required)
+    end
+
+    class NetworkCollision < VagrantError
+      status_code(29)
+      error_key(:collides, "vagrant.actions.vm.network")
+    end
+
+    class NetworkNotFound < VagrantError
+      status_code(30)
+      error_key(:not_found, "vagrant.actions.vm.network")
+    end
+
+    class NFSHostRequired < VagrantError
+      status_code(31)
+      error_key(:host_required, "vagrant.actions.vm.nfs")
+    end
+
+    class NFSNotSupported < VagrantError
+      status_code(32)
+      error_key(:not_supported, "vagrant.actions.vm.nfs")
+    end
+
+    class NFSNoHostNetwork < VagrantError
+      status_code(33)
+      error_key(:no_host_network, "vagrant.actions.vm.nfs")
+    end
+
+    class NoEnvironmentError < VagrantError
+      status_code(3)
+      error_key(:no_env)
+    end
+
+    class PackageIncludeMissing < VagrantError
+      status_code(20)
+      error_key(:include_file_missing, "vagrant.actions.general.package")
+    end
+
+    class PackageOutputExists < VagrantError
+      status_code(16)
+      error_key(:output_exists, "vagrant.actions.general.package")
+    end
+
+    class PackageRequiresDirectory < VagrantError
+      status_code(19)
+      error_key(:requires_directory, "vagrant.actions.general.package")
+    end
+
+    class PersistDotfileExists < VagrantError
+      status_code(34)
+      error_key(:dotfile_error, "vagrant.actions.vm.persist")
+    end
+
+    class ProvisionInvalidClass < VagrantError
+      status_code(35)
+      error_key(:invalid_class, "vagrant.actions.vm.provision")
+    end
+
+    class ProvisionUnknownType < VagrantError
+      status_code(36)
+      error_key(:unknown_type, "vagrant.actions.vm.provision")
+    end
+
+    class SSHAuthenticationFailed < VagrantError
+      status_code(11)
+      error_key(:ssh_authentication_failed)
+    end
+
+    class SSHConnectionRefused < VagrantError
+      status_code(43)
+      error_key(:ssh_connection_refused)
+    end
+
+    class SSHKeyBadPermissions < VagrantError
+      status_code(12)
+      error_key(:ssh_key_bad_permissions)
+    end
+
+    class SSHUnavailableWindows < VagrantError
+      status_code(10)
+      error_key(:ssh_unavailable_windows)
+    end
+
+    class VagrantInterrupt < VagrantError
+      status_code(40)
+      error_key(:interrupted)
+    end
+
+    class VagrantfileSyntaxError < VagrantError
+      status_code(41)
+      error_key(:vagrantfile_syntax_error)
+    end
+
+    class VirtualBoxInvalidOSE < VagrantError
+      status_code(9)
+      error_key(:virtualbox_invalid_ose)
+    end
+
+    class VirtualBoxInvalidVersion < VagrantError
+      status_code(17)
+      error_key(:virtualbox_invalid_version)
+    end
+
+    class VirtualBoxNotDetected < VagrantError
+      status_code(8)
+      error_key(:virtualbox_not_detected)
+    end
+
+    class VMFailedToBoot < VagrantError
+      status_code(21)
+      error_key(:failed_to_boot, "vagrant.actions.vm.boot")
+    end
+
+    class VMImportFailure < VagrantError
+      status_code(28)
+      error_key(:failure, "vagrant.actions.vm.import")
+    end
+
+    class VMNotCreatedError < VagrantError
+      status_code(6)
+      error_key(:vm_creation_required)
+    end
+
+    class VMNotFoundError < VagrantError
+      status_code(4)
+      error_key(:vm_not_found)
+    end
+
+    class VMPowerOffToPackage < VagrantError
+      status_code(24)
+      error_key(:power_off, "vagrant.actions.vm.export")
+    end
+
+    class VMSystemError < VagrantError
+      status_code(39)
+      error_namespace("vagrant.errors.system")
+    end
+  end
+end

data/lib/vagrant/hosts/base.rb

@@ -45,7 +45,7 @@ module Vagrant
       end
 
       # Initialzes a new host. This method shouldn't be called directly,
-      # typically, since it will be called by {Environment#load_host!}
+      # typically, since it will be called by {Environment#load!}.
       #
       # @param [Environment] env
       def initialize(env)

data/lib/vagrant/hosts/bsd.rb

@@ -3,17 +3,11 @@ module Vagrant
     # Represents a BSD host, such as FreeBSD and Darwin (Mac OS X).
     class BSD < Base
       include Util
+      include Util::Retryable
 
       def nfs?
-        tries = 10
-        begin
+        retryable(:tries => 10, :on => TypeError) do
           system("which nfsd > /dev/null 2>&1")
-        rescue TypeError
-          tries -= 1
-          retry if tries > 0
-
-          # Hopefully this point isn't reached
-          raise
         end
       end
 
@@ -25,7 +19,7 @@ module Vagrant
 
         # The sleep ensures that the output is truly flushed before any `sudo`
         # commands are issued.
-        env.logger.info "Preparing to edit /etc/exports. Administrator priveleges will be required..."
+        env.ui.info I18n.t("vagrant.hosts.bsd.nfs_export.prepare")
         sleep 0.5
 
         output.split("\n").each do |line|

data/lib/vagrant/hosts/linux.rb

@@ -3,18 +3,12 @@ module Vagrant
     # Represents a Linux based host, such as Ubuntu.
     class Linux < Base
       include Util
+      include Util::Retryable
 
       def nfs?
-        tries = 10
-        begin
+        retryable(:tries => 10, :on => TypeError) do
           # Check procfs to see if NFSd is a supported filesystem
           system("cat /proc/filesystems | grep nfsd > /dev/null 2>&1")
-        rescue TypeError
-          tries -= 1
-          retry if tries > 0
-
-          # Hopefully this point isn't reached
-          raise
         end
       end
 
@@ -24,7 +18,7 @@ module Vagrant
                                          :ip => ip,
                                          :folders => folders)
 
-        env.logger.info "Preparing to edit /etc/exports. Administrator priveleges will be required..."
+        env.ui.info I18n.t("vagrant.hosts.linux.nfs_export.prepare")
         sleep 0.5
 
         output.split("\n").each do |line|

data/lib/vagrant/plugin.rb

@@ -0,0 +1,50 @@
+require "rubygems"
+
+module Vagrant
+  # Represents a single plugin and also manages loading plugins from
+  # RubyGems. If a plugin has a `vagrant_init.rb` file somewhere on its
+  # load path, then this class will find it and load it. For logging purposes
+  # (for debugging), the list of loaded plugins is stored in the {plugins}
+  # array.
+  class Plugin
+    # The array of loaded plugins.
+    @@plugins = []
+
+    # The gemspec of this plugin. This is an actual gemspec object.
+    attr_reader :gemspec
+
+    # The path to the `vagrant_init.rb` file which was loaded for this plugin.
+    attr_reader :file
+
+    # Loads all the plugins for Vagrant. Plugins are currently
+    # gems which have a "vagrant_init.rb" somewhere on their
+    # load path. This file is loaded to kick off the load sequence
+    # for that plugin.
+    def self.load!
+      # Look for a vagrant_init.rb in all the gems, but only the
+      # latest version of the gems.
+      Gem.source_index.latest_specs.each do |spec|
+        file = Gem.searcher.matching_files(spec, "vagrant_init.rb").first
+        next if !file
+
+        @@plugins << new(spec, file)
+      end
+    end
+
+    # Returns the array of plugins which are currently loaded by
+    # Vagrant.
+    #
+    # @return [Array]
+    def self.plugins; @@plugins; end
+
+    # Initializes a new plugin, given a Gemspec and the path to the
+    # gem's `vagrant_init.rb` file. This should never be called manually.
+    # Instead {load!} creates all the instances.
+    def initialize(spec, file)
+      @gemspec = spec
+      @file = file
+
+      load file
+    end
+  end
+end

data/lib/vagrant/provisioners/base.rb

@@ -30,12 +30,6 @@ module Vagrant
         env.vm
       end
 
-      # This method returns the environment's logger as a convenience
-      # method.
-      def logger
-        env.logger
-      end
-
       # This is the method called to "prepare" the provisioner. This is called
       # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
       # This can be used to setup shared folders, forward ports, etc. Whatever is

data/lib/vagrant/provisioners/chef.rb

@@ -3,9 +3,67 @@ module Vagrant
     # This class is a base class where the common functinality shared between
     # chef-solo and chef-client provisioning are stored. This is **not an actual
     # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      def prepare
+        raise ChefError.new(:invalid_provisioner)
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          # Checks for the existence of chef binary and error if it
+          # doesn't exist.
+          ssh.exec!("which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
+        end
+      end
+
+      def chown_provisioning_folder
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo mkdir -p #{env.config.chef.provisioning_path}")
+          ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.chef.provisioning_path}")
+        end
+      end
+
+      def setup_config(template, filename, template_vars)
+        config_file = TemplateRenderer.render(template, {
+          :log_level => env.config.chef.log_level.to_sym
+        }.merge(template_vars))
+
+        vm.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
+      end
+
+      def setup_json
+        env.ui.info I18n.t("vagrant.provisioners.chef.json")
+
+        # Set up initial configuration
+        data = {
+          :config => env.config.to_hash,
+          :directory => env.config.vm.shared_folders["v-root"][:guestpath],
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(env.config.chef.json)
+
+        json = data.to_json
+
+        vm.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
+      end
+    end
+
+    class Chef < Base
+      class ChefError < Errors::VagrantError
+        error_namespace("vagrant.provisioners.chef")
+      end
+    end
+
     class Chef < Base
       # This is the configuration which is available through `config.chef`
       class ChefConfig < Vagrant::Config::Base
+        configures :chef
+
         # Chef server specific config
         attr_accessor :chef_server_url
         attr_accessor :validation_key_path
@@ -34,7 +92,7 @@ module Vagrant
           @log_level = :info
           @json = {
             :instance_role => "vagrant",
-            :run_list => ["recipe[vagrant_main]"]
+            :run_list => []
           }
         end
 
@@ -60,67 +118,14 @@ module Vagrant
           run_list << name
         end
 
-        def to_json(*a)
+        def instance_variables_hash
           # Overridden so that the 'json' key could be removed, since its just
           # merged into the config anyways
-          data = instance_variables_hash
-          data.delete(:json)
-          data.to_json(*a)
-        end
-      end
-
-      # Tell the Vagrant configure class about our custom configuration
-      Config.configures :chef, ChefConfig
-
-      def prepare
-        action_env.error!(:chef_base_invalid_provisioner)
-      end
-
-      def verify_binary(binary)
-        vm.ssh.execute do |ssh|
-          # Checks for the existence of chef binary and error if it
-          # doesn't exist.
-          ssh.exec!("which #{binary}", :error_key => :chef_not_detected, :error_data => {:binary => binary})
-        end
-      end
-
-      def chown_provisioning_folder
-        logger.info "Setting permissions on chef provisioning folder..."
-        vm.ssh.execute do |ssh|
-          ssh.exec!("sudo mkdir -p #{env.config.chef.provisioning_path}")
-          ssh.exec!("sudo chown #{env.config.ssh.username} #{env.config.chef.provisioning_path}")
+          result = super
+          result.delete("json")
+          result
         end
       end
-
-      def setup_config(template, filename, template_vars)
-        config_file = TemplateRenderer.render(template, {
-          :log_level => env.config.chef.log_level.to_sym
-        }.merge(template_vars))
-
-        logger.info "Uploading chef configuration script..."
-        vm.ssh.upload!(StringIO.new(config_file), File.join(env.config.chef.provisioning_path, filename))
-      end
-
-      def setup_json
-        logger.info "Generating chef JSON and uploading..."
-
-        # Set up initial configuration
-        data = {
-          :config => env.config,
-          :directory => env.config.vm.shared_folders["v-root"][:guestpath],
-        }
-
-        # And wrap it under the "vagrant" namespace
-        data = { :vagrant => data }
-
-        # Merge with the "extra data" which isn't put under the
-        # vagrant namespace by default
-        data.merge!(env.config.chef.json)
-
-        json = data.to_json
-
-        vm.ssh.upload!(StringIO.new(json), File.join(env.config.chef.provisioning_path, "dna.json"))
-      end
     end
   end
 end