vagrantup 0.8.10 → 0.9.0

data/lib/vagrant/action/builtin.rb

@@ -1,108 +1,146 @@
 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!
+  module Action
+    # Registers the builtin actions with a specific registry.
+    #
+    # These are the pre-built action sequences that are shipped with
+    # Vagrant itself.
+    def self.builtin!(registry)
       # provision - Provisions a running VM
-      register(:provision, Builder.new do
-        use VM::Provision
-      end)
+      registry.register(:provision) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::Provision
+        end
+      end
 
       # start - Starts a VM, assuming it already exists on the
       # environment.
-      register(:start, Builder.new do
-        use VM::CleanMachineFolder
-        use VM::ClearForwardedPorts
-        use VM::ForwardPorts
-        use VM::Provision
-        use VM::NFS
-        use VM::ClearSharedFolders
-        use VM::ShareFolders
-        use VM::HostName
-        use VM::Network
-        use VM::Customize
-        use VM::Modify
-        use VM::Boot
-      end)
+      registry.register(:start) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::CleanMachineFolder
+          use VM::ClearForwardedPorts
+          use VM::CheckPortCollisions, :port_collision_handler => :correct
+          use VM::ForwardPorts
+          use VM::Provision
+          use VM::PruneNFSExports
+          use VM::NFS
+          use VM::ClearSharedFolders
+          use VM::ShareFolders
+          use VM::HostName
+          use VM::ClearNetworkInterfaces
+          use VM::Network
+          use VM::Customize
+          use VM::Boot
+        end
+      end
 
       # halt - Halts the VM, attempting gracefully but then forcing
       # a restart if fails.
-      register(:halt, Builder.new do
-        use VM::DiscardState
-        use VM::Halt
-      end)
+      registry.register(:halt) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::DiscardState
+          use VM::Halt
+        end
+      end
 
       # suspend - Suspends the VM
-      register(:suspend, Builder.new do
-        use VM::Suspend
-      end)
+      registry.register(:suspend) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::Suspend
+        end
+      end
 
       # resume - Resume a VM
-      register(:resume, Builder.new do
-        use VM::Resume
-      end)
+      registry.register(:resume) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::CheckPortCollisions
+          use VM::Resume
+        end
+      end
 
       # reload - Halts then restarts the VM
-      register(:reload, Builder.new do
-        use Action[:halt]
-        use Action[:start]
-      end)
+      registry.register(:reload) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use registry.get(:halt)
+          use registry.get(:start)
+        end
+      end
 
       # up - Imports, prepares, then starts a fresh VM.
-      register(:up, Builder.new do
-        use VM::CheckBox
-        use VM::Import
-        use VM::MatchMACAddress
-        use VM::CheckGuestAdditions
-        use Action[:start]
-      end)
+      registry.register(:up) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use VM::CheckBox
+          use VM::Import
+          use VM::CheckGuestAdditions
+          use VM::MatchMACAddress
+          use registry.get(:start)
+        end
+      end
 
       # destroy - Halts, cleans up, and destroys an existing VM
-      register(:destroy, Builder.new do
-        use Action[:halt], :force => true
-        use VM::ProvisionerCleanup
-        use VM::ClearNFSExports
-        use VM::Destroy
-        use VM::CleanMachineFolder
-        use VM::DestroyUnusedNetworkInterfaces
-      end)
+      registry.register(:destroy) do
+        Builder.new do
+          use General::Validate
+          use VM::CheckAccessible
+          use registry.get(:halt), :force => true
+          use VM::ProvisionerCleanup
+          use VM::PruneNFSExports
+          use VM::Destroy
+          use VM::CleanMachineFolder
+          use VM::DestroyUnusedNetworkInterfaces
+        end
+      end
 
       # package - Export and package the VM
-      register(:package, Builder.new do
-        use Action[:halt]
-        use VM::ClearForwardedPorts
-        use VM::ClearSharedFolders
-        use VM::Modify
-        use VM::Export
-        use VM::PackageVagrantfile
-        use VM::Package
-      end)
+      registry.register(:package) do
+        Builder.new do
+          use General::Validate
+          use VM::SetupPackageFiles
+          use VM::CheckAccessible
+          use registry.get(:halt)
+          use VM::ClearForwardedPorts
+          use VM::ClearSharedFolders
+          use VM::Export
+          use VM::PackageVagrantfile
+          use VM::Package
+        end
+      end
 
       # box_add - Download and add a box.
-      register(:box_add, Builder.new do
-        use Box::Download
-        use Box::Unpackage
-        use Box::Verify
-      end)
+      registry.register(:box_add) do
+        Builder.new do
+          use Box::Download
+          use Box::Unpackage
+          use Box::Verify
+        end
+      end
 
       # box_remove - Removes/deletes a box.
-      register(:box_remove, Builder.new do
-        use Box::Destroy
-      end)
+      registry.register(:box_remove) do
+        Builder.new do
+          use Box::Destroy
+        end
+      end
 
       # box_repackage - Repackages a box.
-      register(:box_repackage, Builder.new do
-        use Box::Package
-      end)
-
-      # Other callbacks. There will be more of these in the future. For
-      # now, these are limited to what are needed internally.
-      register(:before_action_run, Builder.new do
-        use General::Validate
-        use VM::CheckAccessible
-      end)
+      registry.register(:box_repackage) do
+        Builder.new do
+          use Box::Package
+        end
+      end
     end
   end
 end

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

@@ -1,15 +1,18 @@
 module Vagrant
-  class Action
+  module 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 || {})
+        def initialize(app, env, options=nil)
+          @app     = app
+          @options = options || {}
         end
 
         def call(env)
+          # Merge the options that were given to us
+          env.merge!(@options)
+
           @app.call(env)
         end
       end

data/lib/vagrant/action/environment.rb

@@ -1,50 +1,12 @@
+require 'vagrant/util/hash_with_indifferent_access'
+
 module Vagrant
-  class Action
+  module 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 < Util::HashWithIndifferentAccess
-      # The {Vagrant::Environment} object represented by this
-      # action environment.
-      attr_reader :env
-
-      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
-        @interrupted = false
-      end
-
-      # Returns a UI object from the environment
-      def ui
-        env.ui
-      end
-
-      # Marks an environment as interrupted (by an outside signal or
-      # anything). This will trigger any middleware sequences using this
-      # environment to halt. This is automatically set by {Action} when
-      # a SIGINT is captured.
-      def interrupt!
-        @interrupted = true
-      end
-
-      # Returns a boolean denoting if environment has been interrupted
-      # with a SIGINT.
-      #
-      # @return [Bool]
-      def interrupted?
-        !!@interrupted
-      end
     end
   end
 end

data/lib/vagrant/action/general/package.rb

@@ -2,7 +2,7 @@ require 'fileutils'
 require 'archive/tar/minitar'
 
 module Vagrant
-  class Action
+  module Action
     module General
       # A general packaging (tar) middleware. Given the following options,
       # it will do the right thing:
@@ -19,19 +19,18 @@ module Vagrant
 
         def initialize(app, env)
           @app = app
-          @env = env
-          @env["package.output"] ||= env["config"].package.name
-          @env["package.include"] ||= []
-          @env["package.vagrantfile"] ||= nil
+
+          env["package.files"]  ||= {}
+          env["package.output"] ||= env["global_config"].package.name
         end
 
         def call(env)
           @env = env
 
           raise Errors::PackageOutputExists if File.exist?(tar_path)
-          raise Errors::PackageRequiresDirectory if !@env["package.directory"] || !File.directory?(@env["package.directory"])
+          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
+            !File.directory?(env["package.directory"])
 
-          verify_files_to_copy
           compress
 
           @app.call(env)
@@ -46,31 +45,17 @@ module Vagrant
 					end
         end
 
-        def files_to_copy
-          package_dir = Pathname.new(@env["package.directory"]).join("include")
-
-          files = @env["package.include"].inject({}) do |acc, file|
-            source = Pathname.new(file)
-            acc[file] = source.relative? ? package_dir.join(source) : package_dir.join(source.basename)
-            acc
-          end
-
-          files[@env["package.vagrantfile"]] = package_dir.join("_Vagrantfile") if @env["package.vagrantfile"]
-          files
-        end
-
-        def verify_files_to_copy
-          files_to_copy.each do |file, _|
-            raise Errors::PackageIncludeMissing, :file => file if !File.exist?(file)
-          end
-        end
-
         # This method copies the include files (passed in via command line)
         # to the temporary directory so they are included in a sub-folder within
         # the actual box
         def copy_include_files
-          files_to_copy.each do |from, to|
-            @env.ui.info I18n.t("vagrant.actions.general.package.packaging", :file => from)
+          include_directory = Pathname.new(@env["package.directory"]).join("include")
+
+          @env["package.files"].each do |from, dest|
+            # We place the file in the include directory
+            to = include_directory.join(dest)
+
+            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", :file => from)
             FileUtils.mkdir_p(to.parent)
 
             # Copy direcotry contents recursively.
@@ -84,7 +69,7 @@ module Vagrant
 
         # Compress the exported file into a package
         def compress
-          @env.ui.info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
+          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
           File.open(tar_path, Platform.tar_file_options) do |tar|
             Archive::Tar::Minitar::Output.open(tar) do |output|
               begin

data/lib/vagrant/action/general/validate.rb

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module General
       # Simply validates the configuration of the current Vagrant
       # environment.
@@ -10,7 +10,7 @@ module Vagrant
         end
 
         def call(env)
-          @env["config"].validate! if !@env.has_key?("validate") || @env["validate"]
+          @env[:vm].config.validate!(@env[:vm].env) if !@env.has_key?("validate") || @env["validate"]
           @app.call(@env)
         end
       end

data/lib/vagrant/action/runner.rb

@@ -0,0 +1,53 @@
+require 'log4r'
+
+require 'vagrant/util/busy'
+
+# TODO:
+# * env.lock
+
+module Vagrant
+  module Action
+    class Runner
+      @@reported_interrupt = false
+
+      def initialize(registry, globals=nil, &block)
+        @registry     = registry
+        @globals      = globals || {}
+        @lazy_globals = block
+        @logger       = Log4r::Logger.new("vagrant::action::runner")
+      end
+
+      def run(callable_id, options=nil)
+        callable = callable_id
+        callable = Builder.new.use(callable_id) if callable_id.kind_of?(Class)
+        callable = @registry.get(callable_id) if callable_id.kind_of?(Symbol)
+        raise ArgumentError, "Argument to run must be a callable object or registered action." if !callable || !callable.respond_to?(:call)
+
+        # Create the initial environment with the options given
+        environment = Environment.new
+        environment.merge!(@globals)
+        environment.merge!(@lazy_globals.call) if @lazy_globals
+        environment.merge!(options || {})
+
+        # Run the action chain in a busy block, marking the environment as
+        # interrupted if a SIGINT occurs, and exiting cleanly once the
+        # chain has been run.
+        ui = environment[:ui] if environment.has_key?(:ui)
+        int_callback = lambda do
+          if environment[:interrupted]
+            ui.error I18n.t("vagrant.actions.runner.exit_immediately") if ui
+            abort
+          end
+
+          ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if ui && !@@reported_interrupt
+          environment[:interrupted] = true
+          @@reported_interrupt = true
+        end
+
+        # We place a process lock around every action that is called
+        @logger.info("Running action: #{callable_id}")
+        Util::Busy.busy(int_callback) { callable.call(environment) }
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Boot
         def initialize(app, env)
@@ -18,27 +18,27 @@ module Vagrant
         end
 
         def boot
-          @env.ui.info I18n.t("vagrant.actions.vm.boot.booting")
-          @env["vm"].vm.start(@env.env.config.vm.boot_mode)
+          @env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
+          @env[:vm].driver.start(@env[:vm].config.vm.boot_mode)
         end
 
         def wait_for_boot
-          @env.ui.info I18n.t("vagrant.actions.vm.boot.waiting")
+          @env[:ui].info I18n.t("vagrant.actions.vm.boot.waiting")
 
-          @env["config"].ssh.max_tries.to_i.times do |i|
-            if @env["vm"].ssh.up?
-              @env.ui.info I18n.t("vagrant.actions.vm.boot.ready")
+          @env[:vm].config.ssh.max_tries.to_i.times do |i|
+            if @env[:vm].channel.ready?
+              @env[:ui].info I18n.t("vagrant.actions.vm.boot.ready")
               return true
             end
 
             # Return true so that the vm_failed_to_boot error doesn't
             # get shown
-            return true if @env.interrupted?
+            return true if @env[:interrupted]
 
             sleep 2 if !@env["vagrant.test"]
           end
 
-          @env.ui.error I18n.t("vagrant.actions.vm.boot.failed")
+          @env[:ui].error I18n.t("vagrant.actions.vm.boot.failed")
           false
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class CheckAccessible
         def initialize(app, env)
@@ -7,7 +7,7 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"] && env["vm"].created? && !env["vm"].vm.accessible?
+          if env[:vm].state == :inaccessible
             # The VM we are attempting to manipulate is inaccessible. This
             # is a very bad situation and can only be fixed by the user. It
             # also prohibits us from actually doing anything with the virtual

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class CheckBox
         def initialize(app, env)
@@ -7,24 +7,22 @@ module Vagrant
         end
 
         def call(env)
-          box_name = env["config"].vm.box
+          box_name = env[:vm].config.vm.box
           raise Errors::BoxNotSpecified if !box_name
 
-          if !env.env.boxes.find(box_name)
-            box_url = env["config"].vm.box_url
+          if !env[:box_collection].find(box_name)
+            box_url = env[:vm].config.vm.box_url
             raise Errors::BoxSpecifiedDoesntExist, :name => box_name if !box_url
 
             # Add the box then reload the box collection so that it becomes
             # aware of it.
-            env.ui.info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
-            Vagrant::Box.add(env.env, box_name, box_url)
-            env["boxes"].reload!
+            env[:ui].info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
+            env[:box_collection].add(box_name, box_url)
+            env[:box_collection].reload!
 
-            # Reload the configuration for all our VMs, since this box
-            # may be used for other VMs.
-            env.env.vms.each do |name, vm|
-              vm.env.reload_config!
-            end
+            # Reload the environment and set the VM to be the new loaded VM.
+            env[:vm].env.reload!
+            env[:vm] = env[:vm].env.vms[env[:vm].name]
           end
 
           @app.call(env)

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module 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
@@ -12,20 +12,20 @@ module Vagrant
         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.ui.warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
+          version = env[:vm].driver.read_guest_additions_version
+          if !version
+            env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
           else
             # Strip the -OSE/_OSE off from the guest additions and the virtual box
             # version since all the matters are that the version _numbers_ match up.
-            guest_version, vb_version = [version, VirtualBox.version].map do |v|
+            guest_version, vb_version = [version, env[:vm].driver.version].map do |v|
               v.gsub(/[-_]ose/i, '')
             end
 
             if guest_version != vb_version
-              env.ui.warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
-                                 :guest_version => version,
-                                 :virtualbox_version => VirtualBox.version))
+              env[:ui].warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
+                                   :guest_version => version,
+                                   :virtualbox_version => vb_version))
             end
           end