vagrant 0.5.4 → 0.6.0

data/lib/vagrant/provisioners/chef_server.rb

@@ -1,16 +1,14 @@
+require 'pathname'
+
 module Vagrant
   module Provisioners
     # This class implements provisioning via chef-client, allowing provisioning
     # with a chef server.
     class ChefServer < Chef
       def prepare
-        if env.config.chef.validation_key_path.nil?
-          action_env.error!(:chef_server_validation_key_required)
-        elsif !File.file?(validation_key_path)
-          action_env.error!(:chef_server_validation_key_doesnt_exist)
-        elsif env.config.chef.chef_server_url.nil?
-          action_env.error!(:chef_server_url_required)
-        end
+        raise ChefError.new(:server_validation_key_required) if env.config.chef.validation_key_path.nil?
+        raise ChefError.new(:server_validation_key_doesnt_exist) if !File.file?(validation_key_path)
+        raise ChefError.new(:server_url_required) if env.config.chef.chef_server_url.nil?
       end
 
       def provision!
@@ -24,7 +22,7 @@ module Vagrant
       end
 
       def create_client_key_folder
-        logger.info "Creating folder to hold client key..."
+        env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
         path = Pathname.new(env.config.chef.client_key_path)
 
         vm.ssh.execute do |ssh|
@@ -33,7 +31,7 @@ module Vagrant
       end
 
       def upload_validation_key
-        logger.info "Uploading chef client validation key..."
+        env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
         vm.ssh.upload!(validation_key_path, guest_validation_key_path)
       end
 
@@ -50,13 +48,13 @@ module Vagrant
       def run_chef_client
         command = "cd #{env.config.chef.provisioning_path} && sudo -E chef-client -c client.rb -j dna.json"
 
-        logger.info "Running chef-client..."
+        env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
         vm.ssh.execute do |ssh|
           ssh.exec!(command) do |channel, type, data|
             if type == :exit_status
               ssh.check_exit_status(data, command)
             else
-              logger.info("#{data}: #{type}")
+              env.ui.info("#{data}: #{type}")
             end
           end
         end

data/lib/vagrant/provisioners/chef_solo.rb

@@ -40,11 +40,11 @@ module Vagrant
       def run_chef_solo
         command = "cd #{env.config.chef.provisioning_path} && sudo -E chef-solo -c solo.rb -j dna.json"
 
-        logger.info "Running chef-solo..."
+        env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
         vm.ssh.execute do |ssh|
           ssh.exec!(command) do |channel, type, data|
             ssh.check_exit_status(data, command) if type == :exit_status
-            logger.info("#{data}: #{type}") if type != :exit_status
+            env.ui.info("#{data}: #{type}") if type != :exit_status
           end
         end
       end

data/lib/vagrant/ssh.rb

@@ -1,9 +1,13 @@
+require 'net/ssh'
+require 'net/scp'
+require 'mario'
+
 module Vagrant
   # Manages SSH access to a specific environment. Allows an environment to
   # replace the process with SSH itself, run a specific set of commands,
   # upload files, or even check if a host is up.
   class SSH
-    include Vagrant::Util
+    include Util::Retryable
 
     # Reference back up to the environment which this SSH object belongs
     # to
@@ -18,9 +22,8 @@ module Vagrant
     # of options which override the configuration values.
     def connect(opts={})
       if Mario::Platform.windows?
-        error_and_exit(:ssh_unavailable_windows,
-                       :key_path => env.config.ssh.private_key_path,
-                       :ssh_port => port(opts))
+        raise Errors::SSHUnavailableWindows.new(:key_path => env.config.ssh.private_key_path,
+                                                :ssh_port => port(opts))
       end
 
       options = {}
@@ -56,31 +59,30 @@ module Vagrant
       opts = opts.dup
       opts[:forward_agent] = true if env.config.ssh.forward_agent
 
-      Net::SSH.start(env.config.ssh.host,
-                     env.config[:ssh][:username],
-                     opts.merge( :port => port,
-                                 :keys => [env.config.ssh.private_key_path],
-                                 :user_known_hosts_file => [],
-                                 :paranoid => false,
-                                 :config => false)) do |ssh|
-        yield SSH::Session.new(ssh)
+      retryable(:tries => 5, :on => Errno::ECONNREFUSED) do
+        Net::SSH.start(env.config.ssh.host,
+                       env.config.ssh.username,
+                       opts.merge( :port => port,
+                                   :keys => [env.config.ssh.private_key_path],
+                                   :user_known_hosts_file => [],
+                                   :paranoid => false,
+                                   :config => false)) do |ssh|
+          yield SSH::Session.new(ssh)
+        end
       end
+    rescue Errno::ECONNREFUSED
+      raise Errors::SSHConnectionRefused.new
     end
 
     # Uploads a file from `from` to `to`. `from` is expected to be a filename
     # or StringIO, and `to` is expected to be a path. This method simply forwards
     # the arguments to `Net::SCP#upload!` so view that for more information.
     def upload!(from, to)
-      tries = 5
-
-      begin
+      retryable(:tries => 5, :on => IOError) do
         execute do |ssh|
           scp = Net::SCP.new(ssh.session)
           scp.upload!(from, to)
         end
-      rescue IOError
-        retry if (tries -= 1) > 0
-        raise
       end
     end
 
@@ -94,7 +96,7 @@ module Vagrant
           execute(:timeout => env.config.ssh.timeout) do |ssh|
             Thread.current[:result] = true
           end
-        rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
+        rescue Errno::ECONNREFUSED, Net::SSH::Disconnect, Errors::SSHConnectionRefused
           # False, its defaulted above
         end
       end
@@ -102,7 +104,7 @@ module Vagrant
       check_thread.join(env.config.ssh.timeout)
       return check_thread[:result]
     rescue Net::SSH::AuthenticationFailed
-      error_and_exit(:vm_ssh_auth_failed)
+      raise Errors::SSHAuthenticationFailed.new
     end
 
     # Checks the file permissions for the private key, resetting them
@@ -114,15 +116,14 @@ module Vagrant
       stat = File.stat(key_path)
 
       if stat.owned? && file_perms(key_path) != "600"
-        env.logger.info "Permissions on private key incorrect, fixing..."
         File.chmod(0600, key_path)
 
-        error_and_exit(:ssh_bad_permissions, :key_path => key_path) if file_perms(key_path) != "600"
+        raise Errors::SSHKeyBadPermissions.new(:key_path => key_path) if file_perms(key_path) != "600"
       end
     rescue Errno::EPERM
       # This shouldn't happen since we verify we own the file, but just
       # in case.
-      error_and_exit(:ssh_bad_permissions, :key_path => key_path)
+      raise Errors::SSHKeyBadPermissions.new(:key_path => key_path)
     end
 
     # Returns the file permissions of a given file. This is fairly unix specific
@@ -163,6 +164,8 @@ module Vagrant
     # in order to provide basic command error checking while still
     # providing access to the actual session object.
     class Session
+      include Util::Retryable
+
       attr_reader :session
 
       def initialize(session)
@@ -185,9 +188,7 @@ module Vagrant
           ch[:result] << data if [:stdout, :stderr].include?(type)
         end
 
-        tries = 5
-
-        begin
+        retryable(:tries => 5, :on => IOError, :sleep => 0.5) do
           metach = session.open_channel do |channel|
             channel.exec(command) do |ch, success|
               raise "could not execute command: #{command.inspect}" unless success
@@ -208,13 +209,10 @@ module Vagrant
               end
             end
           end
-        rescue IOError
-          retry if (tries -= 1) > 0
-          raise
-        end
 
-        metach.wait
-        metach[:result]
+          metach.wait
+          metach[:result]
+        end
       end
 
       # Checks for an erroroneous exit status and raises an exception
@@ -222,13 +220,12 @@ module Vagrant
       def check_exit_status(exit_status, command, options=nil)
         if exit_status != 0
           options = {
-            :error_key => :ssh_bad_exit_status,
-            :error_data => {
-              :command => command
-            }
+            :_error_class => Errors::VagrantError,
+            :_key => :ssh_bad_exit_status,
+            :command => command
           }.merge(options || {})
 
-          raise Action::ActionException.new(options[:error_key], options[:error_data])
+          raise options[:_error_class].new(options)
         end
       end
     end

data/lib/vagrant/systems/base.rb

@@ -27,12 +27,6 @@ module Vagrant
         @vm = vm
       end
 
-      # A convenience method to access the logger on the VM
-      # environment.
-      def logger
-        vm.env.logger
-      end
-
       # Halt the machine. This method should gracefully shut down the
       # operating system. This method will cause `vagrant halt` and associated
       # commands to _block_, meaning that if the machine doesn't halt
@@ -59,13 +53,6 @@ module Vagrant
       # via the host are already done.
       def mount_nfs(ip, folders); end
 
-      # Prepares the system for unison folder syncing. This is called
-      # once once prior to any `create_unison` calls.
-      def prepare_unison(ssh); end
-
-      # Creates an entry for folder syncing via unison.
-      def create_unison(ssh, options); end
-
       # Prepares the system for host only networks. This is called
       # once prior to any `enable_host_only_network` calls.
       def prepare_host_only_network; end

data/lib/vagrant/systems/linux.rb

@@ -13,6 +13,8 @@ module Vagrant
       # generally, Vagrant tries to make almost every aspect of its execution
       # configurable, and this assists that goal.
       class LinuxConfig < Vagrant::Config::Base
+        configures :linux
+
         attr_accessor :halt_timeout
         attr_accessor :halt_check_interval
 
@@ -22,14 +24,11 @@ module Vagrant
         end
       end
 
-      # Register config class
-      Config.configures :linux, LinuxConfig
-
       #-------------------------------------------------------------------
       # Overridden methods
       #-------------------------------------------------------------------
       def halt
-        logger.info "Attempting graceful shutdown of linux..."
+        vm.env.ui.info I18n.t("vagrant.systems.linux.attempting_halt")
         vm.ssh.execute do |ssh|
           ssh.exec!("sudo halt")
         end
@@ -49,7 +48,7 @@ module Vagrant
       def mount_shared_folder(ssh, name, guestpath)
         ssh.exec!("sudo mkdir -p #{guestpath}")
         mount_folder(ssh, name, guestpath)
-        ssh.exec!("sudo chown #{config.ssh.username} #{guestpath}")
+        ssh.exec!("sudo chown #{vm.env.config.ssh.username} #{guestpath}")
       end
 
       def mount_nfs(ip, folders)
@@ -63,36 +62,12 @@ module Vagrant
         end
       end
 
-      def prepare_unison(ssh)
-        ssh.exec!("which unison", :error_key => :unison_not_found)
-
-        logger.info "Preparing system for unison sync..."
-        vm.ssh.upload!(StringIO.new(TemplateRenderer.render('/unison/script')), config.unison.script)
-        ssh.exec!("sudo chmod +x #{config.unison.script}")
-        ssh.exec!("sudo rm #{config.unison.crontab_entry_file}", :error_check => false)
-      end
-
-      def create_unison(ssh, opts)
-        sanitized_string = opts[:original][:guestpath].gsub(/[^a-zA-Z0-9_-]/, '-')
-        crontab_entry = TemplateRenderer.render('/unison/crontab_entry',
-                                                :from => opts[:guestpath],
-                                                :to => opts[:original][:guestpath],
-                                                :options => config.unison.options,
-                                                :script => config.unison.script,
-                                                :log_file => (config.unison.log_file % sanitized_string))
-
-        ssh.exec!("sudo rm -rf ~/.unison")
-        ssh.exec!("sudo rm -rf #{opts[:original][:guestpath]}")
-        ssh.exec!("sudo echo \"#{crontab_entry}\" >> #{config.unison.crontab_entry_file}")
-        ssh.exec!("crontab #{config.unison.crontab_entry_file}")
-      end
-
       def prepare_host_only_network
         # Remove any previous host only network additions to the
         # interface file.
         vm.ssh.execute do |ssh|
           # Verify debian/ubuntu
-          ssh.exec!("cat /etc/debian_version", :error_key => :network_not_debian)
+          ssh.exec!("cat /etc/debian_version", :error_class => LinuxError, :_key => :network_not_debian)
 
           # Clear out any previous entries
           ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces")
@@ -130,13 +105,15 @@ module Vagrant
           break unless result
 
           attempts += 1
-          raise Action::ActionException.new(:vm_mount_fail) if attempts >= 10
+          raise LinuxError.new(:mount_fail) if attempts >= 10
           sleep sleeptime
         end
       end
+    end
 
-      def config
-        vm.env.config
+    class Linux < Base
+      class LinuxError < Errors::VagrantError
+        error_namespace("vagrant.systems.linux")
       end
     end
   end

data/lib/vagrant/systems/solaris.rb

@@ -0,0 +1,59 @@
+module Vagrant
+  module Systems
+    # A general Vagrant system implementation for "solaris".
+    #
+    # Contributed by Blake Irvin <b.irvin@modcloth.com>
+    class Solaris < Base
+      # A custom config class which will be made accessible via `config.solaris`
+      # This is not necessary for all system implementers, of course. However,
+      # generally, Vagrant tries to make almost every aspect of its execution
+      # configurable, and this assists that goal.
+      class SolarisConfig < Vagrant::Config::Base
+        configures :solaris
+
+        attr_accessor :halt_timeout
+        attr_accessor :halt_check_interval
+
+        def initialize
+          @halt_timeout = 30
+          @halt_check_interval = 1
+        end
+      end
+
+      # Here for whenever it may be used.
+      class SolarisError < Errors::VagrantError
+        error_namespace("vagrant.systems.solaris")
+      end
+
+      # There should be an exception raised if the line
+      #
+      #     vagrant::::profiles=Primary Administrator
+      #
+      # does not exist in /etc/user_attr. TODO
+      def halt
+        vm.env.ui.info I18n.t("vagrant.systems.solaris.attempting_halt")
+        vm.ssh.execute do |ssh|
+          ssh.exec!("pfexec poweroff")
+        end
+
+        # Wait until the VM's state is actually powered off. If this doesn't
+        # occur within a reasonable amount of time (15 seconds by default),
+        # then simply return and allow Vagrant to kill the machine.
+        count = 0
+        while vm.vm.state != :powered_off
+          count += 1
+
+          return if count >= vm.env.config.solaris.halt_timeout
+          sleep vm.env.config.solaris.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(ssh, name, guestpath)
+        ssh.exec!("pfexec mkdir -p #{guestpath}")
+        # Using a custom mount method here; could use improvement.
+        ssh.exec!("pfexec mount -F vboxfs v-root #{guestpath}")
+        ssh.exec!("pfexec chown #{vm.env.config.ssh.username} #{guestpath}")
+      end
+    end
+  end
+end

data/lib/vagrant/test_helpers.rb

@@ -0,0 +1,109 @@
+module Vagrant
+  # Test helpers provided by Vagrant to allow for plugin developers
+  # to write automated tests for their code. This module simply provides
+  # methods which can be included into any test framework (`test/unit`,
+  # RSpec, Shoulda, etc.)
+  module TestHelpers
+    #------------------------------------------------------------
+    # Environment creation helpers
+    #------------------------------------------------------------
+    # Creates a "vagrant_app" directory in the test tmp folder
+    # which can be used for creating test Vagrant environments.
+    # Returns the root directory of the app. This typically doesn't need
+    # to be called directly unless you're setting up a custom application.
+    # See the examples for common use cases.
+    def vagrant_app(*path)
+      root = tmp_path.join("vagrant_app")
+      FileUtils.rm_rf(root)
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    # Creates a Vagrantfile with the given contents in the given
+    # app directory. If no app directory is specified, then a default
+    # Vagrant app is used.
+    def vagrantfile(*args)
+      path = args.shift.join("Vagrantfile") if Pathname === args.first
+      path ||= vagrant_app("Vagrantfile")
+      str  = args.shift || ""
+      File.open(path.to_s, "w") do |f|
+        f.puts "Vagrant::Config.run do |config|"
+        f.puts "config.vagrant.home = '#{home_path}'"
+        f.puts str
+        f.puts "end"
+      end
+
+      path.parent
+    end
+
+    # Creates and _loads_ a Vagrant environment at the given path.
+    # If no path is given, then a default {#vagrantfile} is used.
+    def vagrant_env(*args)
+      path = args.shift if Pathname === args.first
+      path ||= vagrantfile
+      Vagrant::Environment.new(:cwd => path).load!
+    end
+
+    # Creates the folder to contain a vagrant box. This allows for
+    # "fake" boxes to be made with the specified name.
+    #
+    # @param [String] name
+    # @return [Pathname]
+    def vagrant_box(name)
+      result = boxes_path.join(name)
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Returns a blank app (callable) and action environment with the
+    # given vagrant environment. This allows for testing of middlewares.
+    def action_env(v_env = nil)
+      v_env ||= vagrant_env
+      app = lambda { |env| }
+      env = Vagrant::Action::Environment.new(v_env)
+      env["vagrant.test"] = true
+      [app, env]
+    end
+
+    #------------------------------------------------------------
+    # Path helpers
+    #------------------------------------------------------------
+    # Path to the tmp directory for the tests.
+    #
+    # @return [Pathname]
+    def tmp_path
+      result = Vagrant.source_root.join("test", "tmp")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the "home" directory for the tests
+    #
+    # @return [Pathname]
+    def home_path
+      result = tmp_path.join("home")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the boxes directory in the home directory
+    #
+    # @return [Pathname]
+    def boxes_path
+      result = home_path.join("boxes")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Cleans all the test temp paths, which includes the boxes path,
+    # home path, etc. This allows for cleaning between tests.
+    def clean_paths
+      FileUtils.rm_rf(tmp_path)
+
+      # Call these methods only to rebuild the directories
+      tmp_path
+      home_path
+      boxes_path
+    end
+  end
+end