vagrant-shell 0.2.9 → 0.2.11

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/destroy_confirm.rb

@@ -1,21 +0,0 @@
-require_relative "confirm"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class asks the user to confirm the destruction of a machine
-      # that Vagrant manages. This is provided as a built-in on top of
-      # {Confirm} because it sets up the proper keys and such so that
-      # `vagrant destroy -f` works properly.
-      class DestroyConfirm < Confirm
-        def initialize(app, env)
-          force_key = :force_confirm_destroy
-          message   = I18n.t("vagrant.commands.destroy.confirmation",
-                             :name => env[:machine].name)
-
-          super(app, env, message, force_key)
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/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.capability(: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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/handle_box_url.rb

@@ -1,77 +0,0 @@
-require "thread"
-
-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
-        @@big_lock = Mutex.new
-        @@handle_box_url_locks = Hash.new { |h,k| h[k] = Mutex.new }
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if !env[:machine].box
-            # Get a "big lock" to make sure that our more fine grained
-            # lock access is thread safe.
-            lock = nil
-            @@big_lock.synchronize do
-              lock = @@handle_box_url_locks[env[:machine].config.vm.box]
-            end
-
-            # 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
-
-            lock.synchronize do
-              # First see if we actually have the box now.
-              has_box = false
-
-              formats = env[:machine].provider_options[:box_format] ||
-                env[:machine].provider_name
-              [formats].flatten.each do |format|
-                if env[:box_collection].find(box_name, format)
-                  has_box = true
-                  break
-                end
-              end
-
-              if !has_box
-                # 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)
-
-                begin
-                  env[:action_runner].run(Vagrant::Action.action_box_add, {
-                    :box_name     => box_name,
-                    :box_provider => env[:machine].provider_name,
-                    :box_url      => box_url
-                  })
-                rescue Errors::BoxAlreadyExists
-                  # Just ignore this, since it means the next part will succeed!
-                  # This can happen in a multi-threaded environment.
-                end
-              end
-            end
-
-            # 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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/handle_forwarded_port_collisions.rb

@@ -1,134 +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.info("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]
-
-          # Log out some of our parameters
-          @logger.debug("Extra in use: #{extra_in_use.inspect}")
-          @logger.debug("Remap: #{remap.inspect}")
-          @logger.debug("Repair: #{repair.inspect}")
-
-          # 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}")
-
-              repaired_port = nil
-              while !usable_ports.empty?
-                # Attempt to repair the forwarded port
-                repaired_port = usable_ports.to_a.sort[0]
-                usable_ports.delete(repaired_port)
-
-                # If the port is in use, then we can't use this either...
-                if extra_in_use.include?(repaired_port) || is_port_open?("127.0.0.1", repaired_port)
-                  @logger.info("Reparied port also in use: #{repaired_port}. Trying another...")
-                  next
-                end
-
-                # We have a port so break out
-                break
-              end
-
-              # If we have no usable ports then we can't repair
-              if !repaired_port && usable_ports.empty?
-                raise Errors::ForwardPortAutolistEmpty,
-                  :vm_name    => env[:machine].name,
-                  :guest_port => guest_port.to_s,
-                  :host_port  => host_port.to_s
-              end
-
-              # 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

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/lock.rb

@@ -1,57 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class creates a multi-process lock using `flock`. The lock
-      # is active for the remainder of the middleware stack.
-      class Lock
-        def initialize(app, env, options=nil)
-          @app     = app
-          @logger  = Log4r::Logger.new("vagrant::action::builtin::lock")
-          @options ||= options || {}
-          raise ArgumentError, "Please specify a lock path" if !@options[:path]
-          raise ArgumentError, "Please specify an exception." if !@options[:exception]
-        end
-
-        def call(env)
-          lock_path = @options[:path]
-          lock_path = lock_path.call(env) if lock_path.is_a?(Proc)
-
-          env_key   = "has_lock_#{lock_path}"
-
-          if !env[env_key]
-            # If we already have the key in our environment we assume the
-            # lock is held by our middleware stack already and we allow
-            # nesting.
-            File.open(lock_path, "w+") do |f|
-              # The file locking fails only if it returns "false." If it
-              # succeeds it returns a 0, so we must explicitly check for
-              # the proper error case.
-              @logger.info("Locking: #{lock_path}")
-              if f.flock(File::LOCK_EX | File::LOCK_NB) === false
-                exception = @options[:exception]
-                exception = exception.call(env) if exception.is_a?(Proc)
-                raise exception
-              end
-
-              # Set that we gained the lock and call deeper into the
-              # middleware, but make sure we UNSET the lock when we leave.
-              begin
-                env[env_key] = true
-                @app.call(env)
-              ensure
-                @logger.info("Unlocking: #{lock_path}")
-                env[env_key] = false
-                f.flock(File::LOCK_UN)
-              end
-            end
-          else
-            # Just call up the middleware because we already hold the lock
-            @app.call(env)
-          end
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/nfs.rb

@@ -1,118 +0,0 @@
-require 'digest/md5'
-require 'fileutils'
-require 'pathname'
-
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This built-in middleware exports and mounts NFS shared folders.
-      #
-      # To use this middleware, two configuration parameters must be given
-      # via the environment hash:
-      #
-      #   - `:nfs_host_ip` - The IP of where to mount the NFS folder from.
-      #   - `:nfs_machine_ip` - The IP of the machine where the NFS folder
-      #     will be mounted.
-      #
-      class NFS
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::nfs")
-        end
-
-        def call(env)
-          # We forward things along first. We do everything on the tail
-          # end of the middleware call.
-          @app.call(env)
-
-          # Used by prepare_permission, so we need to save it
-          @env = env
-
-          folders = {}
-          env[:machine].config.vm.synced_folders.each do |id, opts|
-            # If this synced folder doesn't enable NFS, ignore it.
-            next if !opts[:nfs]
-
-            # Expand the host path, create it if we have to and
-            # store away the folder.
-            hostpath = Pathname.new(opts[:hostpath]).expand_path(env[:root_path])
-
-            if !hostpath.directory? && opts[:create]
-              # Host path doesn't exist, so let's create it.
-              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
-
-              begin
-                FileUtils.mkpath(hostpath)
-              rescue Errno::EACCES
-                raise Vagrant::Errors::SharedFolderCreateFailed,
-                  :path => hostpath.to_s
-              end
-            end
-
-            # Set the hostpath back on the options and save it
-            opts[:hostpath] = hostpath.to_s
-            folders[id] = opts
-          end
-
-          if !folders.empty?
-            raise Errors::NFSNoHostIP if !env[:nfs_host_ip]
-            raise Errors::NFSNoGuestIP if !env[:nfs_machine_ip]
-
-            # Prepare the folder, this means setting up various options
-            # and such on the folder itself.
-            folders.each { |id, opts| prepare_folder(opts) }
-
-            # Export the folders
-            env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
-            env[:host].nfs_export(env[:machine].id, env[:nfs_machine_ip], folders)
-
-            # Mount
-            env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
-
-            # Only mount folders that have a guest path specified.
-            mount_folders = {}
-            folders.each do |id, opts|
-              mount_folders[id] = opts.dup if opts[:guestpath]
-            end
-
-            # Mount them!
-            env[:machine].guest.capability(
-              :mount_nfs_folder, env[:nfs_host_ip], mount_folders)
-          end
-        end
-
-        protected
-
-        def prepare_folder(opts)
-          opts[:map_uid] = prepare_permission(:uid, opts)
-          opts[:map_gid] = prepare_permission(:gid, opts)
-          opts[:nfs_version] ||= 3
-
-          # The poor man's UUID. An MD5 hash here is sufficient since
-          # we need a 32 character "uuid" to represent the filesystem
-          # of an export. Hashing the host path is safe because two of
-          # the same host path will hash to the same fsid.
-          opts[:uuid]    = Digest::MD5.hexdigest(opts[:hostpath])
-        end
-
-        # Prepares the UID/GID settings for a single folder.
-        def prepare_permission(perm, opts)
-          key = "map_#{perm}".to_sym
-          return nil if opts.has_key?(key) && opts[key].nil?
-
-          # The options on the hash get priority, then the default
-          # values
-          value = opts.has_key?(key) ? opts[key] : @env[:machine].config.nfs.send(key)
-          return value if value != :auto
-
-          # Get UID/GID from folder if we've made it this far
-          # (value == :auto)
-          stat = File.stat(opts[:hostpath])
-          return stat.send(perm)
-        end
-      end
-    end
-  end
-end