vagrantup 0.8.10 → 0.9.0

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

@@ -1,32 +1,61 @@
+require "log4r"
+
 module Vagrant
-  class Action
+  module Action
     module VM
       class Provision
         def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::provision")
           @app = app
-          @env = env
-          @env["provision.enabled"] = true if !@env.has_key?("provision.enabled")
+
+          env["provision.enabled"] = true if !env.has_key?("provision.enabled")
         end
 
         def call(env)
-          # Instantiate and prepare the provisioners. Preparation must happen here
-          # so that shared folders and such can properly take effect.
-          provisioners = enabled_provisioners
-          provisioners.map { |p| p.prepare }
+          @env = env
+
+          provisioners = nil
+
+          # We set this here so that even if this value is changed in the future,
+          # it stays constant to what we expect here in this moment.
+          enabled = env["provision.enabled"]
+          if enabled
+            # Instantiate and prepare the provisioners. Preparation must happen here
+            # so that shared folders and such can properly take effect.
+            provisioners = enabled_provisioners
+            provisioners.map { |p| p.prepare }
+          end
 
           @app.call(env)
 
-          # Take prepared provisioners and run the provisioning
-          provisioners.each do |instance|
-            @env.ui.info I18n.t("vagrant.actions.vm.provision.beginning", :provisioner => instance.class)
-            instance.provision!
+          if enabled
+            # Take prepared provisioners and run the provisioning
+            provisioners.each do |instance|
+              @env[:ui].info I18n.t("vagrant.actions.vm.provision.beginning",
+                                    :provisioner => instance.class)
+              instance.provision!
+            end
           end
         end
 
         def enabled_provisioners
-          @env["config"].vm.provisioners.map do |provisioner|
-            provisioner.provisioner.new(@env, provisioner.config)
+          enabled = []
+          @env[:vm].config.vm.provisioners.each do |provisioner|
+            if @env["provision.types"]
+              # If we've specified types of provisioners to enable, then we
+              # only use those provisioners, and skip any that we haven't
+              # specified.
+              if !@env["provision.types"].include?(provisioner.shortcut.to_s)
+                @logger.debug("Skipping provisioner: #{provisioner.shortcut}")
+                next
+              end
+            end
+
+            enabled << provisioner.provisioner.new(@env, provisioner.config)
           end
+
+          # Return the enable provisioners
+          enabled
         end
       end
     end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class ProvisionerCleanup
         def initialize(app, env)
@@ -16,7 +16,7 @@ module Vagrant
         end
 
         def enabled_provisioners
-          @env["config"].vm.provisioners.map do |provisioner|
+          @env[:vm].config.vm.provisioners.map do |provisioner|
             provisioner.provisioner.new(@env, provisioner.config)
           end
         end

data/lib/vagrant/action/vm/{clear_nfs_exports.rb → prune_nfs_exports.rb}

@@ -1,17 +1,17 @@
-require File.expand_path("../nfs_helpers", __FILE__)
-
 module Vagrant
-  class Action
+  module Action
     module VM
-      class ClearNFSExports
-        include NFSHelpers
-
+      class PruneNFSExports
         def initialize(app, env)
           @app = app
         end
 
         def call(env)
-          clear_nfs_exports(env)
+          if env[:host]
+            valid_ids = env[:vm].driver.read_vms
+            env[:host].nfs_prune(valid_ids)
+          end
+
           @app.call(env)
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Resume
         def initialize(app, env)
@@ -7,9 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].vm.saved?
-            env.ui.info I18n.t("vagrant.actions.vm.resume.resuming")
-            env["actions"].run(Boot)
+          if env[:vm].state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
           end
 
           @app.call(env)

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

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module Vagrant
+  module Action
+    module VM
+      # Sets up the mapping of files to copy into the package and verifies
+      # that the files can be properly copied.
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Errors::PackageIncludeMissing, :file => from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,20 @@
+require 'pathname'
+
+require 'log4r'
+
 module Vagrant
-  class Action
+  module Action
     module VM
       class ShareFolders
         def initialize(app, env)
-          @app = app
-          @env = env
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
         end
 
         def call(env)
           @env = env
 
+          prepare_folders
           create_metadata
 
           @app.call(env)
@@ -20,7 +25,7 @@ module Vagrant
         # This method returns an actual list of VirtualBox shared
         # folders to create and their proper path.
         def shared_folders
-          @env.env.config.vm.shared_folders.inject({}) do |acc, data|
+          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
             key, value = data
 
             next acc if value[:disabled]
@@ -32,54 +37,73 @@ module Vagrant
           end
         end
 
-        def create_metadata
-          proc = lambda do |vm|
-            @env.ui.info I18n.t("vagrant.actions.vm.share_folders.creating")
-
-            shared_folders.each do |name, data|
-              folder = VirtualBox::SharedFolder.new
-              folder.name = name
-              folder.host_path = File.expand_path(data[:hostpath], @env.env.root_path)
-              vm.shared_folders << folder
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |name, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+              end
             end
           end
+        end
 
-          @env["vm.modify"].call(proc)
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |name, data|
+            folders << {
+              :name => name,
+              :hostpath => File.expand_path(data[:hostpath], @env[:root_path])
+            }
+          end
+
+          @env[:vm].driver.share_folders(folders)
         end
 
         def mount_shared_folders
-          @env.ui.info I18n.t("vagrant.actions.vm.share_folders.mounting")
-
-          @env["vm"].ssh.execute do |ssh|
-            # short guestpaths first, so we don't step on ourselves
-            folders = shared_folders.sort_by do |name, data|
-              if data[:guestpath]
-                data[:guestpath].length
-              else
-                # A long enough path to just do this at the end.
-                10000
-              end
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |name, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
             end
+          end
 
-            # Go through each folder and mount
-            folders.each do |name, data|
-              if data[:guestpath]
-                # Guest path specified, so mount the folder to specified point
-                @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+          # Go through each folder and mount
+          folders.each do |name, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
                                     :name => name,
                                     :guest_path => data[:guestpath]))
 
-                # Calculate the owner and group
-                owner = data[:owner] || @env["config"].ssh.username
-                group = data[:group] || @env["config"].ssh.username
+              # Dup the data so we can pass it to the guest API
+              data = data.dup
 
-                # Mount the actual folder
-                @env["vm"].system.mount_shared_folder(ssh, name, data[:guestpath], owner, group)
-              else
-                # If no guest path is specified, then automounting is disabled
-                @env.ui.info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+              # Calculate the owner and group
+              data[:owner] ||= @env[:vm].config.ssh.username
+              data[:group] ||= @env[:vm].config.ssh.username
+
+              # Mount the actual folder
+              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
                                     :name => name))
-              end
             end
           end
         end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Suspend
         def initialize(app, env)
@@ -7,9 +7,9 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"].vm.running?
-            env.ui.info I18n.t("vagrant.actions.vm.suspend.suspending")
-            env["vm"].vm.save_state
+          if env[:vm].state == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
+            env[:vm].driver.suspend
           end
 
           @app.call(env)

data/lib/vagrant/action/warden.rb

@@ -1,5 +1,7 @@
+require "log4r"
+
 module Vagrant
-  class Action
+  module Action
     # The action warden is a middleware which injects itself between
     # every other middleware, watching for exceptions which are raised
     # and performing proper cleanup on every action by calling the `recover`
@@ -16,6 +18,7 @@ module Vagrant
       def initialize(actions, env)
         @stack = []
         @actions = actions.map { |m| finalize_action(m, env) }
+        @logger  = Log4r::Logger.new("vagrant::action::warden")
       end
 
       def call(env)
@@ -24,17 +27,17 @@ module Vagrant
         begin
           # Call the next middleware in the sequence, appending to the stack
           # of "recoverable" middlewares in case something goes wrong!
-          raise Errors::VagrantInterrupt if env.interrupted?
+          raise Errors::VagrantInterrupt if env[:interrupted]
           action = @actions.shift
-          env["logger"].info("warden") { "Calling action: #{action}" }
+          @logger.info("Calling action: #{action}")
           @stack.unshift(action).first.call(env)
-          raise Errors::VagrantInterrupt if env.interrupted?
+          raise Errors::VagrantInterrupt if env[:interrupted]
         rescue SystemExit
           # This means that an "exit" or "abort" was called. In these cases,
           # we just exit immediately.
           raise
         rescue Exception => e
-          env["logger"].info("warden") { "Error occurred: #{e}" }
+          @logger.error("Error occurred: #{e}")
           env["vagrant.error"] = e
 
           # Something went horribly wrong. Start the rescue chain then
@@ -50,7 +53,7 @@ module Vagrant
       def begin_rescue(env)
         @stack.each do |act|
           if act.respond_to?(:recover)
-            env["logger"].info("warden") { "Calling recover: #{act}" }
+            @logger.info("Calling recover: #{act}")
             act.recover(env)
           end
         end
@@ -65,6 +68,10 @@ module Vagrant
       def finalize_action(action, env)
         klass, args, block = action
 
+        # Default the arguments to an empty array. Otherwise in Ruby 1.8
+        # a `nil` args will actually pass `nil` into the class.
+        args ||= []
+
         if klass.is_a?(Class)
           # A action klass which is to be instantiated with the
           # app, env, and any arguments given

data/lib/vagrant/action.rb

@@ -1,138 +1,60 @@
 require 'vagrant/action/builder'
 require 'vagrant/action/builtin'
 
-# The builtin middlewares
-require 'vagrant/action/box'
-require 'vagrant/action/env'
-require 'vagrant/action/general'
-require 'vagrant/action/vm'
-
 module Vagrant
-  # Manages action running and registration. Every Vagrant environment
-  # has an instance of {Action} to allow for running in the context of
-  # the environment, which is accessible at {Environment#actions}. Actions
-  # are the foundation of most functionality in Vagrant, and are implemented
-  # architecturally as "middleware."
-  #
-  # # Registering an Action
-  #
-  # The main benefits of registering an action is the ability to retrieve and
-  # modify that registered action, as well as easily run the action. An example
-  # of registering an action is shown below, with a simple middleware which just
-  # outputs to `STDOUT`:
-  #
-  #     class StdoutMiddleware
-  #       def initialize(app, env)
-  #         @app = app
-  #       end
-  #
-  #       def call(env)
-  #         puts "HI!"
-  #         @app.call(env)
-  #       end
-  #     end
-  #
-  #     Vagrant::Action.register(:stdout, StdoutMiddleware)
-  #
-  # Then to run a registered action, assuming `env` is a loaded {Environment}:
-  #
-  #     env.actions.run(:stdout)
-  #
-  # Or to retrieve the action class for any reason:
-  #
-  #     Vagrant::Action[:stdout]
-  #
-  # # Running an Action
-  #
-  # There are various built-in registered actions such as `start`, `stop`, `up`,
-  # etc. Actions are built to be run in the context of an environment, so use
-  # {Environment#actions} to run all actions. Then simply call {#run}:
-  #
-  #     env.actions.run(:name)
-  #
-  # Where `:name` is the name of the registered action.
-  #
-  class Action
+  module Action
     autoload :Environment, 'vagrant/action/environment'
+    autoload :Runner,      'vagrant/action/runner'
     autoload :Warden,      'vagrant/action/warden'
 
-    include Util
-    @@reported_interrupt = false
-
-    class << self
-      # Returns the list of registered actions.
-      #
-      # @return [Array]
-      def actions
-        @actions ||= {}
-      end
-
-      # Registers an action and associates it with a symbol. This
-      # symbol can then be referenced in other action builds and
-      # callbacks can be registered on that symbol.
-      #
-      # @param [Symbol] key
-      def register(key, callable)
-        actions[key.to_sym] = callable
-      end
-
-      # Retrieves a registered action by key.
-      #
-      # @param [Symbol] key
-      def [](key)
-        actions[key.to_sym]
-      end
+    module Box
+      autoload :Destroy,   'vagrant/action/box/destroy'
+      autoload :Download,  'vagrant/action/box/download'
+      autoload :Package,   'vagrant/action/box/package'
+      autoload :Unpackage, 'vagrant/action/box/unpackage'
+      autoload :Verify,    'vagrant/action/box/verify'
     end
 
-    # The environment to run the actions in.
-    attr_reader :env
-
-    # Initializes the action with the given environment which the actions
-    # will be run in.
-    #
-    # @param [Environment] env
-    def initialize(env)
-      @env = env
+    module Env
+      autoload :Set, 'vagrant/action/env/set'
     end
 
-    # Runs the given callable object in the context of the environment.
-    # If a symbol is given as the `callable` parameter, then it is looked
-    # up in the registered actions list which are registered with {register}.
-    #
-    # Any options given are injected into the environment hash.
-    #
-    # @param [Object] callable An object which responds to `call`.
-    def run(callable_id, options=nil)
-      callable = callable_id
-      callable = Builder.new.use(callable_id) if callable_id.kind_of?(Class)
-      callable = self.class.actions[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)
-
-      action_environment = Action::Environment.new(env)
-      action_environment.merge!(options || {})
-
-      # Run the before action run callback, if we're not doing that already
-      run(:before_action_run, action_environment) if callable_id != :before_action_run
-
-      # 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.
-      int_callback = lambda do
-        if action_environment.interrupted?
-          env.ui.error I18n.t("vagrant.actions.runner.exit_immediately")
-          abort
-        end
-
-        env.ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if !@@reported_interrupt
-        action_environment.interrupt!
-        @@reported_interrupt = true
-      end
+    module General
+      autoload :Package,  'vagrant/action/general/package'
+      autoload :Validate, 'vagrant/action/general/validate'
+    end
 
-      # We place a process lock around every action that is called
-      env.logger.info "Running action: #{callable_id}"
-      env.lock do
-        Busy.busy(int_callback) { callable.call(action_environment) }
-      end
+    module VM
+      autoload :Boot,                'vagrant/action/vm/boot'
+      autoload :CheckAccessible,     'vagrant/action/vm/check_accessible'
+      autoload :CheckBox,            'vagrant/action/vm/check_box'
+      autoload :CheckGuestAdditions, 'vagrant/action/vm/check_guest_additions'
+      autoload :CheckPortCollisions, 'vagrant/action/vm/check_port_collisions'
+      autoload :CleanMachineFolder,  'vagrant/action/vm/clean_machine_folder'
+      autoload :ClearForwardedPorts, 'vagrant/action/vm/clear_forwarded_ports'
+      autoload :ClearNetworkInterfaces, 'vagrant/action/vm/clear_network_interfaces'
+      autoload :ClearSharedFolders,  'vagrant/action/vm/clear_shared_folders'
+      autoload :Customize,           'vagrant/action/vm/customize'
+      autoload :Destroy,             'vagrant/action/vm/destroy'
+      autoload :DestroyUnusedNetworkInterfaces, 'vagrant/action/vm/destroy_unused_network_interfaces'
+      autoload :DiscardState,        'vagrant/action/vm/discard_state'
+      autoload :Export,              'vagrant/action/vm/export'
+      autoload :ForwardPorts,        'vagrant/action/vm/forward_ports'
+      autoload :Halt,                'vagrant/action/vm/halt'
+      autoload :HostName,            'vagrant/action/vm/host_name'
+      autoload :Import,              'vagrant/action/vm/import'
+      autoload :MatchMACAddress,     'vagrant/action/vm/match_mac_address'
+      autoload :Network,             'vagrant/action/vm/network'
+      autoload :NFS,                 'vagrant/action/vm/nfs'
+      autoload :Package,             'vagrant/action/vm/package'
+      autoload :PackageVagrantfile,  'vagrant/action/vm/package_vagrantfile'
+      autoload :Provision,           'vagrant/action/vm/provision'
+      autoload :ProvisionerCleanup,  'vagrant/action/vm/provisioner_cleanup'
+      autoload :PruneNFSExports,     'vagrant/action/vm/prune_nfs_exports'
+      autoload :Resume,              'vagrant/action/vm/resume'
+      autoload :ShareFolders,        'vagrant/action/vm/share_folders'
+      autoload :SetupPackageFiles,   'vagrant/action/vm/setup_package_files'
+      autoload :Suspend,             'vagrant/action/vm/suspend'
     end
   end
 end