vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/guest/solaris.rb

@@ -0,0 +1,114 @@
+module Vagrant
+  module Guest
+    # 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
+        attr_accessor :halt_timeout
+        attr_accessor :halt_check_interval
+        # This sets the command to use to execute items as a superuser. sudo is default
+        attr_accessor :suexec_cmd
+        attr_accessor :device
+
+        def initialize
+          @halt_timeout = 30
+          @halt_check_interval = 1
+          @suexec_cmd = 'sudo'
+          @device = "e1000g"
+        end
+      end
+
+      # Here for whenever it may be used.
+      class SolarisError < Errors::VagrantError
+        error_namespace("vagrant.guest.solaris")
+      end
+
+      def configure_networks(networks)
+        networks.each do |network|
+          device = "#{vm.config.solaris.device}#{network[:interface]}"
+          su_cmd = vm.config.solaris.suexec_cmd
+          ifconfig_cmd = "#{su_cmd} /sbin/ifconfig #{device}"
+
+          vm.channel.execute("#{ifconfig_cmd} plumb")
+
+          if network[:type].to_sym == :static
+            vm.channel.execute("#{ifconfig_cmd} inet #{network[:ip]} netmask #{network[:netmask]}")
+            vm.channel.execute("#{ifconfig_cmd} up")
+            vm.channel.execute("#{su_cmd} sh -c \"echo '#{network[:ip]}' > /etc/hostname.#{device}\"")
+          elsif network[:type].to_sym == :dhcp
+            vm.channel.execute("#{ifconfig_cmd} dhcp start")
+          end
+        end
+      end
+
+      def change_host_name(name)
+        su_cmd = vm.config.solaris.suexec_cmd
+
+        # Only do this if the hostname is not already set
+        if !vm.channel.test("#{su_cmd} hostname | grep '#{name}'")
+          vm.channel.execute("#{su_cmd} sh -c \"echo '#{name}' > /etc/nodename\"")
+          vm.channel.execute("#{su_cmd} uname -S #{name}")
+        end
+      end
+
+      # There should be an exception raised if the line
+      #
+      #     vagrant::::profiles=Primary Administrator
+      #
+      # does not exist in /etc/user_attr. TODO
+      def halt
+        # 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
+        last_error = nil
+        while vm.state != :poweroff
+          begin
+            vm.channel.execute("#{vm.config.solaris.suexec_cmd} /usr/sbin/poweroff")
+          rescue IOError => e
+            # Save the last error; if it's not shutdown in a reasonable amount
+            # of attempts we will re-raise the error so it's not hidden for
+            # all time
+            last_error = e
+          end
+
+          count += 1
+          if count >= vm.config.solaris.halt_timeout
+            # Check for last error and re-raise it
+            if last_error != nil
+              raise last_error
+            else
+              # Otherwise, just return
+              return
+            end
+          end
+
+          # Still opportunities remaining; sleep and loop
+          sleep vm.config.solaris.halt_check_interval
+        end # while
+      end
+
+      def mount_shared_folder(name, guestpath, options)
+        # These are just far easier to use than the full options syntax
+        owner = options[:owner]
+        group = options[:group]
+
+        # Create the shared folder
+        vm.channel.execute("#{vm.config.solaris.suexec_cmd} mkdir -p #{guestpath}")
+
+        # Mount the folder with the proper owner/group
+        mount_options = "-o uid=`id -u #{owner}`,gid=`id -g #{group}`"
+        mount_options += ",#{options[:extra]}" if options[:extra]
+        vm.channel.execute("#{vm.config.solaris.suexec_cmd} /sbin/mount -F vboxfs #{mount_options} #{name} #{guestpath}")
+
+        # chown the folder to the proper owner/group
+        vm.channel.execute("#{vm.config.solaris.suexec_cmd} chown `id -u #{owner}`:`id -g #{group}` #{guestpath}")
+      end
+    end
+  end
+end

data/lib/vagrant/{systems → guest}/suse.rb

@@ -1,9 +1,9 @@
 module Vagrant
-  module Systems
+  module Guest
     class Suse < Redhat
       def network_scripts_dir
         '/etc/sysconfig/network/'
-      end 
+      end
     end
   end
 end

data/lib/vagrant/guest/ubuntu.rb

@@ -0,0 +1,23 @@
+require 'vagrant/guest/debian'
+
+module Vagrant
+  module Guest
+    class Ubuntu < Debian
+      def mount_shared_folder(name, guestpath, options)
+        # Mount it like normal
+        super
+
+        # Emit an upstart event if upstart is available
+        @vm.channel.sudo("[ -x /sbin/initctl ] && /sbin/initctl emit vagrant-mounted MOUNTPOINT=#{guestpath}")
+      end
+
+      def change_host_name(name)
+        if !vm.channel.test("sudo hostname | grep '#{name}'")
+          vm.channel.sudo("sed -i 's/.*$/#{name}/' /etc/hostname")
+          vm.channel.sudo("sed -i 's@^\\(127[.]0[.]1[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
+          vm.channel.sudo("service hostname start")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/guest.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  module Guest
+    autoload :Base, 'vagrant/guest/base'
+
+    # Specific guests
+    autoload :Arch,    'vagrant/guest/arch'
+    autoload :Debian,  'vagrant/guest/debian'
+    autoload :FreeBSD, 'vagrant/guest/freebsd'
+    autoload :Gentoo,  'vagrant/guest/gentoo'
+    autoload :Linux,   'vagrant/guest/linux'
+    autoload :Redhat,  'vagrant/guest/redhat'
+    autoload :Solaris, 'vagrant/guest/solaris'
+    autoload :Suse,    'vagrant/guest/suse'
+    autoload :Ubuntu,  'vagrant/guest/ubuntu'
+  end
+end

data/lib/vagrant/hosts/arch.rb

@@ -1,13 +1,17 @@
 module Vagrant
   module Hosts
     class Arch < Linux
-      def nfs_export(ip, folders)
+      def self.match?
+        File.exist?("/etc/rc.conf") && File.exist?("/etc/pacman.conf")
+      end
+
+      def nfs_export(id, ip, folders)
         output = TemplateRenderer.render('nfs/exports_linux',
-                                         :uuid => env.vm.uuid,
+                                         :uuid => id,
                                          :ip => ip,
                                          :folders => folders)
 
-        env.ui.info I18n.t("vagrant.hosts.arch.nfs_export.prepare")
+        @ui.info I18n.t("vagrant.hosts.arch.nfs_export.prepare")
         sleep 0.5
 
         output.split("\n").each do |line|

data/lib/vagrant/hosts/base.rb

@@ -1,54 +1,39 @@
 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`.
+    # Interface for classes which house behavior that is specific
+    # to the host OS that is running Vagrant.
+    #
+    # By default, Vagrant will attempt to choose the best option
+    # for your machine, but the host may also be explicitly set
+    # via the `config.vagrant.host` parameter.
     class Base
-      # The {Environment} which this host belongs to.
-      attr_reader :env
-
-      # 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 self.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.
+      # This returns true/false depending on if the current running system
+      # matches the host class.
       #
-      # @return [Class]
-      def self.detect
-        [BSD, Linux].each do |type|
-          result = type.distro_dispatch
-          return result if result
-        end
-
-        nil
-      rescue Exception
+      # @return [Boolean]
+      def self.match?
         nil
       end
 
-      # This must be implemented by subclasses to dispatch to the proper
-      # distro-specific class for the host. If this returns nil then it is
-      # an invalid host class.
-      def self.distro_dispatch
-        nil
+      # The precedence of the host when checking for matches. This is to
+      # allow certain host such as generic OS's ("Linux", "BSD", etc.)
+      # to be specified last.
+      #
+      # The hosts with the higher numbers will be checked first.
+      #
+      # If you're implementing a basic host, you can probably ignore this.
+      def self.precedence
+        5
       end
 
-      # Initialzes a new host. This method shouldn't be called directly,
-      # typically, since it will be called by {Environment#load!}.
+      # Initializes a new host class.
+      #
+      # The only required parameter is a UI object so that the host
+      # objects have some way to communicate with the outside world.
       #
-      # @param [Environment] env
-      def initialize(env)
-        @env = env
+      # @param [UI] ui UI for the hosts to output to.
+      def initialize(ui)
+        @ui = ui
       end
 
       # Returns true of false denoting whether or not this host supports
@@ -60,16 +45,21 @@ module Vagrant
         false
       end
 
-      # Exports the given hash of folders via NFS. This method will raise
-      # an {Vagrant::Action::ActionException} if anything goes wrong.
+      # Exports the given hash of folders via NFS.
       #
+      # @param [String] id A unique ID that is guaranteed to be unique to
+      #   match these sets of folders.
       # @param [String] ip IP of the guest machine.
       # @param [Hash] folders Shared folders to sync.
-      def nfs_export(ip, folders)
+      def nfs_export(id, ip, folders)
       end
 
-      # Cleans up the exports for the current VM.
-      def nfs_cleanup
+      # Prunes any NFS exports made by Vagrant which aren't in the set
+      # of valid ids given.
+      #
+      # @param [Array<String>] valid_ids Valid IDs that should not be
+      #   pruned.
+      def nfs_prune(valid_ids)
       end
     end
   end

data/lib/vagrant/hosts/bsd.rb

@@ -1,3 +1,5 @@
+require 'log4r'
+
 require 'vagrant/util/platform'
 
 module Vagrant
@@ -7,9 +9,21 @@ module Vagrant
       include Util
       include Util::Retryable
 
-      def self.distro_dispatch
-        return FreeBSD if Util::Platform.freebsd?
-        return self if Util::Platform.darwin? || Util::Platform.bsd?
+      def self.match?
+        Util::Platform.darwin? || Util::Platform.bsd?
+      end
+
+      def self.precedence
+        # Set a lower precedence because this is a generic OS. We
+        # want specific distros to match first.
+        2
+      end
+
+      def initialize(*args)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::hosts::bsd")
+        @nfs_restart_command = "sudo nfsd restart"
       end
 
       def nfs?
@@ -18,42 +32,65 @@ module Vagrant
         end
       end
 
-      def nfs_export(ip, folders)
+      def nfs_export(id, ip, folders)
         output = TemplateRenderer.render('nfs/exports',
-                                         :uuid => env.vm.uuid,
+                                         :uuid => id,
                                          :ip => ip,
                                          :folders => folders)
 
         # The sleep ensures that the output is truly flushed before any `sudo`
         # commands are issued.
-        env.ui.info I18n.t("vagrant.hosts.bsd.nfs_export.prepare")
+        @ui.info I18n.t("vagrant.hosts.bsd.nfs_export")
         sleep 0.5
 
+        # First, clean up the old entry
+        nfs_cleanup(id)
+
+        # Output the rendered template into the exports
         output.split("\n").each do |line|
-          # This should only ask for administrative permission once, even
-          # though its executed in multiple subshells.
           line = line.gsub('"', '\"')
           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")
+        system(@nfs_restart_command)
       end
 
-      def nfs_cleanup
+      def nfs_prune(valid_ids)
         return if !File.exist?("/etc/exports")
 
-        retryable(:tries => 10, :on => TypeError) do
-          system("cat /etc/exports | grep 'VAGRANT-BEGIN: #{env.vm.uuid}' > /dev/null 2>&1")
+        @logger.info("Pruning invalid NFS entries...")
 
-          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")
+        output = false
+
+        File.read("/etc/exports").lines.each do |line|
+          if line =~ /^# VAGRANT-BEGIN: (.+?)$/
+            if valid_ids.include?($1.to_s)
+              @logger.debug("Valid ID: #{$1.to_s}")
+            else
+              if !output
+                # We want to warn the user but we only want to output once
+                @ui.info I18n.t("vagrant.hosts.bsd.nfs_prune")
+                output = true
+              end
+
+              @logger.info("Invalid ID, pruning: #{$1.to_s}")
+              nfs_cleanup($1.to_s)
+            end
           end
         end
       end
+
+      protected
+
+      def nfs_cleanup(id)
+        return if !File.exist?("/etc/exports")
+
+        # Use sed to just strip out the block of code which was inserted
+        # by Vagrant, and restart NFS.
+        system("sudo sed -e '/^# VAGRANT-BEGIN: #{id}/,/^# VAGRANT-END: #{id}/ d' -ibak /etc/exports")
+      end
     end
   end
 end

data/lib/vagrant/hosts/fedora.rb

@@ -1,6 +1,20 @@
+require 'pathname'
+
 module Vagrant
   module Hosts
     class Fedora < Linux
+      def self.match?
+        release_file = Pathname.new("/etc/redhat-release")
+
+        if release_file.exist?
+          release_file.open("r") do |f|
+            return true if f.gets =~ /^Fedora/
+          end
+        end
+
+        false
+      end
+
       def initialize(*args)
         super
 

data/lib/vagrant/hosts/freebsd.rb

@@ -7,45 +7,15 @@ module Vagrant
       include Util
       include Util::Retryable
 
-      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.ui.info I18n.t("vagrant.hosts.bsd.nfs_export.prepare")
-        sleep 0.5
-
-        output.split("\n").each do |line|
-          # This should only ask for administrative permission once, even
-          # though its executed in multiple subshells.
-          line = line.gsub('"', '\"')
-          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/rc.d/mountd onereload")
+      def self.match?
+        Util::Platform.freebsd?
       end
 
-    end
-
-    def nfs_cleanup
-        return if !File.exist?("/etc/exports")
-
-        retryable(:tries => 10, :on => TypeError) do
-          system("cat /etc/exports | grep 'VAGRANT-BEGIN: #{env.vm.uuid}' > /dev/null 2>&1")
+      def initialize(*args)
+        super
 
-          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
-
-          system("sudo /etc/rc.d/mountd onereload")
-        end
+        @nfs_restart_command = "sudo /etc/rc.d/mountd onereload"
       end
+    end
   end
 end

data/lib/vagrant/hosts/linux.rb

@@ -1,3 +1,5 @@
+require 'log4r'
+
 require 'vagrant/util/platform'
 
 module Vagrant
@@ -7,23 +9,20 @@ module Vagrant
       include Util
       include Util::Retryable
 
-      def self.distro_dispatch
-        return nil if !Util::Platform.linux?
-        return Arch if File.exist?("/etc/rc.conf") && File.exist?("/etc/pacman.conf")
-
-        if File.exist?("/etc/redhat-release")
-          # Check if we have a known redhat release
-          File.open("/etc/redhat-release") do |f|
-            return Fedora if f.gets =~ /^Fedora/
-          end
-        end
+      def self.match?
+        Util::Platform.linux?
+      end
 
-        return self
+      def self.precedence
+        # Set a lower precedence because this is a generic OS. We
+        # want specific distros to match first.
+        2
       end
 
       def initialize(*args)
         super
 
+        @logger = Log4r::Logger.new("vagrant::hosts::linux")
         @nfs_server_binary = "/etc/init.d/nfs-kernel-server"
       end
 
@@ -34,15 +33,17 @@ module Vagrant
         end
       end
 
-      def nfs_export(ip, folders)
+      def nfs_export(id, ip, folders)
         output = TemplateRenderer.render('nfs/exports_linux',
-                                         :uuid => env.vm.uuid,
+                                         :uuid => id,
                                          :ip => ip,
                                          :folders => folders)
 
-        env.ui.info I18n.t("vagrant.hosts.linux.nfs_export.prepare")
+        @ui.info I18n.t("vagrant.hosts.linux.nfs_export")
         sleep 0.5
 
+        nfs_cleanup(id)
+
         output.split("\n").each do |line|
           # This should only ask for administrative permission once, even
           # though its executed in multiple subshells.
@@ -54,16 +55,40 @@ module Vagrant
         system("sudo #{@nfs_server_binary} restart")
       end
 
-      def nfs_cleanup
+      def nfs_prune(valid_ids)
         return if !File.exist?("/etc/exports")
-        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")
+        @logger.info("Pruning invalid NFS entries...")
+
+        output = false
+
+        File.read("/etc/exports").lines.each do |line|
+          if line =~ /^# VAGRANT-BEGIN: (.+?)$/
+            if valid_ids.include?($1.to_s)
+              @logger.debug("Valid ID: #{$1.to_s}")
+            else
+              if !output
+                # We want to warn the user but we only want to output once
+                @ui.info I18n.t("vagrant.hosts.linux.nfs_prune")
+                output = true
+              end
+
+              @logger.info("Invalid ID, pruning: #{$1.to_s}")
+              nfs_cleanup($1.to_s)
+            end
+          end
         end
       end
+
+      protected
+
+      def nfs_cleanup(id)
+        return if !File.exist?("/etc/exports")
+
+        # Use sed to just strip out the block of code which was inserted
+        # by Vagrant
+        system("sudo sed -e '/^# VAGRANT-BEGIN: #{id}/,/^# VAGRANT-END: #{id}/ d' -ibak /etc/exports")
+      end
     end
   end
 end

data/lib/vagrant/hosts/windows.rb

@@ -0,0 +1,16 @@
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Hosts
+    class Windows < Base
+      def self.match?
+        Util::Platform.windows?
+      end
+
+      # Windows does not support NFS
+      def nfs?
+        false
+      end
+    end
+  end
+end

data/lib/vagrant/hosts.rb

@@ -1,10 +1,27 @@
 module Vagrant
   module Hosts
-    autoload :Base,  'vagrant/hosts/base'
-    autoload :Arch,  'vagrant/hosts/arch'
-    autoload :BSD,   'vagrant/hosts/bsd'
-    autoload :FreeBSD,'vagrant/hosts/freebsd'
-    autoload :Fedora, 'vagrant/hosts/fedora'
-    autoload :Linux, 'vagrant/hosts/linux'
+    autoload :Base,    'vagrant/hosts/base'
+    autoload :Arch,    'vagrant/hosts/arch'
+    autoload :BSD,     'vagrant/hosts/bsd'
+    autoload :FreeBSD, 'vagrant/hosts/freebsd'
+    autoload :Fedora,  'vagrant/hosts/fedora'
+    autoload :Linux,   'vagrant/hosts/linux'
+    autoload :Windows, 'vagrant/hosts/windows'
+
+    # This method detects the correct host based on the `match?` methods
+    # implemented in the registered hosts.
+    def self.detect(registry)
+      # Sort the hosts by their precedence
+      host_klasses = registry.to_hash.values
+      host_klasses = host_klasses.sort_by { |a| a.precedence }.reverse
+
+      # Test for matches and return the host class that matches
+      host_klasses.each do |klass|
+        return klass if klass.match?
+      end
+
+      # No matches found...
+      return nil
+    end
   end
 end