vagrant-vbguest-update 0.10.1.dev

data/lib/vagrant-vbguest/hosts/virtualbox.rb

@@ -0,0 +1,103 @@
+module VagrantVbguest
+  module Hosts
+    class VirtualBox < Base
+
+      protected
+
+        # Default web URI, where GuestAdditions iso file can be downloaded.
+        #
+        # @return [String] A URI template containing the versions placeholder.
+        def web_path
+          "http://download.virtualbox.org/virtualbox/%{version}/VBoxGuestAdditions_%{version}.iso"
+        end
+
+
+        # Finds GuestAdditions iso file on the host system.
+        # Returns +nil+ if none found.
+        #
+        # @return [String] Absolute path to the local GuestAdditions iso file, or +nil+ if not found.
+        def local_path
+          media_manager_iso || guess_local_iso
+        end
+
+        # Kicks off +VagrantVbguest::Download+ to download the additions file
+        # into a temp file.
+        #
+        # To remove the created tempfile call +cleanup+
+        #
+        # @param [String] The path or URI to download
+        #
+        # @return [String] The path to the downloaded file
+        def download(path)
+          temp_path = File.join(@env.tmp_path, "VBoxGuestAdditions_#{version}.iso")
+          @download = VagrantVbguest::Download.new(path, temp_path, :ui => @env.ui)
+          @download.download!
+          @download.destination
+        end
+
+      private
+
+        # Helper method which queries the VirtualBox media manager
+        # for the first existing path that looks like a
+        # +VBoxGuestAdditions.iso+ file.
+        #
+        # @return [String] Absolute path to the local GuestAdditions iso file, or +nil+ if not found.
+        def media_manager_iso
+          driver.execute('list', 'dvds').scan(/^.+:\s+(.*VBoxGuestAdditions(?:_#{version})?\.iso)$/i).map { |path, _|
+            path if File.exist?(path)
+          }.compact.first
+        end
+
+        # Find the first GuestAdditions iso file which exists on the host system
+        #
+        # @return [String] Absolute path to the local GuestAdditions iso file, or +nil+ if not found.
+        def guess_local_iso
+          Array(platform_path).find do |path|
+            path && File.exists?(path)
+          end
+        end
+
+        # Makes an educated guess where the GuestAdditions iso file
+        # could be found on the host system depending on the OS.
+        # Returns +nil+ if no the file is not in it's place.
+        def platform_path
+          [:linux, :darwin, :cygwin, :windows].each do |sys|
+            return self.send("#{sys}_path") if Vagrant::Util::Platform.respond_to?("#{sys}?") && Vagrant::Util::Platform.send("#{sys}?")
+          end
+          nil
+        end
+
+        # Makes an educated guess where the GuestAdditions iso file
+        # on linux based systems
+        def linux_path
+          paths = ["/usr/share/virtualbox/VBoxGuestAdditions.iso"]
+          paths.unshift(File.join(ENV['HOME'], '.VirtualBox', "VBoxGuestAdditions_#{version}.iso")) if ENV['HOME']
+          paths
+        end
+
+        # Makes an educated guess where the GuestAdditions iso file
+        # on Macs
+        def darwin_path
+          "/Applications/VirtualBox.app/Contents/MacOS/VBoxGuestAdditions.iso"
+        end
+
+        # Makes an educated guess where the GuestAdditions iso file
+        # on windows systems
+        def windows_path
+          if (p = ENV["VBOX_INSTALL_PATH"]) && !p.empty?
+            File.join(p, "VBoxGuestAdditions.iso")
+          elsif (p = ENV["PROGRAM_FILES"] || ENV["ProgramW6432"] || ENV["PROGRAMFILES"]) && !p.empty?
+            File.join(p, "/Oracle/VirtualBox/VBoxGuestAdditions.iso")
+          end
+        end
+        alias_method :cygwin_path, :windows_path
+
+        # overwrite the default version string to allow lagacy
+        # '$VBOX_VERSION' as a placerholder
+        def versionize(path)
+          super(path.gsub('$VBOX_VERSION', version))
+        end
+
+    end
+  end
+end

data/lib/vagrant-vbguest/installer.rb

@@ -0,0 +1,121 @@
+module VagrantVbguest
+
+  ##
+  # Dispatches the installation process to a rigistered
+  # Installer implementation.
+  class Installer
+
+    class NoInstallerFoundError < Vagrant::Errors::VagrantError
+      error_namespace "vagrant_vbguest.errors.installer"
+      error_key "no_installer_for_platform"
+    end
+
+    class << self
+
+      ##
+      # Register an Installer implementation.
+      # All Installer classes which wish to get picked automaticly
+      # using their `#match?` method have to register.
+      # Ad-hoc or small custom Installer meight not need to get
+      # registered, but need to get passed as an config option (`installer`)
+      #
+      # Registration takes a priority which defines how specific
+      # the Installer matches a system. Low level installers, like
+      # "linux" or "bsd" use a small priority (2), while distribution
+      # installers use higher priority (5). Installers matching a
+      # specific version of a distribution should use heigher
+      # priority numbers.
+      #
+      # @param [Class] installer_class A reference to the Installer class.
+      # @param [Fixnum] prio Priority describing how specific the Installer matches. (default: `5`)
+      def register(installer_class, prio = 5)
+        @installers ||= {}
+        @installers[prio] ||= []
+        @installers[prio] << installer_class
+      end
+
+      ##
+      # Returns the class of the registrated Installer class which
+      # matches first (according to it's priority) or `nil` if none matches.
+      def detect(vm, options)
+        @installers.keys.sort.reverse.each do |prio|
+          klass = @installers[prio].detect { |k| k.match?(vm) }
+          return klass if klass
+        end
+        return nil
+      end
+    end
+
+    def initialize(vm, options = {})
+      @vm = vm
+      @env = vm.env
+      @options = options
+      @iso_path = nil
+    end
+
+    def install
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'install' if !installer
+
+      installer.install do |type, data|
+        @env.ui.info(data, :prefix => false, :new_line => false)
+      end
+    ensure
+      cleanup
+    end
+
+    def rebuild
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'rebuild' if !installer
+
+      installer.rebuild do |type, data|
+        @env.ui.info(data, :prefix => false, :new_line => false)
+      end
+    end
+
+    def start
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'manual start' if !installer
+
+      installer.start do |type, data|
+        @env.ui.info(data, :prefix => false, :new_line => false)
+      end
+    end
+
+    def guest_version(reload=false)
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'check guest version of' if !installer
+      installer.guest_version(reload)
+    end
+
+    def host_version
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'check host version of' if !installer
+      installer.host.version
+    end
+
+    def running?
+      installer = guest_installer
+      raise NoInstallerFoundError, :method => 'check current state of' if !installer
+      installer.running?
+    end
+
+    # Returns an installer instance for the current vm
+    # This is either the one configured via `installer` option or
+    # detected from all registered installers (see {Installer.detect})
+    #
+    # @return [Installers::Base]
+    def guest_installer
+      @guest_installer ||= if @options[:installer].is_a? Class
+        @options[:installer].new(@vm, @options)
+      else
+        installer_klass = Installer.detect(@vm, @options) and installer_klass.new(@vm, @options)
+      end
+    end
+
+    def cleanup
+      @guest_installer.cleanup if @guest_installer
+    end
+
+  end
+end

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

@@ -0,0 +1,201 @@
+module VagrantVbguest
+  module Installers
+    class Error < Vagrant::Errors::VagrantError
+      error_namespace "vagrant_vbguest.errors.installer"
+    end
+
+    # This is the base class all installers must inherit from
+    # It defines the basic structure of an Installer and should
+    # never be used directly
+    class Base
+      include VagrantVbguest::Helpers::VmCompatible
+
+      # Tests whether this installer class is applicable to the
+      # current environment. Usually, testing for a specific OS.
+      # Subclasses must override this method and return `true` if
+      # they wish to handle.
+      #
+      # This method will be called only when an Installer detection
+      # is run. It is ignored, when passing an Installer class
+      # directly as an config (`installer`) option.
+      #
+      # @param [Vagrant::VM]
+      # @return [Boolean]
+      def self.match?(vm)
+        false
+      end
+
+      attr_reader :env, :vm, :options, :host
+
+      def initialize(vm, options=nil)
+        @vm = vm
+        @env = vm.env
+        @options = options
+
+        @host = VagrantVbguest::Hosts::VirtualBox.new(vm, options)
+      end
+
+      # The absolute file path of the GuestAdditions iso file should
+      # be uploaded into the guest.
+      # Subclasses must override this method!
+      #
+      # @return [String]
+      def tmp_path
+      end
+
+      # The mountpoint path
+      # Subclasses shall override this method, if they need to mount the uploaded file!
+      #
+      # @return [String]
+      def mount_point
+      end
+
+      # Handles the installation process.
+      # All necessary steps for an installation must be defined here.
+      # This includes uploading the iso into the box, mounting,
+      # installing and cleaning up.
+      # The path to the local iso file should be obtained by calling +iso_file+
+      # Subclasses must override this method!
+      #
+      # @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)
+      end
+
+      # Handels the rebuild of allready running GuestAdditions
+      # It may happen, that the guest has the correct GuestAdditions
+      # version running, but not the kernel module is not running.
+      # This method should perform a rebuild or try to reload the
+      # kernel module _without_ the GuestAdditions iso file.
+      # If there is no way of rebuidling or reloading the
+      # GuestAdditions on a specific system, this method should left
+      # empty.
+      # Subclasses should override this method.
+      #
+      # @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)
+      end
+
+      # Restarts the allready installed GuestAdditions
+      # It may happen, that the guest has the correct GuestAdditions
+      # version installed, but for some reason are not (yet) runnig.
+      # This method should execute the GuestAdditions system specific
+      # init script in order to start it manually.
+      # If there is no way of doing this on a specific system,
+      # this method should left empty.
+      # Subclasses should override this method.
+      #
+      # @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)
+      end
+
+      # Determinates if the GuestAdditions kernel module is loaded.
+      # This method tests if there is a working GuestAdditions
+      # kernel module. If there is none, {#rebuild} is beeing called.
+      # If there is no way of telling if there is a working
+      # GuestAddition for a specific system, this method should
+      # return `true`.
+      # Subclasses should override this method.
+      #
+      # @return [Boolean] `true` if the kernel module is loaded (and thus seems to work), `false` otherwise.
+      def running?(opts=nil, &block)
+        true
+      end
+
+      # Determinates the GuestAdditions version installed on the
+      # guest system.
+      #
+      # @param [Boolean] reload Whether to read the value again or use
+      #                  the cached value form an erlier call.
+      # @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
+
+        guest_version = driver.read_guest_additions_version
+        guest_version = !guest_version ? nil : guest_version.gsub(/[-_]ose/i, '')
+
+        @guest_version = guest_version
+      end
+
+
+      # Determinates the version of the GuestAdditions installer in use
+      #
+      # @return [String] The version code of the GuestAdditions installer
+      def installer_version(path_to_installer)
+        version = nil
+        communicate.sudo("#{path_to_installer} --info", :error_check => false) do |type, data|
+          if (v = data.to_s.match(/\AIdentification.*\s(\d+\.\d+.\d+)/i))
+            version = v[1]
+          end
+        end
+        version
+      end
+
+      # Helper to yield a warning message to the user, that the installation
+      # will start _now_.
+      # The message includes the host and installer version strings.
+      def yield_installation_waring(path_to_installer)
+        @env.ui.warn I18n.t("vagrant_vbguest.installing#{@options[:force] ? '_forced' : ''}",
+          :guest_version => guest_version,
+          :installer_version => installer_version(path_to_installer) || I18n.t("vagrant_vbguest.unknown"))
+      end
+
+      # Helper to yield a warning message to the user, that the installation
+      # will be rebuild using the installed GuestAdditions.
+      # The message includes the host and installer version strings.
+      def yield_rebuild_warning
+        @env.ui.warn I18n.t("vagrant_vbguest.rebuild#{@options[:force] ? '_forced' : ''}",
+          :guest_version => guest_version(true),
+          :host_version => @host.version)
+      end
+
+      # Helper to yield a warning message to the user in the event that the
+      # installer returned a non-zero exit status. Because lack of a window
+      # system will cause this result in VirtualBox 4.2.8+, we don't want to
+      # kill the entire boot process, but we do want to make sure the user
+      # knows there could be a problem. The message includles the installer
+      # version.
+      def yield_installation_error_warning(path_to_installer)
+        @env.ui.warn I18n.t("vagrant_vbguest.install_error",
+          :installer_version => installer_version(path_to_installer) || I18n.t("vagrant_vbguest.unknown"))
+      end
+
+      def iso_file
+        @host.additions_file
+      end
+      alias_method :additions_file, :iso_file
+
+      # A helper method to handle the GuestAdditions iso file upload
+      # into the guest box.
+      # The file will uploaded to the location given by the +temp_path+ method.
+      #
+      # @example Default upload
+      #    upload(file)
+      #
+      # @param [String] Path of the file to upload to the +tmp_path*
+      def upload(file)
+        env.ui.info(I18n.t("vagrant_vbguest.start_copy_iso", :from => file, :to => tmp_path))
+        communicate.upload(file, tmp_path)
+      end
+
+      # A helper method to delete the uploaded GuestAdditions iso file
+      # from the guest box
+      def cleanup
+        @host.cleanup
+        communicate.execute("test -f #{tmp_path} && rm #{tmp_path}", :error_check => false) do |type, data|
+          env.ui.error(data.chomp, :prefix => false)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module VagrantVbguest
+  module Installers
+    class Debian < Linux
+
+      def self.match?(vm)
+        :debian == self.distro(vm)
+      end
+
+      # installes the correct linux-headers package
+      # installes `dkms` package for dynamic kernel module loading
+      # @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)
+        begin
+          communicate.sudo(install_dependencies_cmd, opts, &block)
+        rescue
+          communicate.sudo('apt-get update', opts, &block)
+          communicate.sudo(install_dependencies_cmd, opts, &block)
+        end
+        super
+      end
+
+    protected
+      def install_dependencies_cmd
+        "apt-get install -y #{dependencies}"
+      end
+
+      def dependencies
+        packages = ['linux-headers-`uname -r`']
+        # some Debian system (lenny) dont come with a dkms packe so we neet to skip that.
+        # apt-cache search will exit with 0 even if nothing was found, so we need to grep.
+        packages << 'dkms' if communicate.test('apt-cache search --names-only \'^dkms$\' | grep dkms')
+        packages.join ' '
+      end
+    end
+  end
+end
+VagrantVbguest::Installer.register(VagrantVbguest::Installers::Debian, 5)