vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/errors.rb

@@ -118,14 +118,19 @@ module Vagrant
       error_key(:does_not_exist, "vagrant.actions.vm.check_box")
     end
 
+    class BoxUnpackageFailure < VagrantError
+      status_code(57)
+      error_key(:untar_failure, "vagrant.actions.box.unpackage")
+    end
+
     class BoxVerificationFailed < VagrantError
       status_code(15)
       error_key(:failed, "vagrant.actions.box.verify")
     end
 
-    class CLIMissingEnvironment < VagrantError
+    class CLIInvalidOptions < VagrantError
       status_code(1)
-      error_key(:cli_missing_env)
+      error_key(:cli_invalid_options)
     end
 
     class ConfigValidationFailed < VagrantError
@@ -133,6 +138,11 @@ module Vagrant
       error_key(:config_validation)
     end
 
+    class DeprecationError < VagrantError
+      status_code(60)
+      error_key(:deprecation)
+    end
+
     class DotfileIsDirectory < VagrantError
       status_code(46)
       error_key(:dotfile_is_directory)
@@ -163,6 +173,11 @@ module Vagrant
       error_key(:home_dir_migration_failed)
     end
 
+    class HomeDirectoryNotAccessible < VagrantError
+      status_code(55)
+      error_key(:home_dir_not_accessible)
+    end
+
     class ForwardPortAutolistEmpty < VagrantError
       status_code(27)
       error_key(:auto_empty, "vagrant.actions.vm.forward_ports")
@@ -173,6 +188,11 @@ module Vagrant
       error_key(:collision_error, "vagrant.actions.vm.forward_ports")
     end
 
+    class ForwardPortCollisionResume < VagrantError
+      status_code(62)
+      error_key(:port_collision_resume)
+    end
+
     class MultiVMEnvironmentRequired < VagrantError
       status_code(5)
       error_key(:multi_vm_required)
@@ -183,21 +203,29 @@ module Vagrant
       error_key(:multi_vm_target_required)
     end
 
+    class NetworkAdapterCollision < VagrantError
+      status_code(65)
+      error_key(:adapter_collision, "vagrant.actions.vm.network")
+    end
+
     class NetworkCollision < VagrantError
       status_code(29)
-      error_key(:collides, "vagrant.actions.vm.network")
+      error_key(:collides, "vagrant.actions.vm.host_only_network")
     end
 
-    class NetworkNotFound < VagrantError
-      status_code(30)
-      error_key(:not_found, "vagrant.actions.vm.network")
+    class NetworkNoAdapters < VagrantError
+      status_code(64)
+      error_key(:no_adapters, "vagrant.actions.vm.network")
     end
 
-    # Note: This is a temporary error for Windows users while host-only
-    # networking doesn't quite work.
-    class NetworkNotImplemented < VagrantError
-      status_code(49)
-      error_key(:windows_not_implemented, "vagrant.actions.vm.network")
+    class NetworkDHCPAlreadyAttached < VagrantError
+      status_code(68)
+      error_key(:dhcp_already_attached, "vagrant.actions.vm.network")
+    end
+
+    class NetworkNotFound < VagrantError
+      status_code(30)
+      error_key(:not_found, "vagrant.actions.vm.host_only_network")
     end
 
     class NFSHostRequired < VagrantError
@@ -240,6 +268,16 @@ module Vagrant
       error_key(:dotfile_error, "vagrant.actions.vm.persist")
     end
 
+    class SCPUnavailable < VagrantError
+      status_code(56)
+      error_key(:scp_unavailable)
+    end
+
+    class SharedFolderCreateFailed < VagrantError
+      status_code(66)
+      error_key(:shared_folder_create_failed)
+    end
+
     class SSHAuthenticationFailed < VagrantError
       status_code(11)
       error_key(:ssh_authentication_failed)
@@ -275,11 +313,21 @@ module Vagrant
       error_key(:interrupted)
     end
 
+    class VagrantfileExistsError < VagrantError
+      status_code(58)
+      error_key(:vagrantfile_exists)
+    end
+
     class VagrantfileSyntaxError < VagrantError
       status_code(41)
       error_key(:vagrantfile_syntax_error)
     end
 
+    class VBoxManageError < VagrantError
+      status_code(59)
+      error_key(:vboxmanage_error)
+    end
+
     class VirtualBoxInvalidVersion < VagrantError
       status_code(17)
       error_key(:virtualbox_invalid_version)
@@ -290,25 +338,26 @@ module Vagrant
       error_key(:virtualbox_not_detected)
     end
 
-    # Note that this is a subclass of VirtualBoxNotDetected, so developers
-    # who script Vagrant or use it as a library in any way can rescue from
-    # "VirtualBoxNotDetected" and catch both errors, which represent the
-    # same thing. This subclass simply has a specialized error message.
-    class VirtualBoxNotDetected_Win64 < VirtualBoxNotDetected
-      status_code(48)
-      error_key(:virtualbox_not_detected_win64)
-    end
-
     class VMBaseMacNotSpecified < VagrantError
       status_code(47)
       error_key(:no_base_mac, "vagrant.actions.vm.match_mac")
     end
 
+    class VMCustomizationFailed < VagrantError
+      status_code(61)
+      error_key(:failure, "vagrant.actions.vm.customize")
+    end
+
     class VMFailedToBoot < VagrantError
       status_code(21)
       error_key(:failed_to_boot, "vagrant.actions.vm.boot")
     end
 
+    class VMGuestError < VagrantError
+      status_code(39)
+      error_namespace("vagrant.errors.guest")
+    end
+
     class VMImportFailure < VagrantError
       status_code(28)
       error_key(:failure, "vagrant.actions.vm.import")
@@ -319,6 +368,11 @@ module Vagrant
       error_key(:vm_inaccessible)
     end
 
+    class VMNoMatchError < VagrantError
+      status_code(63)
+      error_key(:vm_no_match)
+    end
+
     class VMNotCreatedError < VagrantError
       status_code(6)
       error_key(:vm_creation_required)
@@ -338,10 +392,5 @@ module Vagrant
       status_code(24)
       error_key(:power_off, "vagrant.actions.vm.export")
     end
-
-    class VMSystemError < VagrantError
-      status_code(39)
-      error_namespace("vagrant.errors.system")
-    end
   end
 end

data/lib/vagrant/guest/arch.rb

@@ -0,0 +1,48 @@
+require 'set'
+require 'tempfile'
+
+module Vagrant
+  module Guest
+    class Arch < Linux
+      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])
+          entries << TemplateRenderer.render("guests/arch/network_#{network[:type]}",
+                                             :options => network)
+        end
+
+        # Perform the careful dance necessary to reconfigure
+        # the network interfaces
+        temp = Tempfile.new("vagrant")
+        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/{systems → guest}/base.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  module Systems
+  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
@@ -16,7 +16,7 @@ module Vagrant
     # changes will be noted on release notes.**
     class Base
       class BaseError < Errors::VagrantError
-        error_namespace("vagrant.systems.base")
+        error_namespace("vagrant.guest.base")
       end
 
       include Vagrant::Util
@@ -47,38 +47,50 @@ module Vagrant
       #
       # If when this method returns, the machine's state isn't "powered_off,"
       # Vagrant will proceed to forcefully shut the machine down.
-      def halt; end
+      def halt
+        raise BaseError, :_key => :unsupported_halt
+      end
 
-      # Mounts a shared folder. This method is called by the shared
-      # folder action with an open SSH session (passed in as `ssh`).
+      # 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 [Object] ssh The Net::SSH session.
       # @param [String] name The name of the shared folder.
       # @param [String] guestpath The path on the machine which the user
       #   wants the folder mounted.
-      def mount_shared_folder(ssh, name, guestpath, owner, group); end
+      # @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); 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(net_options=nil)
-        raise BaseError, :_key => :unsupported_host_only
+      def mount_nfs(ip, folders)
+        raise BaseError, :_key => :unsupported_nfs
       end
 
-      # Setup the system by adding a new host only network. This
-      # method should configure and bring up the interface for the
-      # given options.
+      # Configures the given list of networks on the virtual machine.
       #
-      # @param [Hash] net_options The options for the network.
-      def enable_host_only_network(net_options); end
+      # 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        => "33.33.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

data/lib/vagrant/guest/debian.rb

@@ -0,0 +1,61 @@
+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])
+          entries << TemplateRenderer.render("guests/debian/network_#{network[:type]}",
+                                             :options => network)
+        end
+
+        # Perform the careful dance necessary to reconfigure
+        # the network interfaces
+        temp = Tempfile.new("vagrant")
+        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/{systems → guest}/freebsd.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  module Systems
+  module Guest
     # A general Vagrant system implementation for "freebsd".
     #
     # Contributed by Kenneth Vestergaard <kvs@binarysolutions.dk>
@@ -9,8 +9,6 @@ module Vagrant
       # generally, Vagrant tries to make almost every aspect of its execution
       # configurable, and this assists that goal.
       class FreeBSDConfig < Vagrant::Config::Base
-        configures :freebsd
-
         attr_accessor :halt_timeout
         attr_accessor :halt_check_interval
 
@@ -22,24 +20,21 @@ module Vagrant
 
       # Here for whenever it may be used.
       class FreeBSDError < Errors::VagrantError
-        error_namespace("vagrant.systems.freebsd")
+        error_namespace("vagrant.guest.freebsd")
       end
 
       def halt
-        vm.env.ui.info I18n.t("vagrant.systems.freebsd.attempting_halt")
-        vm.ssh.execute do |ssh|
-          ssh.exec!("sudo shutdown -p now")
-        end
+        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.vm.state != :powered_off
+        while vm.state != :poweroff
           count += 1
 
-          return if count >= vm.env.config.freebsd.halt_timeout
-          sleep vm.env.config.freebsd.halt_check_interval
+          return if count >= vm.config.freebsd.halt_timeout
+          sleep vm.config.freebsd.halt_check_interval
         end
       end
 
@@ -48,15 +43,13 @@ module Vagrant
       #   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.env.config.ssh.username} #{guestpath}")
+      #   ssh.exec!("sudo chown #{vm.config.ssh.username} #{guestpath}")
       # end
 
       def mount_nfs(ip, folders)
         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
+          vm.channel.sudo("mkdir -p #{opts[:guestpath]}")
+          vm.channel.sudo("mount #{ip}:#{opts[:hostpath]} #{opts[:guestpath]}")
         end
       end
 
@@ -65,13 +58,13 @@ module Vagrant
         # interface file.
         vm.ssh.execute do |ssh|
           # Clear out any previous entries
-          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/rc.conf > /tmp/rc.conf")
+          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN-HOSTONLY/,/^#VAGRANT-END-HOSTONLY/ d' /etc/rc.conf > /tmp/rc.conf")
           ssh.exec!("sudo mv /tmp/rc.conf /etc/rc.conf")
         end
       end
 
       def enable_host_only_network(net_options)
-        entry = "#VAGRANT-BEGIN\nifconfig_em#{net_options[:adapter]}=\"inet #{net_options[:ip]} netmask #{net_options[:netmask]}\"\n#VAGRANT-END\n"
+        entry = "#VAGRANT-BEGIN-HOSTONLY\nifconfig_em#{net_options[:adapter]}=\"inet #{net_options[:ip]} netmask #{net_options[:netmask]}\"\n#VAGRANT-END-HOSTONLY\n"
         vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
 
         vm.ssh.execute do |ssh|

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