tnargav 1.3.5 → 1.3.6

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,82 @@
+require "log4r"
+require "timeout"
+
+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")
+
+            begin
+              env[:machine].guest.capability(:halt)
+            rescue Errors::MachineGuestNotReady
+              @logger.info("Machine guest not ready while attempting to halt. Ignoring.")
+            end
+
+            @logger.debug("Waiting for target graceful halt state: #{@target_state}")
+            begin
+              Timeout.timeout(env[:machine].config.vm.graceful_halt_timeout) do
+                while env[:machine].state.id != @target_state
+                  sleep 1
+                end
+              end
+            rescue Timeout::Error
+              # Don't worry about it, we catch the case later.
+            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,86 @@
+require "thread"
+
+require "log4r"
+
+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
+          @logger = Log4r::Logger.new("vagrant::action::builtin::handle_box_url")
+        end
+
+        def call(env)
+          if !env[:machine].config.vm.box || !env[:machine].config.vm.box_url
+            @logger.info("Skipping HandleBoxUrl because box or box_url not set.")
+            @app.call(env)
+            return
+          end
+
+          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
+            box_download_insecure = env[:machine].config.vm.box_download_insecure
+
+            lock.synchronize do
+              # First see if we actually have the box now.
+              has_box = false
+
+              box_formats = env[:machine].provider_options[:box_format] ||
+                env[:machine].provider_name
+              if env[:box_collection].find(box_name, box_formats)
+                has_box = true
+                break
+              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_download_insecure => box_download_insecure,
+                    :box_name     => box_name,
+                    :box_provider => box_formats,
+                    :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 || !options[:auto_correct]
+                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/mixin_provisioners.rb

@@ -0,0 +1,43 @@
+module Vagrant
+  module Action
+    module Builtin
+      module MixinProvisioners
+        # This returns all the instances of the configured provisioners.
+        # This is safe to call multiple times since it will cache the results.
+        #
+        # @return [Array<Provisioner>]
+        def provisioner_instances
+          return @_provisioner_instances if @_provisioner_instances
+
+          # Make the mapping that'll keep track of provisioner => type
+          @_provisioner_types = {}
+
+          # Get all the configured provisioners
+          @_provisioner_instances = @env[:machine].config.vm.provisioners.map do |provisioner|
+            # Instantiate the provisioner
+            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.name]
+            result = klass.new(@env[:machine], provisioner.config)
+
+            # Store in the type map so that --provision-with works properly
+            @_provisioner_types[result] = provisioner.name
+
+            # Return the result
+            result
+          end
+
+          return @_provisioner_instances
+        end
+
+        # This will return a mapping of a provisioner instance to its
+        # type.
+        def provisioner_type_map
+          # Call this in order to initial the map if it hasn't been already
+          provisioner_instances
+
+          # Return the type map
+          @_provisioner_types
+        end
+      end
+    end
+  end
+end