tnargav 1.2.2

data/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/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/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/lib/vagrant/action/builtin/destroy_confirm.rb

@@ -0,0 +1,21 @@
+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/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/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.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/lib/vagrant/action/builtin/handle_box_url.rb

@@ -0,0 +1,77 @@
+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/lib/vagrant/action/builtin/handle_forwarded_port_collisions.rb

@@ -0,0 +1,134 @@
+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/lib/vagrant/action/builtin/lock.rb

@@ -0,0 +1,57 @@
+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/lib/vagrant/action/builtin/nfs.rb

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