boxcar 0.10005.1

data/lib/vagrant/guest/arch.rb

@@ -0,0 +1,56 @@
+require 'set'
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    class Arch < Linux
+      # Make the TemplateRenderer top-level
+      include Vagrant::Util
+
+      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/rc.conf")
+          vm.channel.sudo("hostname #{name}")
+          vm.channel.sudo("sed -i 's@^\\(127[.]0[.]0[.]1[[:space:]]\\+\\)@\\1#{name} @' /etc/hosts")
+        end
+      end
+
+      def configure_networks(networks)
+        # Remove previous Vagrant-managed network interfaces
+        vm.channel.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/rc.conf > /tmp/vagrant-network-interfaces")
+        vm.channel.sudo("cat /tmp/vagrant-network-interfaces > /etc/rc.conf")
+
+        # Configure the network interfaces
+        interfaces = Set.new
+        entries = []
+        networks.each do |network|
+          interfaces.add(network[:interface])
+          entry = TemplateRenderer.render("guests/arch/network_#{network[:type]}",
+                                          :options => network)
+
+          entries << entry
+        end
+
+        # Perform the careful dance necessary to reconfigure
+        # the network interfaces
+        temp = Tempfile.new("vagrant")
+        temp.binmode
+        temp.write(entries.join("\n"))
+        temp.close
+
+        vm.channel.upload(temp.path, "/tmp/vagrant-network-entry")
+
+        # Reconfigure the network interfaces
+        vm.channel.sudo("cat /tmp/vagrant-network-entry >> /etc/rc.conf")
+        vm.channel.sudo("/etc/rc.d/network restart")
+
+        interfaces.each do |interface|
+          vm.channel.sudo("dhcpcd -k eth#{interface} && dhcpcd eth#{interface} && sleep 3")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/guest/base.rb

@@ -0,0 +1,99 @@
+module Vagrant
+  module Guest
+    # The base class for a "system." A system represents an installed
+    # operating system on a given box. There are some portions of
+    # Vagrant which are fairly OS-specific (such as mounting shared
+    # folders) and while the number is few, this abstraction allows
+    # more obscure operating systems to be installed without having
+    # to directly modify Vagrant internals.
+    #
+    # Subclasses of the system base class are expected to implement
+    # all the methods. These methods are described in the comments
+    # above their definition.
+    #
+    # **This is by no means a complete specification. The methods
+    # required by systems can and will change at any time. Any
+    # changes will be noted on release notes.**
+    class Base
+      class BaseError < Errors::VagrantError
+        error_namespace("vagrant.guest.base")
+      end
+
+      include Vagrant::Util
+
+      # The VM which this system is tied to.
+      attr_reader :vm
+
+      # Initializes the system. Any subclasses MUST make sure this
+      # method is called on the parent. Therefore, if a subclass overrides
+      # `initialize`, then you must call `super`.
+      def initialize(vm)
+        @vm = vm
+      end
+
+      # This method is automatically called when the system is available (when
+      # Vagrant can successfully SSH into the machine) to give the system a chance
+      # to determine the distro and return a distro-specific system.
+      #
+      # **Warning:** If a return value which subclasses from {Base} is
+      # returned, Vagrant will use it as the new system instance for the
+      # class.
+      def distro_dispatch; 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
+      # in a reasonable amount of time, this method should just return.
+      #
+      # If when this method returns, the machine's state isn't "powered_off,"
+      # Vagrant will proceed to forcefully shut the machine down.
+      def halt
+        raise BaseError, :_key => :unsupported_halt
+      end
+
+      # Mounts a shared folder.
+      #
+      # This method should create, mount, and properly set permissions
+      # on the shared folder. This method should also properly
+      # adhere to any configuration values such as `shared_folder_uid`
+      # on `config.vm`.
+      #
+      # @param [String] name The name of the shared folder.
+      # @param [String] guestpath The path on the machine which the user
+      #   wants the folder mounted.
+      # @param [Hash] options Additional options for the shared folder
+      #   which can be honored.
+      def mount_shared_folder(name, guestpath, options)
+        raise BaseError, :_key => :unsupported_shared_folder
+      end
+
+      # Mounts a shared folder via NFS. This assumes that the exports
+      # via the host are already done.
+      def mount_nfs(ip, folders)
+        raise BaseError, :_key => :unsupported_nfs
+      end
+
+      # Configures the given list of networks on the virtual machine.
+      #
+      # The networks parameter will be an array of hashes where the hashes
+      # represent the configuration of a network interface. The structure
+      # of the hash will be roughly the following:
+      #
+      # {
+      #   :type      => :static,
+      #   :ip        => "192.168.33.10",
+      #   :netmask   => "255.255.255.0",
+      #   :interface => 1
+      # }
+      #
+      def configure_networks(networks)
+        raise BaseError, :_key => :unsupported_configure_networks
+      end
+
+      # Called to change the hostname of the virtual machine.
+      def change_host_name(name)
+        raise BaseError, :_key => :unsupported_host_name
+      end
+    end
+  end
+end

data/lib/vagrant/guest/debian.rb

@@ -0,0 +1,64 @@
+require 'set'
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    class Debian < Linux
+      # Make the TemplateRenderer top-level
+      include Vagrant::Util
+
+      def configure_networks(networks)
+        # First, remove any previous network modifications
+        # from the interface file.
+        vm.channel.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces")
+        vm.channel.sudo("su -c 'cat /tmp/vagrant-network-interfaces > /etc/network/interfaces'")
+
+        # 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
+        entries = []
+        networks.each do |network|
+          interfaces.add(network[:interface])
+          entry = TemplateRenderer.render("guests/debian/network_#{network[:type]}",
+                                          :options => network)
+
+          entries << entry
+        end
+
+        # Perform the careful dance necessary to reconfigure
+        # the network interfaces
+        temp = Tempfile.new("vagrant")
+        temp.binmode
+        temp.write(entries.join("\n"))
+        temp.close
+
+        vm.channel.upload(temp.path, "/tmp/vagrant-network-entry")
+
+        # 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")
+        end
+
+        vm.channel.sudo("cat /tmp/vagrant-network-entry >> /etc/network/interfaces")
+
+        # Bring back up each network interface, reconfigured
+        interfaces.each do |interface|
+          vm.channel.sudo("/sbin/ifup eth#{interface}")
+        end
+      end
+
+      def change_host_name(name)
+        if !vm.channel.test("hostname --fqdn | grep '^#{name}$' || hostname --short | grep '^#{name}$'")
+          vm.channel.sudo("sed -r -i 's/^(127[.]0[.]1[.]1[[:space:]]+).*$/\\1#{name} #{name.split('.')[0]}/' /etc/hosts")
+          vm.channel.sudo("sed -i 's/.*$/#{name.split('.')[0]}/' /etc/hostname")
+          vm.channel.sudo("hostname -F /etc/hostname")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/guest/fedora.rb

@@ -0,0 +1,66 @@
+require 'set'
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    class Fedora < 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-p7p#{network[:interface]}")
+          vm.channel.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' #{network_scripts_dir}/ifcfg-p7p#{network[:interface]} > /tmp/vagrant-ifcfg-p7p#{network[:interface]}")
+          vm.channel.sudo("cat /tmp/vagrant-ifcfg-p7p#{network[:interface]} > #{network_scripts_dir}/ifcfg-p7p#{network[:interface]}")
+
+          # Render and upload the network entry file to a deterministic
+          # temporary location.
+          entry = TemplateRenderer.render("guests/fedora/network_#{network[:type]}",
+                                          :options => network)
+
+          temp = Tempfile.new("vagrant")
+          temp.binmode
+          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 p7p (the NAT interface) so
+        # SSH never dies.
+        interfaces.each do |interface|
+          vm.channel.sudo("/sbin/ifdown p7p#{interface} 2> /dev/null", :error_check => false)
+          vm.channel.sudo("cat /tmp/vagrant-network-entry_#{interface} >> #{network_scripts_dir}/ifcfg-p7p#{interface}")
+          vm.channel.sudo("/sbin/ifup p7p#{interface} 2> /dev/null")
+        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/freebsd.rb

@@ -0,0 +1,86 @@
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    # A general Vagrant system implementation for "freebsd".
+    #
+    # Contributed by Kenneth Vestergaard <kvs@binarysolutions.dk>
+    class FreeBSD < Base
+      # A custom config class which will be made accessible via `config.freebsd`
+      # 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 FreeBSDConfig < Vagrant::Config::Base
+        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 FreeBSDError < Errors::VagrantError
+        error_namespace("vagrant.guest.freebsd")
+      end
+
+      def halt
+        vm.channel.sudo("shutdown -p 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.freebsd.halt_timeout
+          sleep vm.config.freebsd.halt_check_interval
+        end
+      end
+
+      # TODO: vboxsf is currently unsupported in FreeBSD, if you are able to
+      # help out with this project, please contact vbox@FreeBSD.org
+      #
+      # See: http://wiki.freebsd.org/VirtualBox/ToDo
+      # def mount_shared_folder(ssh, name, guestpath)
+      #   ssh.exec!("sudo mkdir -p #{guestpath}")
+      #   # Using a custom mount method here; could use improvement.
+      #   ssh.exec!("sudo mount -t vboxfs v-root #{guestpath}")
+      #   ssh.exec!("sudo chown #{vm.config.ssh.username} #{guestpath}")
+      # end
+
+      def mount_nfs(ip, folders)
+        folders.each do |name, opts|
+          vm.channel.sudo("mkdir -p #{opts[:guestpath]}")
+          vm.channel.sudo("mount #{ip}:#{opts[:hostpath]} #{opts[:guestpath]}")
+        end
+      end
+
+      def configure_networks(networks)
+        # Remove any previous network additions to the configuration file.
+        vm.channel.sudo("sed -i '' -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/rc.conf")
+
+        networks.each do |network|
+          entry = TemplateRenderer.render("guests/freebsd/network_#{network[:type]}",
+                                          :options => network)
+          vm.channel.upload(StringIO.new(entry), "/tmp/vagrant-network-entry")
+          vm.channel.sudo("su -m root -c 'cat /tmp/vagrant-network-entry >> /etc/rc.conf'")
+          if network[:type].to_sym == :static
+            vm.channel.sudo("ifconfig em#{network[:interface]} inet #{network[:ip]} netmask #{network[:netmask]}")
+          elsif network[:type].to_sym == :dhcp
+            vm.channel.sudo("dhclient em#{network[:interface]}")
+          end
+        end
+      end
+
+     def change_host_name(name)
+       if !vm.channel.test("hostname -f | grep '^#{name}$' || hostname -s | grep '^#{name}$'")
+         vm.channel.sudo("sed -i '' 's/^hostname=.*$/hostname=#{name}/' /etc/rc.conf")
+         vm.channel.sudo("hostname #{name}")
+       end
+     end
+    end
+  end
+end

data/lib/vagrant/guest/gentoo.rb

@@ -0,0 +1,46 @@
+require 'tempfile'
+
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Guest
+    class Gentoo < Linux
+      # Make the TemplateRenderer top-level
+      include Vagrant::Util
+
+      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.binmode
+          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
+
+      def change_host_name(name)
+        if !vm.channel.test("sudo hostname --fqdn | grep '#{name}'")
+          vm.channel.sudo("echo 'hostname=#{name.split('.')[0]}' > /etc/conf.d/hostname")
+          vm.channel.sudo("sed -i 's@^\\(127[.]0[.]1[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
+          vm.channel.sudo("hostname #{name.split('.')[0]}")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/guest/linux.rb

@@ -0,0 +1,118 @@
+require 'log4r'
+
+require 'vagrant/guest/linux/error'
+require 'vagrant/guest/linux/config'
+
+module Vagrant
+  module Guest
+    class Linux < Base
+      def initialize(*args)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::guest::linux")
+      end
+
+      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 :fedora if @vm.channel.test("grep 'Fedora release 16' /etc/redhat-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)
+        real_guestpath = expanded_guest_path(guestpath)
+        @logger.debug("Shell expanded guest path: #{real_guestpath}")
+
+        @vm.channel.sudo("mkdir -p #{real_guestpath}")
+        mount_folder(name, real_guestpath, options)
+        @vm.channel.sudo("chown `id -u #{options[:owner]}`:`id -g #{options[:group]}` #{real_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|
+          # Expand the guestpath, so we can handle things like "~/vagrant"
+          real_guestpath = expanded_guest_path(opts[:guestpath])
+
+          # Do the actual creating and mounting
+          @vm.channel.sudo("mkdir -p #{real_guestpath}")
+          @vm.channel.sudo("mount -o vers=#{opts[:nfs_version]} #{ip}:'#{opts[:hostpath]}' #{real_guestpath}",
+                          :error_class => LinuxError,
+                          :error_key => :mount_nfs_fail)
+        end
+      end
+
+      protected
+
+      # Determine the real guest path. Since we use a `sudo` shell everywhere
+      # else, things like '~' don't expand properly in shared folders. We have
+      # to `echo` here to get that path.
+      #
+      # @param [String] guestpath The unexpanded guest path.
+      # @return [String] The expanded guestpath
+      def expanded_guest_path(guestpath)
+        real_guestpath = nil
+        @vm.channel.execute("printf #{guestpath}") do |type, data|
+          if type == :stdout
+            real_guestpath ||= ""
+            real_guestpath += data
+          end
+        end
+
+        if !real_guestpath
+          # Really strange error case if this happens. Let's throw an error,
+          # tell the user to check the echo output.
+          raise LinuxError, :_key => :guestpath_expand_fail
+        end
+
+        # Chomp the string so that any trailing newlines are killed
+        return real_guestpath.chomp
+      end
+
+      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