vagrantup 0.4.3.dev → 0.5.0

data/lib/vagrant/action/builtin.rb

@@ -0,0 +1,114 @@
+module Vagrant
+  class Action
+    # Registers the builtin actions. These are locked away in a
+    # method so that their definition can be deferred until after
+    # all the necessary Vagrant libraries are loaded. Hopefully
+    # in the future this will no longer be necessary with autoloading.
+    def self.builtin!
+      # provision - Provisions a running VM
+      provision = Builder.new do
+        use VM::Provision
+      end
+
+      register :provision, provision
+
+      # start - Starts a VM, assuming it already exists on the
+      # environment.
+      start = Builder.new do
+        use VM::CleanMachineFolder
+        use VM::Customize
+        use VM::ClearForwardedPorts
+        use VM::ForwardPorts
+        use VM::Provision
+        use VM::NFS
+        use VM::ClearSharedFolders
+        use VM::ShareFolders
+        use VM::Network
+        use VM::Boot
+      end
+
+      register :start, start
+
+      # halt - Halts the VM, attempting gracefully but then forcing
+      # a restart if fails.
+      halt = Builder.new do
+        use VM::Halt
+        use VM::DisableNetworks
+      end
+
+      register :halt, halt
+
+      # suspend - Suspends the VM
+      suspend = Builder.new do
+        use VM::Suspend
+      end
+
+      register :suspend, suspend
+
+      # resume - Resume a VM
+      resume = Builder.new do
+        use VM::Resume
+      end
+
+      register :resume, resume
+
+      # reload - Halts then restarts the VM
+      reload = Builder.new do
+        use Action[:halt]
+        use Action[:start]
+      end
+
+      register :reload, reload
+
+      # up - Imports, prepares, then starts a fresh VM.
+      up = Builder.new do
+        use VM::CheckBox
+        use VM::Import
+        use VM::Persist
+        use VM::MatchMACAddress
+        use VM::CheckGuestAdditions
+        use Action[:start]
+      end
+
+      register :up, up
+
+      # destroy - Halts, cleans up, and destroys an existing VM
+      destroy = Builder.new do
+        use Action[:halt], :force => true
+        use VM::ClearNFSExports
+        use VM::DestroyUnusedNetworkInterfaces
+        use VM::Destroy
+        use VM::CleanMachineFolder
+      end
+
+      register :destroy, destroy
+
+      # package - Export and package the VM
+      package = Builder.new do
+        use Action[:halt]
+        use VM::ClearForwardedPorts
+        use VM::ClearSharedFolders
+        use VM::Export
+        use VM::Package
+      end
+
+      register :package, package
+
+      # box_add - Download and add a box.
+      box_add = Builder.new do
+        use Box::Download
+        use Box::Unpackage
+        use Box::Verify
+      end
+
+      register :box_add, box_add
+
+      # box_remove - Removes/deletes a box.
+      box_remove = Builder.new do
+        use Box::Destroy
+      end
+
+      register :box_remove, box_remove
+    end
+  end
+end

data/lib/vagrant/action/env/error_halt.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  class Action
+    module Env
+      # A middleware which simply halts if the environment is erroneous.
+      class ErrorHalt
+        def initialize(app,env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env) if !env.error?
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/env/set.rb

@@ -0,0 +1,18 @@
+module Vagrant
+  class Action
+    module Env
+      # A middleware which just sets up the environment with some
+      # options which are passed to it.
+      class Set
+        def initialize(app,env,options=nil)
+          @app = app
+          env.merge!(options || {})
+        end
+
+        def call(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/environment.rb

@@ -0,0 +1,98 @@
+module Vagrant
+  class Action
+    # Represents an action environment which is what is passed
+    # to the `call` method of each action. This environment contains
+    # some helper methods for accessing the environment as well
+    # as being a hash, to store any additional options.
+    class Environment < Hash
+      # The {Vagrant::Environment} object represented by this
+      # action environment.
+      attr_reader :env
+
+      # If nonnil, the error associated with this environment. Set
+      # using {#error!}
+      attr_reader :error
+
+      def initialize(env)
+        super() do |h,k|
+          # By default, try to find the key as a method on the
+          # environment. Gross eval use here.
+          begin
+            value = eval("h.env.#{k}")
+            h[k] = value
+          rescue Exception
+            nil
+          end
+        end
+
+        @env = env
+        @error = nil
+      end
+
+      # Returns a logger associated with the environment.
+      def logger
+        env.logger
+      end
+
+      # Flags the environment as erroneous. Stores the given key
+      # and options until the end of the action sequence.
+      #
+      # @param [Symbol] key Key to translation to display error message.
+      # @param [Hash] options Variables to pass to the translation
+      def error!(key, options=nil)
+        @error = [key, (options || {})]
+      end
+
+      # Returns boolean denoting if environment is in erroneous state.
+      #
+      # @return [Boolean]
+      def error?
+        !error.nil?
+      end
+
+      # Returns a boolean denoting if environment has been interrupted
+      # with a SIGINT.
+      def interrupted?
+        error? && error.first == :interrupt
+      end
+
+      #-----------------------------------------------------------------
+      # Hash with indifferent access
+      #-----------------------------------------------------------------
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def has_key?(key)
+        super(convert_key(key))
+      end
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+    end
+  end
+end

data/lib/vagrant/action/exception_catcher.rb

@@ -0,0 +1,14 @@
+module Vagrant
+  class Action
+    # A helper to catch any ActionExceptions raised and to
+    # apply the error to the environment.
+    module ExceptionCatcher
+      def catch_action_exception(env)
+        yield env
+      rescue ActionException => e
+        env.error!(e.key, e.data)
+        false
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/boot.rb

@@ -0,0 +1,54 @@
+module Vagrant
+  class Action
+    module VM
+      class Boot
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          # Do nothing if the environment is erroneous
+          return if env.error?
+
+          @env = env
+
+          # Start up the VM and wait for it to boot.
+          boot
+          return env.error!(:vm_failed_to_boot) if !wait_for_boot
+          return if env.error?
+
+          @app.call(env)
+        end
+
+        def boot
+          @env.logger.info "Booting VM..."
+          @env["vm"].vm.start(@env.env.config.vm.boot_mode)
+        end
+
+        def wait_for_boot
+          @env.logger.info "Waiting for VM to boot..."
+
+          @env.env.config.ssh.max_tries.to_i.times do |i|
+            @env.logger.info "Trying to connect (attempt ##{i+1} of #{@env.env.config[:ssh][:max_tries]})..."
+
+            if @env["vm"].ssh.up?
+              @env.logger.info "VM booted and ready for use!"
+              return true
+            end
+
+            # Return true so that the vm_failed_to_boot error doesn't
+            # get shown
+            return true if @env.interrupted?
+
+            sleep 5 if !@env["vagrant.test"]
+          end
+
+          @env.logger.info "Failed to connect to VM! Failed to boot?"
+          false
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/action/vm/check_box.rb

@@ -0,0 +1,27 @@
+module Vagrant
+  class Action
+    module VM
+      class CheckBox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          box_name = env["config"].vm.box
+          return env.error!(:box_not_specified) if !box_name
+
+          if !Vagrant::Box.find(env.env , box_name)
+            box_url = env["config"].vm.box_url
+            return env.error!(:box_specified_doesnt_exist, :box_name => box_name) if !box_url
+
+            env.logger.info "Box #{box_name} not found. Fetching box since URL specified..."
+            Vagrant::Box.add(env.env, box_name, box_url)
+            env.env.load_box!
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/check_guest_additions.rb

@@ -0,0 +1,32 @@
+module Vagrant
+  class Action
+    module VM
+      # Middleware which verifies that the VM has the proper guest additions
+      # installed and prints a warning if they're not detected or if the
+      # version does not match the installed VirtualBox version.
+      class CheckGuestAdditions
+        include Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Use the raw interface for now, while the virtualbox gem
+          # doesn't support guest properties (due to cross platform issues)
+          version = env["vm"].vm.interface.get_guest_property_value("/VirtualBox/GuestAdd/Version")
+          if version.empty?
+            env.logger.error Translator.t(:vm_additions_not_detected)
+          elsif version != VirtualBox.version
+            env.logger.error Translator.t(:vm_additions_version_mismatch,
+                                          :guest_additions_version => version,
+                                          :virtualbox_version => VirtualBox.version)
+          end
+
+          # Continue
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/clean_machine_folder.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+module Vagrant
+  class Action
+    module VM
+      # Cleans up the VirtualBox machine folder for any ".xml-prev"
+      # files which VirtualBox may have left over. This is a bug in
+      # VirtualBox. As soon as this is fixed, this middleware can and
+      # will be removed.
+      class CleanMachineFolder
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          clean_machine_folder
+          @app.call(env)
+        end
+
+        def clean_machine_folder
+          folder = File.join(VirtualBox::Global.global.system_properties.default_machine_folder, "*")
+
+          # Small safeguard against potentially unwanted rm-rf, since the default
+          # machine folder will typically always be greater than 10 characters long.
+          # For users with it < 10, out of luck?
+          return if folder.length < 10
+
+          Dir[folder].each do |f|
+            next unless File.directory?(f)
+
+            keep = Dir["#{f}/**/*"].find do |d|
+              # Find a file that doesn't have ".xml-prev" as the suffix,
+              # which signals that we want to keep this folder
+              File.file?(d) && !(File.basename(d) =~ /\.xml-prev$/)
+            end
+
+            FileUtils.rm_rf(f) if !keep
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/clear_forwarded_ports.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), 'forward_ports_helpers')
+
+module Vagrant
+  class Action
+    module VM
+      class ClearForwardedPorts
+        include ForwardPortsHelpers
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+          clear
+          @app.call(env)
+        end
+
+        def clear
+          if used_ports.length > 0
+            @env.logger.info "Deleting any previously set forwarded ports..."
+            clear_ports
+            @env["vm"].reload!
+          end
+        end
+
+        # Deletes existing forwarded ports.
+        def clear_ports
+          @env["vm"].vm.network_adapters.each do |na|
+            na.nat_driver.forwarded_ports.dup.each do |fp|
+              fp.destroy
+            end
+          end
+        end
+      end
+    end
+  end
+end