vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/action/builtin/set_hostname.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware sets the hostname of the guest according to the
+      # "vm.hostname" configuration parameter if it is set. This middleware
+      # should be placed such that the after the @app.call, a booted machine
+      # is available (this generally means BEFORE the boot middleware).
+      class SetHostname
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          hostname = env[:machine].config.vm.hostname
+          if !hostname.nil?
+            env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
+            env[:machine].guest.change_host_name(hostname)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_exec.rb

@@ -0,0 +1,42 @@
+require "pathname"
+
+require "vagrant/util/ssh"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will exec into a full fledged SSH console into the
+      # remote machine. This middleware assumes that the VM is running and
+      # ready for SSH, and uses the {Machine#ssh_info} method to retrieve
+      # SSH information necessary to connect.
+      #
+      # Note: If there are any middleware after `SSHExec`, they will **not**
+      # run, since exec replaces the currently running process.
+      class SSHExec
+        # For quick access to the `SSH` class.
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Grab the SSH info from the machine
+          info = env[:machine].ssh_info
+
+          # If the result is nil, then the machine is telling us that it is
+          # not yet ready for SSH, so we raise this exception.
+          raise Errors::SSHNotReady if info.nil?
+
+          if info[:private_key_path]
+            # Check the SSH key permissions
+            SSH.check_key_permissions(Pathname.new(info[:private_key_path]))
+          end
+
+          # Exec!
+          SSH.exec(info, env[:ssh_opts])
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_run.rb

@@ -0,0 +1,43 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run a single command on the remote machine and will
+      # mirror the output to the UI. The resulting exit status of the command
+      # will exist in the `:ssh_run_exit_status` key in the environment.
+      class SSHRun
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::ssh_run")
+        end
+
+        def call(env)
+          command = env[:ssh_run_command]
+
+          @logger.debug("Executing command: #{command}")
+          exit_status = 0
+          exit_status = env[:machine].communicate.execute(command, :error_check => false) do |type, data|
+            # Determine the proper channel to send the output onto depending
+            # on the type of data we are receiving.
+            channel = type == :stdout ? :out : :error
+
+            # Print the output as it comes in, but don't prefix it and don't
+            # force a new line so that the output is properly preserved however
+            # it may be formatted.
+            env[:ui].info(data.to_s,
+                          :prefix => false,
+                          :new_line => false,
+                          :channel => channel)
+          end
+
+          # Set the exit status on a known environmental variable
+          env[:ssh_run_exit_status] = exit_status
+
+          # Call the next middleware
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require 'fileutils'
-require 'archive/tar/minitar'
+
+require 'vagrant/util/subprocess'
 
 module Vagrant
   module Action
@@ -63,9 +64,9 @@ module Vagrant
 
             # Copy direcotry contents recursively.
             if File.directory?(from)
-              FileUtils.cp_r(Dir.glob(from), to.parent)
+              FileUtils.cp_r(Dir.glob(from), to.parent, :preserve => true)
             else
-              FileUtils.cp(from, to)
+              FileUtils.cp(from, to, :preserve => true)
             end
           end
         end
@@ -73,21 +74,21 @@ 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)
-          File.open(tar_path, Platform.tar_file_options) do |tar|
-            Archive::Tar::Minitar::Output.open(tar) do |output|
-              begin
-                current_dir = FileUtils.pwd
-
-                copy_include_files
-
-                FileUtils.cd(@env["package.directory"])
-                Dir.glob(File.join(".", "**", "*")).each do |entry|
-                  Archive::Tar::Minitar.pack_file(entry, output)
-                end
-              ensure
-                FileUtils.cd(current_dir)
-              end
-            end
+
+          # Copy over the included files
+          copy_include_files
+
+          # Get the output path. We have to do this up here so that the
+          # pwd returns the proper thing.
+          output_path = tar_path.to_s
+
+          # Switch into that directory and package everything up
+          Dir.chdir(@env["package.directory"]) do
+            # Find all the files in our current directory and tar it up!
+            files = Dir.glob(File.join(".", "**", "*"))
+
+            # Package!
+            Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
           end
         end
 

data/lib/vagrant/action/hook.rb

@@ -0,0 +1,103 @@
+module Vagrant
+  module Action
+    # This class manages hooks into existing {Builder} stacks, and lets you
+    # add and remove middleware classes. This is the primary method by which
+    # plugins can hook into built-in middleware stacks.
+    class Hook
+      # This is a hash of the middleware to prepend to a certain
+      # other middleware.
+      #
+      # @return [Hash<Class, Array<Class>>]
+      attr_reader :before_hooks
+
+      # This is a hash of the middleware to append to a certain other
+      # middleware.
+      #
+      # @return [Hash<Class, Array<Class>>]
+      attr_reader :after_hooks
+
+      # This is a list of the hooks to just prepend to the beginning
+      #
+      # @return [Array<Class>]
+      attr_reader :prepend_hooks
+
+      # This is a list of the hooks to just append to the end
+      #
+      # @return [Array<Class>]
+      attr_reader :append_hooks
+
+      def initialize
+        @before_hooks  = Hash.new { |h, k| h[k] = [] }
+        @after_hooks   = Hash.new { |h, k| h[k] = [] }
+        @prepend_hooks = []
+        @append_hooks  = []
+      end
+
+      # Add a middleware before an existing middleware.
+      #
+      # @param [Class] existing The existing middleware.
+      # @param [Class] new The new middleware.
+      def before(existing, new, *args, &block)
+        @before_hooks[existing] << [new, args, block]
+      end
+
+      # Add a middleware after an existing middleware.
+      #
+      # @param [Class] existing The existing middleware.
+      # @param [Class] new The new middleware.
+      def after(existing, new, *args, &block)
+        @after_hooks[existing] << [new, args, block]
+      end
+
+      # Append a middleware to the end of the stack. Note that if the
+      # middleware sequence ends early, then the new middleware won't
+      # be run.
+      #
+      # @param [Class] new The middleware to append.
+      def append(new, *args, &block)
+        @append_hooks << [new, args, block]
+      end
+
+      # Prepend a middleware to the beginning of the stack.
+      #
+      # @param [Class] new The new middleware to prepend.
+      def prepend(new, *args, &block)
+        @prepend_hooks << [new, args, block]
+      end
+
+      # This applies the given hook to a builder. This should not be
+      # called directly.
+      #
+      # @param [Builder] builder
+      def apply(builder)
+        # Prepends first
+        @prepend_hooks.each do |klass, args, block|
+          builder.insert(0, klass, *args, &block)
+        end
+
+        # Appends
+        @append_hooks.each do |klass, args, block|
+          builder.use(klass, *args, &block)
+        end
+
+        # Before hooks
+        @before_hooks.each do |key, list|
+          next if !builder.index(key)
+
+          list.each do |klass, args, block|
+            builder.insert_before(key, klass, *args, &block)
+          end
+        end
+
+        # After hooks
+        @after_hooks.each do |key, list|
+          next if !builder.index(key)
+
+          list.each do |klass, args, block|
+            builder.insert_after(key, klass, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/runner.rb

@@ -1,5 +1,6 @@
 require 'log4r'
 
+require 'vagrant/action/hook'
 require 'vagrant/util/busy'
 
 # TODO:
@@ -10,8 +11,7 @@ module Vagrant
     class Runner
       @@reported_interrupt = false
 
-      def initialize(registry, globals=nil, &block)
-        @registry     = registry
+      def initialize(globals=nil, &block)
         @globals      = globals || {}
         @lazy_globals = block
         @logger       = Log4r::Logger.new("vagrant::action::runner")
@@ -19,16 +19,28 @@ module Vagrant
 
       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)
+        callable = Builder.build(callable_id) if callable_id.kind_of?(Class)
         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 = {}
         environment.merge!(@globals)
         environment.merge!(@lazy_globals.call) if @lazy_globals
         environment.merge!(options || {})
 
+        # Setup the action hooks
+        hooks = Vagrant.plugin("2").manager.action_hooks(environment[:action_name])
+        if !hooks.empty?
+          @logger.info("Preparing hooks for middleware sequence...")
+          environment[:action_hooks] = hooks.map do |hook_proc|
+            Hook.new.tap do |h|
+              hook_proc.call(h)
+            end
+          end
+
+          @logger.info("#{environment[:action_hooks].length} hooks defined.")
+        end
+
         # 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.
@@ -47,6 +59,10 @@ module Vagrant
         # 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) }
+
+        # Return the environment in case there are things in there that
+        # the caller wants to use.
+        environment
       end
     end
   end

data/lib/vagrant/action/warden.rb

@@ -16,9 +16,10 @@ module Vagrant
       attr_accessor :actions, :stack
 
       def initialize(actions, env)
-        @stack = []
-        @actions = actions.map { |m| finalize_action(m, env) }
-        @logger  = Log4r::Logger.new("vagrant::action::warden")
+        @stack      = []
+        @actions    = actions.map { |m| finalize_action(m, env) }
+        @logger     = Log4r::Logger.new("vagrant::action::warden")
+        @last_error = nil
       end
 
       def call(env)
@@ -37,20 +38,28 @@ module Vagrant
           # we just exit immediately.
           raise
         rescue Exception => e
-          @logger.error("Error occurred: #{e}")
+          # We guard this so that the Warden only outputs this once for
+          # an exception that bubbles up.
+          if e != @last_error
+            @logger.error("Error occurred: #{e}")
+            @last_error = e
+          end
+
           env["vagrant.error"] = e
 
           # Something went horribly wrong. Start the rescue chain then
           # reraise the exception to properly kick us out of limbo here.
-          begin_rescue(env)
+          recover(env)
           raise
         end
       end
 
-      # Begins the recovery sequence for all middlewares which have run.
-      # It does this by calling `recover` (if it exists) on each middleware
-      # which has already run, in reverse order.
-      def begin_rescue(env)
+      # We implement the recover method ourselves in case a Warden is
+      # embedded within another Warden. To recover, we just do our own
+      # recovery process on our stack.
+      def recover(env)
+        @logger.info("Beginning recovery process...")
+
         @stack.each do |act|
           if act.respond_to?(:recover)
             @logger.info("Calling recover: #{act}")
@@ -58,6 +67,8 @@ module Vagrant
           end
         end
 
+        @logger.info("Recovery complete.")
+
         # Clear stack so that warden down the middleware chain doesn't
         # rescue again.
         @stack.clear

data/lib/vagrant/box.rb

@@ -1,44 +1,93 @@
+require 'fileutils'
+
+require "json"
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
 module Vagrant
-  # Represents a "box," which is simply a packaged vagrant environment.
-  # Boxes are simply `tar` files which contain an exported VirtualBox
-  # virtual machine, at the least. They are created with `vagrant package`
-  # and may contain additional files if specified by the creator. This
-  # class serves to help manage these boxes, although most of the logic
-  # is kicked out to middlewares.
+  # Represents a "box," which is a package Vagrant environment that is used
+  # as a base image when creating a new guest machine.
   class Box
-    # The name of the box.
+    include Comparable
+
+    # The box name. This is the logical name used when adding the box.
+    #
+    # @return [String]
     attr_reader :name
 
-    # The directory where this box is stored
+    # This is the provider that this box is built for.
+    #
+    # @return [Symbol]
+    attr_reader :provider
+
+    # This is the directory on disk where this box exists.
+    #
+    # @return [Pathname]
     attr_reader :directory
 
-    # Creates a new box instance. Given an optional `name` parameter,
-    # newly created instance will have that name, otherwise it defaults
-    # to `nil`.
+    # This is the metadata for the box. This is read from the "metadata.json"
+    # file that all boxes require.
+    #
+    # @return [Hash]
+    attr_reader :metadata
+
+    # This is used to initialize a box.
     #
-    # **Note:** This method does not actually _create_ the box, but merely
-    # returns a new, abstract representation of it. To add a box, see {#add}.
-    def initialize(name, directory, action_runner)
-      @name          = name
-      @directory     = directory
-      @action_runner = action_runner
+    # @param [String] name Logical name of the box.
+    # @param [Symbol] provider The provider that this box implements.
+    # @param [Pathname] directory The directory where this box exists on
+    #   disk.
+    def initialize(name, provider, directory)
+      @name      = name
+      @provider  = provider
+      @directory = directory
+      @metadata  = JSON.parse(directory.join("metadata.json").read)
+
+      @logger = Log4r::Logger.new("vagrant::box")
     end
 
-    # Begins the process of destroying this box. This cannot be undone!
-    def destroy
-      @action_runner.run(:box_remove, { :box_name => @name, :box_directory => @directory })
+    # This deletes the box. This is NOT undoable.
+    def destroy!
+      # Delete the directory to delete the box.
+      FileUtils.rm_r(@directory)
+
+      # Just return true always
+      true
+    rescue Errno::ENOENT
+      # This means the directory didn't exist. Not a problem.
+      return true
     end
 
-    # Begins sequence to repackage this box.
-    def repackage(options=nil)
-      @action_runner.run(:box_repackage, { :box_name => @name, :box_directory => @directory })
+    # This repackages this box and outputs it to the given path.
+    #
+    # @param [Pathname] path The full path (filename included) of where
+    #   to output this box.
+    # @return [Boolean] true if this succeeds.
+    def repackage(path)
+      @logger.debug("Repackaging box '#{@name}' to: #{path}")
+
+      Dir.chdir(@directory) do
+        # Find all the files in our current directory and tar it up!
+        files = Dir.glob(File.join(".", "**", "*"))
+
+        # Package!
+        Util::Subprocess.execute("bsdtar", "-czf", path.to_s, *files)
+      end
+
+      @logger.info("Repackaged box '#{@name}' successfully: #{path}")
+
+      true
     end
 
-    # Implemented for comparison with other boxes. Comparison is implemented
-    # by simply comparing name.
+    # Implemented for comparison with other boxes. Comparison is
+    # implemented by comparing names and providers.
     def <=>(other)
       return super if !other.is_a?(self.class)
-      name <=> other.name
+
+      # Comparison is done by composing the name and provider
+      "#{@name}-#{@provider}" <=> "#{other.name}-#{other.provider}"
     end
   end
 end