vagrantup 1.0.7 → 1.1.0

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

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

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,117 @@
+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.mount_nfs(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

data/lib/vagrant/action/builtin/provision.rb

@@ -0,0 +1,70 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run the configured provisioners against the
+      # machine.
+      #
+      # This action should be placed BEFORE the machine is booted so it
+      # can do some setup, and then run again (on the return path) against
+      # a running machine.
+      class Provision
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::provision")
+        end
+
+        def call(env)
+          # Check if we're even provisioning things.
+          enabled = true
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+
+          # This keeps track of a mapping between provisioner and type
+          type_map = {}
+
+          # Get all the configured provisioners
+          provisioners = 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
+            type_map[result] = provisioner.name
+
+            # Return the result
+            result
+          end
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioners.each do |p|
+            p.configure(env[:machine].config)
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+
+          # Actually provision if we enabled it
+          if enabled
+            provisioners.each do |p|
+              next if env[:provision_types] && \
+                !env[:provision_types].include?(type_map[p])
+
+              run_provisioner(env, p)
+            end
+          end
+        end
+
+        # This is pulled out into a seperate method so that users can
+        # subclass and implement custom behavior if they'd like around
+        # this step.
+        def run_provisioner(env, p)
+          env[:ui].info(I18n.t("vagrant.actions.vm.provision.beginning",
+                               :provisioner => p.class))
+
+          p.provision
+        end
+      end
+    end
+  end
+end