vagrant-lxc 0.0.1

data/vendor/vagrant/lib/vagrant/action.rb

@@ -0,0 +1,42 @@
+require 'vagrant/action/builder'
+
+module Vagrant
+  module Action
+    autoload :Runner,      'vagrant/action/runner'
+    autoload :Warden,      'vagrant/action/warden'
+
+    # Builtin contains middleware classes that are shipped with Vagrant-core
+    # and are thus available to all plugins as a "standard library" of sorts.
+    module Builtin
+      autoload :BoxAdd,  "vagrant/action/builtin/box_add"
+      autoload :Call,    "vagrant/action/builtin/call"
+      autoload :Confirm, "vagrant/action/builtin/confirm"
+      autoload :ConfigValidate, "vagrant/action/builtin/config_validate"
+      autoload :EnvSet,  "vagrant/action/builtin/env_set"
+      autoload :GracefulHalt, "vagrant/action/builtin/graceful_halt"
+      autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
+      autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
+      autoload :Lock, "vagrant/action/builtin/lock"
+      autoload :NFS, "vagrant/action/builtin/nfs"
+      autoload :Provision, "vagrant/action/builtin/provision"
+      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
+      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
+      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
+    end
+
+    module General
+      autoload :Package,  'vagrant/action/general/package'
+    end
+
+    # This is the action that will add a box from a URL. This middleware
+    # sequence is built-in to Vagrant. Plugins can hook into this like any
+    # other middleware sequence. This is particularly useful for provider
+    # plugins, which can hook in to do things like verification of boxes
+    # that are downloaded.
+    def self.action_box_add
+      Builder.new.tap do |b|
+        b.use Builtin::BoxAdd
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builder.rb

@@ -0,0 +1,154 @@
+module Vagrant
+  module Action
+    # Action builder which provides a nice DSL for building up
+    # a middleware sequence for Vagrant actions. This code is based
+    # heavily off of `Rack::Builder` and `ActionDispatch::MiddlewareStack`
+    # in Rack and Rails, respectively.
+    #
+    # Usage
+    #
+    # Building an action sequence is very easy:
+    #
+    #     app = Vagrant::Action::Builder.new.tap do |b|
+    #       b.use MiddlewareA
+    #       b.use MiddlewareB
+    #     end
+    #
+    #     Vagrant::Action.run(app)
+    #
+    class Builder
+      # This is the stack of middlewares added. This should NOT be used
+      # directly.
+      #
+      # @return [Array]
+      attr_reader :stack
+
+      # This is a shortcut for a middleware sequence with only one item
+      # in it. For a description of the arguments and the documentation, please
+      # see {#use} instead.
+      #
+      # @return [Builder]
+      def self.build(middleware, *args, &block)
+        new.use(middleware, *args, &block)
+      end
+
+      def initialize
+        @stack = []
+      end
+
+      # Implement a custom copy that copies the stack variable over so that
+      # we don't clobber that.
+      def initialize_copy(original)
+        super
+
+        @stack = original.stack.dup
+      end
+
+      # Returns a mergeable version of the builder. If `use` is called with
+      # the return value of this method, then the stack will merge, instead
+      # of being treated as a separate single middleware.
+      def flatten
+        lambda do |env|
+          self.call(env)
+        end
+      end
+
+      # Adds a middleware class to the middleware stack. Any additional
+      # args and a block, if given, are saved and passed to the initializer
+      # of the middleware.
+      #
+      # @param [Class] middleware The middleware class
+      def use(middleware, *args, &block)
+        if middleware.kind_of?(Builder)
+          # Merge in the other builder's stack into our own
+          self.stack.concat(middleware.stack)
+        else
+          self.stack << [middleware, args, block]
+        end
+
+        self
+      end
+
+      # Inserts a middleware at the given index or directly before the
+      # given middleware object.
+      def insert(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        raise "no such middleware to insert before: #{index.inspect}" unless index
+        stack.insert(index, [middleware, args, block])
+      end
+
+      alias_method :insert_before, :insert
+
+      # Inserts a middleware after the given index or middleware object.
+      def insert_after(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        raise "no such middleware to insert after: #{index.inspect}" unless index
+        insert(index + 1, middleware, *args, &block)
+      end
+
+      # Replaces the given middlware object or index with the new
+      # middleware.
+      def replace(index, middleware, *args, &block)
+        if index.is_a?(Integer)
+          delete(index)
+          insert(index, middleware, *args, &block)
+        else
+          insert_before(index, middleware, *args, &block)
+          delete(index)
+        end
+      end
+
+      # Deletes the given middleware object or index
+      def delete(index)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.delete_at(index)
+      end
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+
+      # Returns the numeric index for the given middleware object.
+      #
+      # @param [Object] object The item to find the index for
+      # @return [Integer]
+      def index(object)
+        stack.each_with_index do |item, i|
+          return i if item[0] == object
+          return i if item[0].respond_to?(:name) && item[0].name == object
+        end
+
+        nil
+      end
+
+      # Converts the builder stack to a runnable action sequence.
+      #
+      # @param [Vagrant::Action::Environment] env The action environment
+      # @return [Object] A callable object
+      def to_app(env)
+        app_stack = nil
+
+        # If we have action hooks, then we apply them
+        if env[:action_hooks]
+          builder = self.dup
+
+          # Apply all the hooks to the new builder instance
+          env[:action_hooks].each do |hook|
+            hook.apply(builder)
+          end
+
+          # The stack is now the result of the new builder
+          app_stack = builder.stack.dup
+        end
+
+        # If we don't have a stack then default to using our own
+        app_stack ||= stack.dup
+
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(app_stack, env)
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/box_add.rb

@@ -0,0 +1,79 @@
+require "log4r"
+
+require "vagrant/util/platform"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware will download a remote box and add it to the
+      # given box collection.
+      class BoxAdd
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::box_add")
+        end
+
+        def call(env)
+          # Instantiate the downloader
+          downloader = download_klass(env[:box_url]).new(env[:ui])
+          env[:ui].info I18n.t("vagrant.actions.box.download.with",
+                               :class => downloader.class.to_s)
+
+          # Download the box to a temporary path. We store the temporary
+          # path as an instance variable so that the `#recover` method can
+          # access it.
+          @temp_path = env[:tmp_path].join("box" + Time.now.to_i.to_s)
+          @logger.info("Downloading box to: #{@temp_path}")
+          File.open(@temp_path, Vagrant::Util::Platform.tar_file_options) do |f|
+            downloader.download!(env[:box_url], f)
+          end
+
+          # Add the box
+          env[:ui].info I18n.t("vagrant.actions.box.add.adding", :name => env[:box_name])
+          begin
+            env[:box_collection].add(@temp_path, env[:box_name], env[:box_provider])
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            # Upgrade the box
+            env[:box_collection].upgrade(env[:box_name])
+
+            # Try adding it again
+            retry
+          end
+
+          # Call the 'recover' method in all cases to clean up the
+          # downloaded temporary file.
+          recover(env)
+
+          # Carry on!
+          @app.call(env)
+        end
+
+        def download_klass(url)
+          # This is hardcoded for now. In the future I'd like to make this
+          # pluginnable as well.
+          classes = [Downloaders::HTTP, Downloaders::File]
+
+          # Find the class to use.
+          classes.each_index do |i|
+            klass = classes[i]
+
+            # Use the class if it matches the given URI or if this
+            # is the last class...
+            return klass if classes.length == (i + 1) || klass.match?(url)
+          end
+
+          # If no downloader knows how to download this file, then we
+          # raise an exception.
+          raise Errors::BoxDownloadUnknownType
+        end
+
+        def recover(env)
+          if @temp_path && File.exist?(@temp_path)
+            env[:ui].info I18n.t("vagrant.actions.box.download.cleaning")
+            File.unlink(@temp_path)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/call.rb

@@ -0,0 +1,67 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class allows a sort of "conditional" run within
+      # a single middlware sequence. It takes another middleware runnable,
+      # runs it with the same environment, then yields the resulting env to a block,
+      # allowing that block to determine the next course of action in the
+      # middleware sequence.
+      #
+      # The first argument to this middleware sequence is anywhere middleware
+      # runnable, whether it be a class, lambda, or something else that
+      # responds to `call`. This middleware runnable is run with the same
+      # environment as this class.
+      #
+      # After running, {Call} takes the environment and yields it to a block
+      # given to initialize the class, along with an instance of {Builder}.
+      # The result is used to build up a new sequence on the given builder.
+      # This builder is then run.
+      class Call
+        # For documentation, read the description of the {Call} class.
+        #
+        # @param [Object] callable A valid middleware runnable object. This
+        #   can be a class, a lambda, or an object that responds to `call`.
+        # @yield [result, builder] This block is expected to build on `builder`
+        #   which is the next middleware sequence that will be run.
+        def initialize(app, env, callable, *callable_args, &block)
+          raise ArgumentError, "A block must be given to Call" if !block
+
+          @app      = app
+          @callable = callable
+          @callable_args = callable_args
+          @block    = block
+          @child_app = nil
+        end
+
+        def call(env)
+          runner  = Runner.new
+
+          # Build the callable that we'll run
+          callable = Builder.build(@callable, *@callable_args)
+
+          # Run our callable with our environment
+          new_env = runner.run(callable, env)
+
+          # Build our new builder based on the result
+          builder = Builder.new
+          @block.call(new_env, builder)
+
+          # Run the result with our new environment
+          @child_app = builder.to_app(new_env)
+          final_env = runner.run(@child_app, new_env)
+
+          # Merge the environment into our original environment
+          env.merge!(final_env)
+
+          # Call the next step using our final environment
+          @app.call(env)
+        end
+
+        def recover(env)
+          # Call back into our compiled application and recover it.
+          @child_app.recover(env) if @child_app
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/config_validate.rb

@@ -0,0 +1,30 @@
+require "vagrant/util/template_renderer"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class validates the configuration and raises an exception
+      # if there are any validation errors.
+      class ConfigValidate
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env.has_key?(:config_validate) || env[:config_validate]
+            errors = env[:machine].config.validate(env[:machine])
+
+            if errors && !errors.empty?
+              raise Errors::ConfigInvalid,
+                :errors => Util::TemplateRenderer.render(
+                  "config/validation_failed",
+                  :errors => errors)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/confirm.rb

@@ -0,0 +1,38 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This class asks the user to confirm some sort of question with
+      # a "Y/N" question. The only parameter is the text to ask the user.
+      # The result is placed in `env[:result]` so that it can be used
+      # with the {Call} class.
+      class Confirm
+        # For documentation, read the description of the {Confirm} class.
+        #
+        # @param [String] message The message to ask the user.
+        # @param [Symbol] force_key The key that if present and true in
+        #   the environment hash will skip the confirmation question.
+        def initialize(app, env, message, force_key=nil)
+          @app      = app
+          @message  = message
+          @force_key = force_key
+        end
+
+        def call(env)
+          choice = nil
+
+          # If we have a force key set and we're forcing, then set
+          # the result to "Y"
+          choice = "Y" if @force_key && env[@force_key]
+
+          # If we haven't chosen yes, then ask the user via TTY
+          choice = env[:ui].ask(@message) if !choice
+
+          # The result is only true if the user said "Y"
+          env[:result] = choice && choice.upcase == "Y"
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/env_set.rb

@@ -0,0 +1,24 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class allows you to modify the environment hash
+      # in the middle of a middleware sequence. The new environmental data
+      # will take affect at this stage in the middleware and will persist
+      # through.
+      class EnvSet
+        def initialize(app, env, new_env=nil)
+          @app     = app
+          @new_env = new_env || {}
+        end
+
+        def call(env)
+          # Merge in the new data
+          env.merge!(@new_env)
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/vagrant/lib/vagrant/action/builtin/graceful_halt.rb

@@ -0,0 +1,73 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware class will attempt to perform a graceful shutdown
+      # of the machine using the guest implementation. This middleware is
+      # compatible with the {Call} middleware so you can branch based on
+      # the result, which is true if the halt succeeded and false otherwise.
+      class GracefulHalt
+        # Note: Any of the arguments can be arrays as well.
+        #
+        # @param [Symbol] target_state The target state ID that means that
+        #   the machine was properly shut down.
+        # @param [Symbol] source_state The source state ID that the machine
+        #   must be in to be shut down.
+        def initialize(app, env, target_state, source_state=nil)
+          @app          = app
+          @logger       = Log4r::Logger.new("vagrant::action::builtin::graceful_halt")
+          @source_state = source_state
+          @target_state = target_state
+        end
+
+        def call(env)
+          graceful = true
+          graceful = !env[:force_halt] if env.has_key?(:force_halt)
+
+          # By default, we didn't succeed.
+          env[:result] = false
+
+          if graceful && @source_state
+            @logger.info("Verifying source state of machine: #{@source_state.inspect}")
+
+            # If we're not in the proper source state, then we don't
+            # attempt to halt the machine
+            current_state = env[:machine].state.id
+            if current_state != @source_state
+              @logger.info("Invalid source state, not halting: #{current_state}")
+              graceful = false
+            end
+          end
+
+          # Only attempt to perform graceful shutdown under certain cases
+          # checked above.
+          if graceful
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.graceful")
+            env[:machine].guest.halt
+
+            @logger.debug("Waiting for target graceful halt state: #{@target_state}")
+            count = 0
+            while env[:machine].state.id != @target_state
+              count += 1
+              return if count >= env[:machine].config.vm.graceful_halt_retry_count
+              sleep env[:machine].config.vm.graceful_halt_retry_interval
+            end
+
+            # The result of this matters on whether we reached our
+            # proper target state or not.
+            env[:result] = env[:machine].state.id == @target_state
+
+            if env[:result]
+              @logger.info("Gracefully halted.")
+            else
+              @logger.info("Graceful halt failed.")
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end