vagrant-vbguest-update 0.10.1.dev

data/lib/vagrant-vbguest/installers/linux.rb

@@ -0,0 +1,158 @@
+module VagrantVbguest
+  module Installers
+    # A basic Installer implementation for vanilla or
+    # unknown Linux based systems.
+    class Linux < Base
+
+      # A helper method to cache the result of {Vagrant::Guest::Base#distro_dispatch}
+      # which speeds up Installer detection runs a lot,
+      # when having lots of Linux based Installer classes
+      # to check.
+      #
+      # @see {Vagrant::Guest::Linux#distro_dispatch}
+      # @return [Symbol] One of `:debian`, `:ubuntu`, `:gentoo`, `:fedora`, `:redhat`, `:suse`, `:arch`
+      def self.distro(vm)
+        @@ditro ||= {}
+        @@ditro[ vm_id(vm) ] ||= distro_name vm
+      end
+
+      # Matches if the operating system name prints "Linux"
+      # Raises an Error if this class is beeing subclassed but
+      # this method was not overridden. This is considered an
+      # error because, subclassed Installers usually indicate
+      # a more specific distributen like 'ubuntu' or 'arch' and
+      # therefore should do a more specific check.
+      def self.match?(vm)
+        raise Error, :_key => :do_not_inherit_match_method if self != Linux
+        communicate_to(vm).test("uname | grep 'Linux'")
+      end
+
+      # defaults the temp path to "/tmp/VBoxGuestAdditions.iso" for all Linux based systems
+      def tmp_path
+        '/tmp/VBoxGuestAdditions.iso'
+      end
+
+      # defaults the mount point to "/mnt" for all Linux based systems
+      def mount_point
+        '/mnt'
+      end
+
+      # a generic way of installing GuestAdditions assuming all
+      # dependencies on the guest are installed
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def install(opts=nil, &block)
+        env.ui.warn I18n.t("vagrant_vbguest.errors.installer.generic_linux_installer") if self.class == Linux
+        upload(iso_file)
+        mount_iso(opts, &block)
+        execute_installer(opts, &block)
+        unmount_iso(opts, &block)
+      end
+
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def running?(opts=nil, &block)
+        opts = {
+          :sudo => true
+        }.merge(opts || {})
+        communicate.test('lsmod | grep vboxsf', opts, &block)
+      end
+
+      # This overrides {VagrantVbguest::Installers::Base#guest_version}
+      # to also query the `VBoxService` on the host system (if available)
+      # for it's version.
+      # In some scenarios the results of the VirtualBox driver and the
+      # additions installed on the host may differ. If this happens, we
+      # assume, that the host binaries are right and yield a warning message.
+      #
+      # @return [String] The version code of the VirtualBox Guest Additions
+      #                  available on the guest, or `nil` if none installed.
+      def guest_version(reload = false)
+        return @guest_version if @guest_version && !reload
+        driver_version = super
+
+        communicate.sudo('VBoxService --version', :error_check => false) do |type, data|
+          if (v = data.to_s.match(/^(\d+\.\d+.\d+)/)) && driver_version != v[1]
+            @env.ui.warn(I18n.t("vagrant_vbguest.guest_version_reports_differ", :driver => driver_version, :service => v[1]))
+            @guest_version = v[1]
+          end
+        end
+        @guest_version
+      end
+
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def rebuild(opts=nil, &block)
+        communicate.sudo('/etc/init.d/vboxadd setup', opts, &block)
+      end
+
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def start(opts=nil, &block)
+        opts = {:error_check => false}.merge(opts || {})
+        communicate.sudo('/etc/init.d/vboxadd start', opts, &block)
+      end
+
+
+      # A generic helper method to execute the installer.
+      # This also yields a installation warning to the user, and an error
+      # warning in the event that the installer returns a non-zero exit status.
+      #
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def execute_installer(opts=nil, &block)
+        yield_installation_waring(installer)
+        opts = {:error_check => false}.merge(opts || {})
+        exit_status = communicate.sudo("#{installer} #{installer_arguments}", opts, &block)
+        yield_installation_error_warning(installer) unless exit_status == 0
+        exit_status
+      end
+
+      # The absolute path to the GuestAdditions installer script.
+      # The iso file has to be mounted on +mount_point+.
+      def installer
+        @installer ||= File.join(mount_point, 'VBoxLinuxAdditions.run')
+      end
+
+      # The arguments string, which gets passed to the installer script
+      def installer_arguments
+        @installer_arguments ||= Array(options[:installer_arguments]).join " "
+      end
+
+      # A generic helper method for mounting the GuestAdditions iso file
+      # on most linux system.
+      # Mounts the given uploaded file from +tmp_path+ on +mount_point+.
+      #
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def mount_iso(opts=nil, &block)
+        communicate.sudo("mount #{tmp_path} -o loop #{mount_point}", opts, &block)
+      end
+
+      # A generic helper method for un-mounting the GuestAdditions iso file
+      # on most linux system
+      # Unmounts the +mount_point+.
+      #
+      # @param [Hash] opts Optional options Hash wich meight get passed to {Vagrant::Communication::SSH#execute} and firends
+      # @yield [type, data] Takes a Block like {Vagrant::Communication::Base#execute} for realtime output of the command being executed
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      def unmount_iso(opts=nil, &block)
+        communicate.sudo("umount #{mount_point}", opts, &block)
+      end
+    end
+  end
+end
+VagrantVbguest::Installer.register(VagrantVbguest::Installers::Linux, 2)

data/lib/vagrant-vbguest/installers/redhat.rb

@@ -0,0 +1,29 @@
+module VagrantVbguest
+  module Installers
+    class RedHat < Linux
+      # Scientific Linux (and probably CentOS) both show up as :redhat
+      # fortunately they're probably both similar enough to RHEL
+      # (RedHat Enterprise Linux) not to matter.
+      def self.match?(vm)
+        :redhat == self.distro(vm)
+      end
+
+      # Install missing deps and yield up to regular linux installation
+      def install(opts=nil, &block)
+        communicate.sudo(install_dependencies_cmd, opts, &block)
+        super
+      end
+
+    protected
+      def install_dependencies_cmd
+        "yum install -y #{dependencies}"
+      end
+
+      def dependencies
+        packages = ['kernel-devel-`uname -r`', 'gcc', 'make', 'perl', 'bzip2']
+        packages.join ' '
+      end
+    end
+  end
+end
+VagrantVbguest::Installer.register(VagrantVbguest::Installers::RedHat, 5)

data/lib/vagrant-vbguest/installers/ubuntu.rb

@@ -0,0 +1,44 @@
+module VagrantVbguest
+  module Installers
+    class Ubuntu < Debian
+
+      def self.match?(vm)
+        :ubuntu == self.distro(vm)
+      end
+
+      def install(opts=nil, &block)
+        if packaged_additions?
+          unload_packaged_additions(opts, &block)
+          remove_packaged_additions(opts, &block)
+        end
+        super
+      end
+
+    protected
+
+      def packaged_additions?
+        communicate.test("dpkg --list | grep virtualbox-guest")
+      end
+
+      def remove_packaged_additions(opts=nil, &block)
+        options = (opts || {}).merge(:error_check => false)
+        command = "apt-get -y -q purge virtualbox-guest-dkms virtualbox-guest-utils virtualbox-guest-x11"
+        communicate.sudo(command, options, &block)
+      end
+
+      def unload_packaged_additions(opts=nil, &block)
+        commands = [
+          "service virtualbox-guest-utils stop",
+          "umount -a -t vboxsf",
+          "rmmod vboxsf",
+          "rmmod vboxguest"
+        ]
+        command = "(" + commands.join("; sleep 1; ") + ")"
+        options = (opts || {}).merge(:error_check => false)
+        communicate.sudo(command, options, &block)
+      end
+
+    end
+  end
+end
+VagrantVbguest::Installer.register(VagrantVbguest::Installers::Ubuntu, 5)

data/lib/vagrant-vbguest/machine.rb

@@ -0,0 +1,105 @@
+module VagrantVbguest
+  class Machine
+
+    require 'micromachine'
+
+    attr_reader :installer, :env, :vm, :options
+
+    def initialize vm, options
+      @vm       = vm
+      @env      = vm.env
+      @options  = options
+
+      @logger = Log4r::Logger.new("vagrant::plugins::vbguest-machine")
+      @logger.debug("initialize vbguest machine for VM '#{vm.name}' (#{vm.to_s})")
+
+      @installer = Installer.new vm, options
+    end
+
+    def run
+      current_state = state
+      runlist = steps(current_state)
+      @logger.debug("Runlist for state #{current_state} is: #{runlist}")
+      while (command = runlist.shift)
+        @logger.debug("Running command #{command} from runlist")
+        if !self.send(command)
+          env.ui.error('vagrant_vbguest.machine_loop_guard', :command => command, :state => current_state)
+          return false
+        end
+        return run if current_state != state
+      end
+      true
+    end
+
+    def install
+      return env.ui.warn(I18n.t("vagrant_vbguest.skipped_installation")) if options[:no_install] && !options[:force]
+      guest_additions_state.trigger :install
+    end
+
+    def rebuild
+      return env.ui.warn(I18n.t("vagrant_vbguest.skipped_rebuild")) if options[:no_install] && !options[:force]
+      guest_additions_state.trigger :rebuild
+    end
+
+    def start
+      guest_additions_state.trigger :start
+    end
+
+    def installation_ran?; guest_additions_state == :installed end
+    def started?; guest_additions_state == :started end
+    def rebuilt?; guest_additions_state == :rebuilt end
+
+    def reboot;  box_state.trigger :reboot end
+    def reboot?; box_state.state == :rebooted end
+
+    def steps(state)
+      case state
+      when :clean, :unmatched
+        [:install]
+      when :not_running
+        installation_ran? ? [:reboot] : [:start, :rebuild, :reboot]
+      else
+        []
+      end
+    end
+
+    def state
+      guest_version = installer.guest_version(true)
+      host_version  = installer.host_version
+      running = installer.running?
+      @logger.debug("Current states for VM '#{vm.name}' are : guest_version=#{guest_version} : host_version=#{host_version} : running=#{running}")
+
+      return :clean       if !guest_version
+      return :unmatched   if host_version != guest_version
+      return :not_running if !running
+      return :ok
+    end
+
+    def info
+      {
+        :host_version => installer.host_version,
+        :guest_version => installer.guest_version
+      }
+    end
+
+    protected
+
+      def guest_additions_state
+        @guest_additions_state ||= MicroMachine.new(:pending).tap { |m|
+          m.when :install, :pending => :installed
+          m.when :start,   :pending => :started
+          m.when :rebuild, :pending => :rebuilt, :started => :rebuilt
+
+          m.on(:installed) { installer.install }
+          m.on(:started)   { installer.start }
+          m.on(:rebuilt)   { installer.rebuild }
+        }
+      end
+
+      def box_state
+        @box_state ||= MicroMachine.new(:first_boot).tap { |m|
+          m.when :reboot, :first_boot => :rebooted
+        }
+      end
+  end
+end

data/lib/vagrant-vbguest/middleware.rb

@@ -0,0 +1,43 @@
+module VagrantVbguest
+
+  # A Vagrant middleware which checks the installed VirtualBox Guest
+  # Additions to match the installed VirtualBox installation on the
+  # host system.
+
+  class Middleware
+    include VagrantVbguest::Helpers::Rebootable
+
+    def initialize(app, env)
+      @app = app
+      @env = env
+    end
+
+    def call(env)
+      @env    = env
+      vm      = env[:vm] || env[:machine]
+
+      options = override_config(vm.config.vbguest.to_hash).freeze
+
+      if options[:auto_update]
+        machine = VagrantVbguest::Machine.new vm, options
+        status  = machine.state
+        vm.env.ui.send((:ok == status ? :success : :warn), I18n.t("vagrant_vbguest.status.#{status}", machine.info))
+        machine.run
+        reboot(vm, options) if machine.reboot?
+      end
+    rescue VagrantVbguest::Installer::NoInstallerFoundError => e
+      vm.env.ui.error e.message
+    ensure
+      @app.call(env)
+    end
+
+    def override_config(opts)
+      if opts[:auto_reboot] && Vagrant::VERSION.between?("1.1.0", "1.1.5") && Vagrant::VERSION != "1.1.4"
+        @env[:ui].warn I18n.t("vagrant_vbguest.vagrant_11_reload_issues")
+        opts.merge!({:auto_reboot => false})
+      end
+      opts
+    end
+
+  end
+end

data/lib/vagrant-vbguest/rebootable.rb

@@ -0,0 +1,39 @@
+module VagrantVbguest
+  module Helpers
+
+    module Rebootable
+      include VmCompatible
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      @@rebooted = {}
+
+      def rebooted?(vm)
+        !!@@rebooted[ self.class.vm_id(vm) ]
+      end
+
+      def reboot?(vm, options)
+        if rebooted?(vm)
+          vm.env.ui.error(I18n.t("vagrant_vbguest.restart_loop_guard_activated"))
+          false
+        elsif options[:auto_reboot]
+          vm.env.ui.warn(I18n.t("vagrant_vbguest.restart_vm"))
+          @@rebooted[ self.class.vm_id(vm) ] = true
+        else
+          vm.env.ui.warn(I18n.t("vagrant_vbguest.suggest_restart", :name => vm.name))
+          false
+        end
+      end
+
+      def reboot(vm, options)
+        raise NotImplementedError
+      end
+
+      def reboot!(vm, options)
+        raise NotImplementedError
+      end
+    end
+
+  end
+end

data/lib/vagrant-vbguest/vagrant_compat.rb

@@ -0,0 +1,21 @@
+vagrant_version = Gem::Version.new(Vagrant::VERSION)
+supported_version = {
+  "< 1.1.0"  => "1_0",
+  "~> 1.1.0" => "1_1",
+  "~> 1.2.0" => "1_2",
+  "~> 1.3.0" => "1_3",
+}
+compat_version = supported_version.find { |requirement, version|
+  Gem::Requirement.new(requirement).satisfied_by?(vagrant_version)
+}
+
+if compat_version
+  compat_version = compat_version[1]
+else
+  # @TODO: yield warning
+  compat_version = supported_version.to_a.last[1]
+end
+
+%w{vm_compatible rebootable command download}.each do |r|
+  require File.expand_path("../vagrant_compat/vagrant_#{compat_version}/#{r}", __FILE__)
+end

data/lib/vagrant-vbguest/vagrant_compat/vagrant_1_0/command.rb

@@ -0,0 +1,17 @@
+require 'vagrant-vbguest/command'
+require 'vagrant/command/start_mixins'
+
+module VagrantVbguest
+
+  class Command < Vagrant::Command::Base
+    include CommandCommons
+    include Vagrant::Command::StartMixins
+
+    def check_runable_on(vm)
+      raise Vagrant::Errors::VMNotCreatedError if !vm.created?
+      raise Vagrant::Errors::VMInaccessible if !vm.state == :inaccessible
+      raise Vagrant::Errors::VMNotRunningError if vm.state != :running
+    end
+  end
+
+end