tnargav 1.3.5 → 1.3.6

data/lib/vagrant/action/hook.rb

@@ -0,0 +1,107 @@
+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, options=nil)
+        options ||= {}
+
+        if !options[:no_prepend_or_append]
+          # 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
+        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

@@ -0,0 +1,69 @@
+require 'log4r'
+
+require 'vagrant/action/hook'
+require 'vagrant/util/busy'
+
+# TODO:
+# * env.lock
+
+module Vagrant
+  module Action
+    class Runner
+      @@reported_interrupt = false
+
+      def initialize(globals=nil, &block)
+        @globals      = globals || {}
+        @lazy_globals = block
+        @logger       = Log4r::Logger.new("vagrant::action::runner")
+      end
+
+      def run(callable_id, options=nil)
+        callable = callable_id
+        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.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.
+        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) }
+
+        # Return the environment in case there are things in there that
+        # the caller wants to use.
+        environment
+      end
+    end
+  end
+end

data/lib/vagrant/action/warden.rb

@@ -0,0 +1,104 @@
+require "log4r"
+
+module Vagrant
+  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`
+    # method. The warden therefore allows middlewares to not worry about
+    # exceptional events, and by providing a simple callback, can clean up
+    # in any erroneous case.
+    #
+    # Warden will "just work" behind the scenes, and is not of particular
+    # interest except to those who are curious about the internal workings
+    # of Vagrant.
+    class Warden
+      attr_accessor :actions, :stack
+
+      def initialize(actions, env)
+        @stack      = []
+        @actions    = actions.map { |m| finalize_action(m, env) }
+        @logger     = Log4r::Logger.new("vagrant::action::warden")
+        @last_error = nil
+      end
+
+      def call(env)
+        return if @actions.empty?
+
+        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]
+          action = @actions.shift
+          @logger.info("Calling IN action: #{action}")
+          @stack.unshift(action).first.call(env)
+          raise Errors::VagrantInterrupt if env[:interrupted]
+          @logger.info("Calling OUT action: #{action}")
+        rescue SystemExit
+          # This means that an "exit" or "abort" was called. In these cases,
+          # we just exit immediately.
+          raise
+        rescue Exception => 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.
+          recover(env)
+          raise
+        end
+      end
+
+      # 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}")
+            act.recover(env)
+          end
+        end
+
+        @logger.info("Recovery complete.")
+
+        # Clear stack so that warden down the middleware chain doesn't
+        # rescue again.
+        @stack.clear
+      end
+
+      # A somewhat confusing function which simply initializes each
+      # middleware properly to call the next middleware in the sequence.
+      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
+          klass.new(self, env, *args, &block)
+        elsif klass.respond_to?(:call)
+          # Make it a lambda which calls the item then forwards
+          # up the chain
+          lambda do |e|
+            klass.call(e)
+            self.call(e)
+          end
+        else
+          raise "Invalid action: #{action.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/batch_action.rb

@@ -0,0 +1,113 @@
+require 'thread'
+
+require "log4r"
+
+module Vagrant
+  # This class executes multiple actions as a single batch, parallelizing
+  # the action calls if possible.
+  class BatchAction
+    def initialize(allow_parallel=true)
+      @actions          = []
+      @allow_parallel   = allow_parallel
+      @logger           = Log4r::Logger.new("vagrant::batch_action")
+    end
+
+    # Add an action to the batch of actions that will be run.
+    #
+    # This will **not** run the action now. The action will be run
+    # when {#run} is called.
+    #
+    # @param [Machine] machine The machine to run the action on
+    # @param [Symbol] action The action to run
+    # @param [Hash] options Any additional options to send in.
+    def action(machine, action, options=nil)
+      @actions << [machine, action, options]
+    end
+
+    # Run all the queued up actions, parallelizing if possible.
+    #
+    # This will parallelize if and only if the provider of every machine
+    # supports parallelization and parallelization is possible from
+    # initialization of the class.
+    def run
+      par = false
+
+      if @allow_parallel
+        par = true
+        @logger.info("Enabling parallelization by default.")
+      end
+
+      if par
+        @actions.each do |machine, _, _|
+          if !machine.provider_options[:parallel]
+            @logger.info("Disabling parallelization because provider doesn't support it: #{machine.provider_name}")
+            par = false
+            break
+          end
+        end
+      end
+
+      @logger.info("Batch action will parallelize: #{par.inspect}")
+
+      threads = []
+      @actions.each do |machine, action, options|
+        @logger.info("Starting action: #{machine} #{action} #{options}")
+
+        # Create the new thread to run our action. This is basically just
+        # calling the action but also contains some error handling in it
+        # as well.
+        thread = Thread.new do
+          Thread.current[:error] = nil
+
+          begin
+            machine.send(:action, action, options)
+          rescue Exception => e
+            # If we're not parallelizing, then raise the error
+            raise if !par
+
+            # Store the exception that will be processed later
+            Thread.current[:error] = e
+          end
+        end
+
+        # Set some attributes on the thread for later
+        thread[:machine] = machine
+
+        thread.join if !par
+        threads << thread
+      end
+
+      errors = []
+
+      threads.each do |thread|
+        # Wait for the thread to complete
+        thread.join
+
+        # If the thread had an error, then store the error to show later
+        if thread[:error]
+          e = thread[:error]
+          # If the error isn't a Vagrant error, then store the backtrace
+          # as well.
+          if !thread[:error].is_a?(Errors::VagrantError)
+            e       = thread[:error]
+            message = e.message
+            message += "\n"
+            message += "\n#{e.backtrace.join("\n")}"
+
+            errors << I18n.t("vagrant.general.batch_unexpected_error",
+                             :machine => thread[:machine].name,
+                             :message => message)
+          else
+            errors << I18n.t("vagrant.general.batch_vagrant_error",
+                             :machine => thread[:machine].name,
+                             :message => thread[:error].message)
+          end
+        end
+      end
+
+      if !errors.empty?
+        raise Errors::BatchMultiError, :message => errors.join("\n\n")
+      end
+    end
+  end
+end

data/lib/vagrant/box.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+require "json"
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/safe_chdir"
+require "vagrant/util/subprocess"
+
+module Vagrant
+  # Represents a "box," which is a package Vagrant environment that is used
+  # as a base image when creating a new guest machine.
+  class Box
+    include Comparable
+
+    # The box name. This is the logical name used when adding the box.
+    #
+    # @return [String]
+    attr_reader :name
+
+    # 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
+
+    # 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.
+    #
+    # @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_file = directory.join("metadata.json")
+      raise Errors::BoxMetadataFileNotFound, :name => @name if !metadata_file.file?
+      @metadata = JSON.parse(directory.join("metadata.json").read)
+
+      @logger = Log4r::Logger.new("vagrant::box")
+    end
+
+    # 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
+
+    # 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}")
+
+      Util::SafeChdir.safe_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 comparing names and providers.
+    def <=>(other)
+      return super if !other.is_a?(self.class)
+
+      # Comparison is done by composing the name and provider
+      "#{@name}-#{@provider}" <=> "#{other.name}-#{other.provider}"
+    end
+  end
+end