vagrant-lxc 0.0.1 → 0.0.2

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

@@ -1,79 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

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

@@ -1,43 +0,0 @@
-module Vagrant
-  module Action
-    module Builtin
-      # This built-in middleware handles the `box_url` setting, downloading
-      # the box if necessary. You should place this early in your middleware
-      # sequence for a provider after configuration validation but before
-      # you attempt to use any box.
-      class HandleBoxUrl
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if !env[:machine].box
-            # We can assume a box URL is set because the Vagrantfile
-            # validation should do this for us. If not, though, we do
-            # raise a terrible runtime error.
-            box_name = env[:machine].config.vm.box
-            box_url  = env[:machine].config.vm.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,
-              :provider => env[:machine].provider_name)
-            env[:action_runner].run(Vagrant::Action.action_box_add, {
-              :box_name     => box_name,
-              :box_provider => env[:machine].provider_name,
-              :box_url      => box_url
-            })
-
-            # Reload the environment and set the VM to be the new loaded VM.
-            env[:machine] = env[:machine].env.machine(
-              env[:machine].name, env[:machine].provider_name, true)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-require "set"
-
-require "log4r"
-
-require "vagrant/util/is_port_open"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This middleware class will detect and handle collisions with
-      # forwarded ports, whether that means raising an error or repairing
-      # them automatically.
-      #
-      # Parameters it takes from the environment hash:
-      #
-      #   * `:port_collision_repair` - If true, it will attempt to repair
-      #     port collisions. If false, it will raise an exception when
-      #     there is a collision.
-      #
-      #   * `:port_collision_extra_in_use` - An array of ports that are
-      #     considered in use.
-      #
-      #   * `:port_collision_remap` - A hash remapping certain host ports
-      #     to other host ports.
-      #
-      class HandleForwardedPortCollisions
-        include Util::IsPortOpen
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_port_collisions")
-        end
-
-        def call(env)
-          @logger.debug("Detecting any forwarded port collisions...")
-
-          # Get the extra ports we consider in use
-          extra_in_use = env[:port_collision_extra_in_use] || []
-
-          # Get the remap
-          remap = env[:port_collision_remap] || {}
-
-          # Determine the handler we'll use if we have any port collisions
-          repair = !!env[:port_collision_repair]
-
-          # Determine a list of usable ports for repair
-          usable_ports = Set.new(env[:machine].config.vm.usable_port_range)
-          usable_ports.subtract(extra_in_use)
-
-          # Pass one, remove all defined host ports from usable ports
-          with_forwarded_ports(env) do |options|
-            usable_ports.delete(options[:host])
-          end
-
-          # Pass two, detect/handle any collisions
-          with_forwarded_ports(env) do |options|
-            guest_port = options[:guest]
-            host_port  = options[:host]
-
-            if remap[host_port]
-              remap_port = remap[host_port]
-              @logger.debug("Remap port override: #{host_port} => #{remap_port}")
-              host_port = remap_port
-            end
-
-            # If the port is open (listening for TCP connections)
-            if extra_in_use.include?(host_port) || is_port_open?("127.0.0.1", host_port)
-              if !repair
-                raise Errors::ForwardPortCollision,
-                  :guest_port => guest_port.to_s,
-                  :host_port  => host_port.to_s
-              end
-
-              @logger.info("Attempting to repair FP collision: #{host_port}")
-
-              # If we have no usable ports then we can't repair
-              if usable_ports.empty?
-                raise Errors::ForwardPortAutolistEmpty,
-                  :vm_name    => env[:machine].name,
-                  :guest_port => guest_port.to_s,
-                  :host_port  => host_port.to_s
-              end
-
-              # Attempt to repair the forwarded port
-              repaired_port = usable_ports.to_a.sort[0]
-              usable_ports.delete(repaired_port)
-
-              # Modify the args in place
-              options[:host] = repaired_port
-
-              @logger.info("Repaired FP collision: #{host_port} to #{repaired_port}")
-
-              # Notify the user
-              env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
-                                   :host_port  => host_port.to_s,
-                                   :guest_port => guest_port.to_s,
-                                   :new_port   => repaired_port.to_s))
-            end
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        def with_forwarded_ports(env)
-          env[:machine].config.vm.networks.each do |type, options|
-            # Ignore anything but forwarded ports
-            next if type != :forwarded_port
-
-            yield options
-          end
-        end
-      end
-    end
-  end
-end