vagrant 0.8.10 → 0.9.0

data/lib/vagrant/guest/gentoo.rb

@@ -0,0 +1,32 @@
+require 'tempfile'
+
+module Vagrant
+  module Guest
+    class Gentoo < Linux
+      def configure_networks(networks)
+        # Remove any previous host only network additions to the interface file
+        vm.channel.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/conf.d/net > /tmp/vagrant-network-interfaces")
+        vm.channel.sudo("cat /tmp/vagrant-network-interfaces > /etc/conf.d/net")
+
+        # Configure each network interface
+        networks.each do |network|
+          entry = TemplateRenderer.render("guests/gentoo/network_#{network[:type]}",
+                                          :options => network)
+
+          # Upload the entry to a temporary location
+          temp = Tempfile.new("vagrant")
+          temp.write(entry)
+          temp.close
+
+          vm.channel.upload(temp.path, "/tmp/vagrant-network-entry")
+
+          # Configure the interface
+          vm.channel.sudo("ln -fs /etc/init.d/net.lo /etc/init.d/net.eth#{network[:interface]}")
+          vm.channel.sudo("/etc/init.d/net.eth#{network[:interface]} stop 2> /dev/null")
+          vm.channel.sudo("cat /tmp/vagrant-network-entry >> /etc/conf.d/net")
+          vm.channel.sudo("/etc/init.d/net.eth#{network[:interface]} start")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/guest/linux.rb

@@ -0,0 +1,78 @@
+require 'vagrant/guest/linux/error'
+require 'vagrant/guest/linux/config'
+
+module Vagrant
+  module Guest
+    class Linux < Base
+      def distro_dispatch
+        if @vm.channel.test("cat /etc/debian_version")
+          return :debian if @vm.channel.test("cat /proc/version | grep 'Debian'")
+          return :ubuntu if @vm.channel.test("cat /proc/version | grep 'Ubuntu'")
+        end
+
+        return :gentoo if @vm.channel.test("cat /etc/gentoo-release")
+        return :redhat if @vm.channel.test("cat /etc/redhat-release")
+        return :suse if @vm.channel.test("cat /etc/SuSE-release")
+        return :arch if @vm.channel.test("cat /etc/arch-release")
+
+        # Can't detect the distro, assume vanilla linux
+        nil
+      end
+
+      def halt
+        vm.channel.sudo("shutdown -h now")
+
+        # 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.state != :poweroff
+          count += 1
+
+          return if count >= vm.config.linux.halt_timeout
+          sleep vm.config.linux.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(name, guestpath, options)
+        @vm.channel.sudo("mkdir -p #{guestpath}")
+        mount_folder(name, guestpath, options)
+        @vm.channel.sudo("chown `id -u #{options[:owner]}`:`id -g #{options[:group]}` #{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.channel.sudo("mkdir -p #{opts[:guestpath]}")
+          vm.channel.sudo("mount #{ip}:'#{opts[:hostpath]}' #{opts[:guestpath]}",
+                          :error_class => LinuxError,
+                          :error_key => :mount_nfs_fail)
+        end
+      end
+
+      #-------------------------------------------------------------------
+      # "Private" methods which assist above methods
+      #-------------------------------------------------------------------
+      def mount_folder(name, guestpath, options)
+        # Determine the permission string to attach to the mount command
+        mount_options = "-o uid=`id -u #{options[:owner]}`,gid=`id -g #{options[:group]}`"
+        mount_options += ",#{options[:extra]}" if options[:extra]
+
+        attempts = 0
+        while true
+          success = true
+          @vm.channel.sudo("mount -t vboxsf #{mount_options} #{name} #{guestpath}") do |type, data|
+            success = false if type == :stderr && data =~ /No such device/i
+          end
+
+          break if success
+
+          attempts += 1
+          raise LinuxError, :mount_fail if attempts >= 10
+          sleep 5
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/{systems → guest}/linux/config.rb

@@ -1,13 +1,11 @@
 module Vagrant
-  module Systems
-    class Linux < Vagrant::Systems::Base
+  module Guest
+    class Linux < Vagrant::Guest::Base
       # A custom config class which will be made accessible via `config.linux`
       # 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 LinuxConfig < Vagrant::Config::Base
-        configures :linux
-
         attr_accessor :halt_timeout
         attr_accessor :halt_check_interval
 

data/lib/vagrant/guest/linux/error.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  module Guest
+    class Linux < Vagrant::Guest::Base
+      class LinuxError < Errors::VagrantError
+        error_namespace("vagrant.guest.linux")
+      end
+    end
+  end
+end

data/lib/vagrant/guest/redhat.rb

@@ -0,0 +1,66 @@
+require 'set'
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    class Redhat < Linux
+      # Make the TemplateRenderer top-level
+      include Vagrant::Util
+
+      def configure_networks(networks)
+        # Accumulate the configurations to add to the interfaces file as
+        # well as what interfaces we're actually configuring since we use that
+        # later.
+        interfaces = Set.new
+        networks.each do |network|
+          interfaces.add(network[:interface])
+
+          # Remove any previous vagrant configuration in this network interface's
+          # configuration files.
+          vm.channel.sudo("touch #{network_scripts_dir}/ifcfg-eth#{network[:interface]}")
+          vm.channel.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' #{network_scripts_dir}/ifcfg-eth#{network[:interface]} > /tmp/vagrant-ifcfg-eth#{network[:interface]}")
+          vm.channel.sudo("cat /tmp/vagrant-ifcfg-eth#{network[:interface]} > #{network_scripts_dir}/ifcfg-eth#{network[:interface]}")
+
+          # Render and upload the network entry file to a deterministic
+          # temporary location.
+          entry = TemplateRenderer.render("guests/redhat/network_#{network[:type]}",
+                                          :options => network)
+
+          temp = Tempfile.new("vagrant")
+          temp.write(entry)
+          temp.close
+
+          vm.channel.upload(temp.path, "/tmp/vagrant-network-entry_#{network[:interface]}")
+        end
+
+        # Bring down all the interfaces we're reconfiguring. By bringing down
+        # each specifically, we avoid reconfiguring eth0 (the NAT interface) so
+        # SSH never dies.
+        interfaces.each do |interface|
+          vm.channel.sudo("/sbin/ifdown eth#{interface} 2> /dev/null")
+          vm.channel.sudo("cat /tmp/vagrant-network-entry_#{interface} >> #{network_scripts_dir}/ifcfg-eth#{interface}")
+          vm.channel.sudo("/sbin/ifup eth#{interface}")
+        end
+      end
+
+      # The path to the directory with the network configuration scripts.
+      # This is pulled out into its own directory since there are other
+      # operating systems (SuSE) which behave similarly but with a different
+      # path to the network scripts.
+      def network_scripts_dir
+        '/etc/sysconfig/network-scripts'
+      end
+
+      def change_host_name(name)
+        # Only do this if the hostname is not already set
+        if !vm.channel.test("sudo hostname | grep '#{name}'")
+          vm.channel.sudo("sed -i 's/\\(HOSTNAME=\\).*/\\1#{name}/' /etc/sysconfig/network")
+          vm.channel.sudo("hostname #{name}")
+          vm.channel.sudo("sed -i 's@^\\(127[.]0[.]0[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
+        end
+      end
+    end
+  end
+end

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/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

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