nixme-vagrant 0.7.2

data/lib/vagrant/systems.rb

@@ -0,0 +1,10 @@
+# These can't be autoloaded because they have to register functionality
+# with Vagrant core.
+require 'vagrant/systems/base'
+require 'vagrant/systems/freebsd'
+require 'vagrant/systems/linux'
+require 'vagrant/systems/solaris'
+
+require 'vagrant/systems/debian'
+require 'vagrant/systems/gentoo'
+require 'vagrant/systems/redhat'

data/lib/vagrant/systems/base.rb

@@ -0,0 +1,87 @@
+module Vagrant
+  module Systems
+    # 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.systems.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; end
+
+      # Mounts a shared folder. This method is called by the shared
+      # folder action with an open SSH session (passed in as `ssh`).
+      # 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); 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
+      end
+
+      # Setup the system by adding a new host only network. This
+      # method should configure and bring up the interface for the
+      # given options.
+      #
+      # @param [Hash] net_options The options for the network.
+      def enable_host_only_network(net_options); end
+
+      def change_host_name(name)
+        raise BaseError, :_key => :unsupported_host_name
+      end
+    end
+  end
+end

data/lib/vagrant/systems/debian.rb

@@ -0,0 +1,36 @@
+module Vagrant
+  module Systems
+    class Debian < Linux
+      def prepare_host_only_network(net_options=nil)
+        # Remove any previous host only network additions to the
+        # interface file.
+        vm.ssh.execute do |ssh|
+          # Clear out any previous entries
+          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-interfaces > /etc/network/interfaces'")
+        end
+      end
+
+      def enable_host_only_network(net_options)
+        entry = TemplateRenderer.render('network_entry_debian', :net_options => net_options)
+        vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
+
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo /sbin/ifdown eth#{net_options[:adapter]} 2> /dev/null")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-entry >> /etc/network/interfaces'")
+          ssh.exec!("sudo /sbin/ifup eth#{net_options[:adapter]}")
+        end
+      end
+
+      def change_host_name(name)
+        vm.ssh.execute do |ssh|
+          if !ssh.test?("sudo hostname | grep '#{name}'")
+            ssh.exec!("sudo sed -i 's/.*$/#{name}/' /etc/hostname")
+            ssh.exec!("sudo sed -i 's@^\\(127[.]0[.]1[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
+            ssh.exec!("sudo service hostname start")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/systems/freebsd.rb

@@ -0,0 +1,84 @@
+module Vagrant
+  module Systems
+    # 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
+        configures :freebsd
+
+        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.systems.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
+
+        # 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
+          count += 1
+
+          return if count >= vm.env.config.freebsd.halt_timeout
+          sleep vm.env.config.freebsd.halt_check_interval
+        end
+      end
+
+      # TODO: Error/warning about this.
+      # 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.env.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
+        end
+      end
+
+      def prepare_host_only_network(net_options=nil)
+        # Remove any previous host only network additions to the
+        # 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 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"
+        vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
+
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo su -m root -c 'cat /tmp/vagrant-network-entry >> /etc/rc.conf'")
+          ssh.exec!("sudo ifconfig em#{net_options[:adapter]} inet #{net_options[:ip]} netmask #{net_options[:netmask]}")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/systems/gentoo.rb

@@ -0,0 +1,27 @@
+module Vagrant
+  module Systems
+    class Gentoo < Linux
+      def prepare_host_only_network(net_options=nil)
+        # Remove any previous host only network additions to the
+        # interface file.
+        vm.ssh.execute do |ssh|
+          # Clear out any previous entries
+          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/conf.d/net > /tmp/vagrant-network-interfaces")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-interfaces > /etc/conf.d/net'")
+        end
+      end
+
+      def enable_host_only_network(net_options)
+        entry = TemplateRenderer.render('network_entry_gentoo', :net_options => net_options)
+        vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
+
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo ln -fs /etc/init.d/net.lo /etc/init.d/net.eth#{net_options[:adapter]}")
+          ssh.exec!("sudo /etc/init.d/net.eth#{net_options[:adapter]} stop 2> /dev/null")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-entry >> /etc/conf.d/net'")
+          ssh.exec!("sudo /etc/init.d/net.eth#{net_options[:adapter]} start")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/systems/linux.rb

@@ -0,0 +1,79 @@
+require 'vagrant/systems/linux/error'
+require 'vagrant/systems/linux/config'
+
+module Vagrant
+  module Systems
+    class Linux < Base
+      def distro_dispatch
+        vm.ssh.execute do |ssh|
+          return :debian if ssh.test?("cat /etc/debian_version")
+          return :gentoo if ssh.test?("cat /etc/gentoo-release")
+          return :redhat if ssh.test?("cat /etc/redhat-release")
+        end
+
+        # Can't detect the distro, assume vanilla linux
+        nil
+      end
+
+      def halt
+        vm.env.ui.info I18n.t("vagrant.systems.linux.attempting_halt")
+        vm.ssh.execute do |ssh|
+          ssh.exec!("sudo halt")
+        end
+
+        # 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
+          count += 1
+
+          return if count >= vm.env.config.linux.halt_timeout
+          sleep vm.env.config.linux.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(ssh, name, guestpath)
+        ssh.exec!("sudo mkdir -p #{guestpath}")
+        mount_folder(ssh, name, guestpath)
+        ssh.exec!("sudo chown #{vm.env.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]}", :_error_class => LinuxError, :_key => :mount_nfs_fail)
+          end
+        end
+      end
+
+      #-------------------------------------------------------------------
+      # "Private" methods which assist above methods
+      #-------------------------------------------------------------------
+      def mount_folder(ssh, name, guestpath, sleeptime=5)
+        # Determine the permission string to attach to the mount command
+        perms = []
+        perms << "uid=`id -u #{vm.env.config.vm.shared_folder_uid}`"
+        perms << "gid=`id -g #{vm.env.config.vm.shared_folder_gid}`"
+        perms = " -o #{perms.join(",")}" if !perms.empty?
+
+        attempts = 0
+        while true
+          result = ssh.exec!("sudo mount -t vboxsf#{perms} #{name} #{guestpath}") do |ch, type, data|
+            # net/ssh returns the value in ch[:result] (based on looking at source)
+            ch[:result] = !!(type == :stderr && data =~ /No such device/i)
+          end
+
+          break unless result
+
+          attempts += 1
+          raise LinuxError, :mount_fail if attempts >= 10
+          sleep sleeptime
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/systems/linux/config.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  module Systems
+    class Linux < Vagrant::Systems::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
+
+        def initialize
+          @halt_timeout = 30
+          @halt_check_interval = 1
+        end
+      end
+    end
+  end
+end

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

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

data/lib/vagrant/systems/redhat.rb

@@ -0,0 +1,39 @@
+module Vagrant
+  module Systems
+    class Redhat < Linux
+      def prepare_host_only_network(net_options)
+        # Remove any previous host only network additions to the
+        # interface file.
+        vm.ssh.execute do |ssh|
+          # Clear out any previous entries
+          ssh.exec!("sudo sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/sysconfig/network-scripts/ifcfg-eth#{net_options[:adapter]} > /tmp/vagrant-ifcfg-eth#{net_options[:adapter]}")
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-ifcfg-eth#{net_options[:adapter]} > /etc/sysconfig/network-scripts/ifcfg-eth#{net_options[:adapter]}'")
+        end
+      end
+
+      def enable_host_only_network(net_options)
+        entry = TemplateRenderer.render('network_entry_redhat', :net_options => net_options)
+
+        vm.ssh.upload!(StringIO.new(entry), "/tmp/vagrant-network-entry")
+
+        vm.ssh.execute do |ssh|
+          interface_up = ssh.test?("/sbin/ifconfig eth#{net_options[:adapter]} | grep 'inet addr:'")
+          ssh.exec!("sudo /sbin/ifdown eth#{net_options[:adapter]} 2> /dev/null") if interface_up
+          ssh.exec!("sudo su -c 'cat /tmp/vagrant-network-entry >> /etc/sysconfig/network-scripts/ifcfg-eth#{net_options[:adapter]}'")
+          ssh.exec!("sudo /sbin/ifup eth#{net_options[:adapter]}")
+        end
+      end
+
+      def change_host_name(name)
+        vm.ssh.execute do |ssh|
+          # Only do this if the hostname is not already set
+          if !ssh.test?("sudo hostname | grep '#{name}'")
+            ssh.exec!("sudo sed -i 's/\\(HOSTNAME=\\).*/\\1#{name}/' /etc/sysconfig/network")
+            ssh.exec!("sudo hostname #{name}")
+            ssh.exec!("sudo sed -i 's@^\\(127[.]0[.]0[.]1[[:space:]]\\+\\)@\\1#{name} @' /etc/hosts")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/systems/solaris.rb

@@ -0,0 +1,62 @@
+module Vagrant
+  module Systems
+    # 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
+        configures :solaris
+
+        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
+
+        def initialize
+          @halt_timeout = 30
+          @halt_check_interval = 1
+          @suexec_cmd = 'sudo'
+        end
+      end
+
+      # Here for whenever it may be used.
+      class SolarisError < Errors::VagrantError
+        error_namespace("vagrant.systems.solaris")
+      end
+
+      # There should be an exception raised if the line
+      #
+      #     vagrant::::profiles=Primary Administrator
+      #
+      # does not exist in /etc/user_attr. TODO
+      def halt
+        vm.env.ui.info I18n.t("vagrant.systems.solaris.attempting_halt")
+        vm.ssh.execute do |ssh|
+          ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /usr/sbin/poweroff")
+        end
+
+        # 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
+          count += 1
+
+          return if count >= vm.env.config.solaris.halt_timeout
+          sleep vm.env.config.solaris.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(ssh, name, guestpath)
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} mkdir -p #{guestpath}")
+        # Using a custom mount method here; could use improvement.
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /sbin/mount -F vboxfs #{name} #{guestpath}")
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} chown #{vm.env.config.ssh.username} #{guestpath}")
+      end
+    end
+  end
+end