vagrant 0.4.2 → 0.5.0

data/lib/vagrant/hosts/base.rb

@@ -0,0 +1,77 @@
+module Vagrant
+  module Hosts
+    # Base class representing a host machine. These classes
+    # define methods which may have host-specific (Mac OS X, Windows,
+    # Linux, etc) behavior. The class is automatically determined by
+    # default but may be explicitly set via `config.vagrant.host`.
+    class Base
+      # The {Environment} which this host belongs to.
+      attr_reader :env
+
+      class << self
+        # Loads the proper host for the given value. If the value is nil
+        # or is the symbol `:detect`, then the host class will be detected
+        # using the `RUBY_PLATFORM` constant.
+        #
+        # @param [Environment] env
+        # @param [String] klass
+        # @return [Base]
+        def load(env, klass)
+          klass = detect if klass.nil? || klass == :detect
+          return nil if !klass
+          return klass.new(env)
+        end
+
+        # Detects the proper host class for current platform and returns
+        # the class.
+        #
+        # @return [Class]
+        def detect
+          # More coming soon
+          classes = {
+            :darwin => BSD,
+            :bsd => BSD,
+            :linux => Linux
+          }
+
+          classes.each do |type, klass|
+            return klass if Util::Platform.send("#{type}?")
+          end
+
+          nil
+        rescue Exception
+          nil
+        end
+      end
+
+      # Initialzes a new host. This method shouldn't be called directly,
+      # typically, since it will be called by {Environment#load_host!}
+      #
+      # @param [Environment] env
+      def initialize(env)
+        @env = env
+      end
+
+      # Returns true of false denoting whether or not this host supports
+      # NFS shared folder setup. This method ideally should verify that
+      # NFS is installed.
+      #
+      # @return [Boolean]
+      def nfs?
+        false
+      end
+
+      # Exports the given hash of folders via NFS. This method will raise
+      # an {Vagrant::Action::ActionException} if anything goes wrong.
+      #
+      # @param [String] ip IP of the guest machine.
+      # @param [Hash] folders Shared folders to sync.
+      def nfs_export(ip, folders)
+      end
+
+      # Cleans up the exports for the current VM.
+      def nfs_cleanup
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/bsd.rb

@@ -0,0 +1,53 @@
+module Vagrant
+  module Hosts
+    # Represents a BSD host, such as FreeBSD and Darwin (Mac OS X).
+    class BSD < Base
+      include Util
+
+      def nfs?
+        tries = 10
+        begin
+          system("which nfsd > /dev/null 2>&1")
+        rescue TypeError
+          tries -= 1
+          retry if tries > 0
+
+          # Hopefully this point isn't reached
+          raise
+        end
+      end
+
+      def nfs_export(ip, folders)
+        output = TemplateRenderer.render('nfs/exports',
+                                         :uuid => env.vm.uuid,
+                                         :ip => ip,
+                                         :folders => folders)
+
+        # 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..."
+        sleep 0.5
+
+        output.split("\n").each do |line|
+          # This should only ask for administrative permission once, even
+          # though its executed in multiple subshells.
+          system(%Q[sudo su root -c "echo '#{line}' >> /etc/exports"])
+        end
+
+        # We run restart here instead of "update" just in case nfsd
+        # is not starting
+        system("sudo nfsd restart")
+      end
+
+      def nfs_cleanup
+        system("cat /etc/exports | grep 'VAGRANT-BEGIN: #{env.vm.uuid}' > /dev/null 2>&1")
+
+        if $?.to_i == 0
+          # Use sed to just strip out the block of code which was inserted
+          # by Vagrant
+          system("sudo sed -e '/^# VAGRANT-BEGIN: #{env.vm.uuid}/,/^# VAGRANT-END: #{env.vm.uuid}/ d' -i bak /etc/exports")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/hosts/linux.rb

@@ -0,0 +1,52 @@
+module Vagrant
+  module Hosts
+    # Represents a Linux based host, such as Ubuntu.
+    class Linux < Base
+      include Util
+
+      def nfs?
+        tries = 10
+        begin
+          # 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
+
+      def nfs_export(ip, folders)
+        output = TemplateRenderer.render('nfs/exports_linux',
+                                         :uuid => env.vm.uuid,
+                                         :ip => ip,
+                                         :folders => folders)
+
+        env.logger.info "Preparing to edit /etc/exports. Administrator priveleges will be required..."
+        sleep 0.5
+
+        output.split("\n").each do |line|
+          # This should only ask for administrative permission once, even
+          # though its executed in multiple subshells.
+          system(%Q[sudo su root -c "echo '#{line}' >> /etc/exports"])
+        end
+
+        # We run restart here instead of "update" just in case nfsd
+        # is not starting
+        system("sudo /etc/init.d/nfs-kernel-server restart")
+      end
+
+      def nfs_cleanup
+        system("cat /etc/exports | grep 'VAGRANT-BEGIN: #{env.vm.uuid}' > /dev/null 2>&1")
+
+        if $?.to_i == 0
+          # Use sed to just strip out the block of code which was inserted
+          # by Vagrant
+          system("sudo sed -e '/^# VAGRANT-BEGIN: #{env.vm.uuid}/,/^# VAGRANT-END: #{env.vm.uuid}/ d' -ibak /etc/exports")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/base.rb

@@ -7,19 +7,27 @@ module Vagrant
     class Base
       include Vagrant::Util
 
-      # The VM which this is being provisioned for
-      attr_reader :vm
+      # The environment which provisioner is running in. This is a
+      # {Vagrant::Action::Environment}
+      attr_reader :action_env
 
-      def initialize(vm)
-        @vm = vm
+      def initialize(env)
+        @action_env = env
       end
 
-      # This method returns the environment which the provisioner is working
-      # on. This is also the environment of the VM. This method is provided
-      # as a simple helper since the environment is often used throughout the
-      # provisioner.
+      # Returns the actual {Vagrant::Environment} which this provisioner
+      # represents.
+      #
+      # @return [Vagrant::Environment]
       def env
-        @vm.env
+        action_env.env
+      end
+
+      # Returns the VM which this provisioner is working on.
+      #
+      # @return [Vagrant::VM]
+      def vm
+        env.vm
       end
 
       # This method returns the environment's logger as a convenience

data/lib/vagrant/provisioners/chef.rb

@@ -72,7 +72,7 @@ module Vagrant
       Config.configures :chef, ChefConfig
 
       def prepare
-        raise Actions::ActionException.new(:chef_base_invalid_provisioner)
+        action_env.error!(:chef_base_invalid_provisioner)
       end
 
       def verify_binary(binary)

data/lib/vagrant/provisioners/chef_server.rb

@@ -5,13 +5,11 @@ module Vagrant
     class ChefServer < Chef
       def prepare
         if env.config.chef.validation_key_path.nil?
-          raise Actions::ActionException.new(:chef_server_validation_key_required)
+          action_env.error!(:chef_server_validation_key_required)
         elsif !File.file?(validation_key_path)
-          raise Actions::ActionException.new(:chef_server_validation_key_doesnt_exist)
-        end
-
-        if env.config.chef.chef_server_url.nil?
-          raise Actions::ActionException.new(:chef_server_url_required)
+          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
       end
 
@@ -55,8 +53,6 @@ module Vagrant
         logger.info "Running chef-client..."
         vm.ssh.execute do |ssh|
           ssh.exec!(command) do |channel, type, data|
-            # TODO: Very verbose. It would be easier to save the data and only show it during
-            # an error, or when verbosity level is set high
             if type == :exit_status
               ssh.check_exit_status(data, command)
             else

data/lib/vagrant/provisioners/chef_solo.rb

@@ -29,6 +29,7 @@ module Vagrant
 
       def setup_solo_config
         setup_config("chef_solo_solo", "solo.rb", {
+          :node_name => env.config.chef.node_name,
           :provisioning_path => env.config.chef.provisioning_path,
           :cookbooks_path => cookbooks_path,
           :roles_path => roles_path
@@ -41,8 +42,6 @@ module Vagrant
         logger.info "Running chef-solo..."
         vm.ssh.execute do |ssh|
           ssh.exec!(command) do |channel, type, data|
-            # TODO: Very verbose. It would be easier to save the data and only show it during
-            # an error, or when verbosity level is set high
             ssh.check_exit_status(data, command) if type == :exit_status
             logger.info("#{data}: #{type}") if type != :exit_status
           end

data/lib/vagrant/ssh.rb

@@ -31,12 +31,17 @@ module Vagrant
 
       check_key_permissions(options[:private_key_path])
 
+      # Command line options
+      command_options = ["-p #{options[:port]}", "-o UserKnownHostsFile=/dev/null",
+                         "-o StrictHostKeyChecking=no", "-i #{options[:private_key_path]}"]
+      command_options << "-o ForwardAgent=yes" if env.config.ssh.forward_agent
+
       # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
       # (GH-51). As a workaround, we fork and wait. On all other platforms,
       # we simply exec.
       pid = nil
       pid = fork if Util::Platform.leopard?
-      Kernel.exec "ssh -p #{options[:port]} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -i #{options[:private_key_path]} #{options[:username]}@#{options[:host]}".strip if pid.nil?
+      Kernel.exec "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip if pid.nil?
       Process.wait(pid) if pid
     end
 
@@ -46,6 +51,10 @@ module Vagrant
       # Check the key permissions to avoid SSH hangs
       check_key_permissions(env.config.ssh.private_key_path)
 
+      # Merge in any additional options
+      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,
@@ -98,10 +107,9 @@ module Vagrant
     # Checks the file permissions for the private key, resetting them
     # if needed, or on failure erroring.
     def check_key_permissions(key_path)
+      # Windows systems don't have this issue
       return if Mario::Platform.windows?
 
-      # TODO: This only works on unix based systems for now. Windows
-      # systems will need to be investigated further.
       stat = File.stat(key_path)
 
       if stat.owned? && file_perms(key_path) != "600"
@@ -219,7 +227,7 @@ module Vagrant
             }
           }.merge(options || {})
 
-          raise Actions::ActionException.new(options[:error_key], options[:error_data])
+          raise Action::ActionException.new(options[:error_key], options[:error_data])
         end
       end
     end

data/lib/vagrant/systems/base.rb

@@ -55,6 +55,10 @@ module Vagrant
       #   wants the folder mounted.
       def mount_shared_folder(ssh, name, guestpath); end
 
+      # Mounts a shared folder via NFS. This assumes that the exports
+      # 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

data/lib/vagrant/systems/linux.rb

@@ -52,6 +52,17 @@ module Vagrant
         ssh.exec!("sudo chown #{config.ssh.username} #{guestpath}")
       end
 
+      def mount_nfs(ip, folders)
+        # TODO: Maybe check for nfs support on the guest, since its often
+        # not installed by default
+        folders.each do |name, opts|
+          vm.ssh.execute do |ssh|
+            ssh.exec!("sudo mkdir -p #{opts[:guestpath]}")
+            ssh.exec!("sudo mount #{ip}:#{opts[:hostpath]} #{opts[:guestpath]}")
+          end
+        end
+      end
+
       def prepare_unison(ssh)
         ssh.exec!("which unison", :error_key => :unison_not_found)
 
@@ -119,7 +130,7 @@ module Vagrant
           break unless result
 
           attempts += 1
-          raise Actions::ActionException.new(:vm_mount_fail) if attempts >= 10
+          raise Action::ActionException.new(:vm_mount_fail) if attempts >= 10
           sleep sleeptime
         end
       end

data/lib/vagrant/util.rb

@@ -3,5 +3,21 @@ module Vagrant
     def self.included(base)
       base.extend(self)
     end
+
+    def error_and_exit(key, data = {})
+      abort <<-error
+=====================================================================
+Vagrant experienced an error!
+
+#{Translator.t(key, data).chomp}
+=====================================================================
+error
+    end
+
+    def wrap_output
+      puts "====================================================================="
+      yield
+      puts "====================================================================="
+    end
   end
 end

data/lib/vagrant/util/busy.rb

@@ -0,0 +1,59 @@
+module Vagrant
+  module Util
+    # Utility class which allows blocks of code to be marked as "busy"
+    # with a specified interrupt handler. During busy areas of code, it
+    # is often undesirable for SIGINTs to immediately kill the application.
+    # This class is a helper to cleanly register callbacks to handle this
+    # situation.
+    class Busy
+      @@registered = []
+      @@mutex = Mutex.new
+
+      class << self
+        # Mark a given block of code as a "busy" block of code, which will
+        # register a SIGINT handler for the duration of the block. When a
+        # SIGINT occurs, the `sig_callback` proc will be called. It is up
+        # to the callback to behave properly and exit the application.
+        def busy(sig_callback)
+          register(sig_callback)
+          yield
+        ensure
+          unregister(sig_callback)
+        end
+
+        # Registers a SIGINT handler. This typically is called from {busy}.
+        # Callbacks are only registered once, so calling this multiple times
+        # with the same callback has no consequence.
+        def register(sig_callback)
+          @@mutex.synchronize do
+            registered << sig_callback
+            registered.uniq!
+
+            # Register the handler if this is our first callback.
+            Signal.trap("INT") { fire_callbacks } if registered.length == 1
+          end
+        end
+
+        # Unregisters a SIGINT handler.
+        def unregister(sig_callback)
+          @@mutex.synchronize do
+            registered.delete(sig_callback)
+
+            # Remove the signal trap if no more registered callbacks exist
+            Signal.trap("INT", "DEFAULT") if registered.empty?
+          end
+        end
+
+        # Fires all the registered callbacks.
+        def fire_callbacks
+          registered.each { |r| r.call }
+        end
+
+        # Helper method to get access to the class variable. This is mostly
+        # exposed for tests. This shouldn't be mucked with directly, since it's
+        # structure may change at any time.
+        def registered; @@registered; end
+      end
+    end
+  end
+end