vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/plugin/v2/provider.rb

@@ -0,0 +1,69 @@
+module Vagrant
+  module Plugin
+    module V2
+      # This is the base class for a provider for the V2 API. A provider
+      # is responsible for creating compute resources to match the needs
+      # of a Vagrant-configured system.
+      class Provider
+        # Initialize the provider to represent the given machine.
+        #
+        # @param [Vagrant::Machine] machine The machine that this provider
+        #   is responsible for.
+        def initialize(machine)
+        end
+
+        # This should return an action callable for the given name.
+        #
+        # @param [Symbol] name Name of the action.
+        # @return [Object] A callable action sequence object, whether it
+        #   is a proc, object, etc.
+        def action(name)
+          nil
+        end
+
+        # This method is called if the underying machine ID changes. Providers
+        # can use this method to load in new data for the actual backing
+        # machine or to realize that the machine is now gone (the ID can
+        # become `nil`). No parameters are given, since the underlying machine
+        # is simply the machine instance given to this object. And no
+        # return value is necessary.
+        def machine_id_changed
+        end
+
+        # This should return a hash of information that explains how to
+        # SSH into the machine. If the machine is not at a point where
+        # SSH is even possible, then `nil` should be returned.
+        #
+        # The general structure of this returned hash should be the
+        # following:
+        #
+        #     {
+        #       :host => "1.2.3.4",
+        #       :port => "22",
+        #       :username => "mitchellh",
+        #       :private_key_path => "/path/to/my/key"
+        #     }
+        #
+        # **Note:** Vagrant only supports private key based authentication,
+        # mainly for the reason that there is no easy way to exec into an
+        # `ssh` prompt with a password, whereas we can pass a private key
+        # via commandline.
+        #
+        # @return [Hash] SSH information. For the structure of this hash
+        #   read the accompanying documentation for this method.
+        def ssh_info
+          nil
+        end
+
+        # This should return the state of the machine within this provider.
+        # The state must be an instance of {MachineState}. Please read the
+        # documentation of that class for more information.
+        #
+        # @return [MachineState]
+        def state
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2/provisioner.rb

@@ -0,0 +1,47 @@
+module Vagrant
+  module Plugin
+    module V2
+      # This is the base class for a provisioner for the V2 API. A provisioner
+      # is primarily responsible for installing software on a Vagrant guest.
+      class Provisioner
+        attr_reader :machine
+        attr_reader :config
+
+        # Initializes the provisioner with the machine that it will be
+        # provisioning along with the provisioner configuration (if there
+        # is any).
+        #
+        # The provisioner should _not_ do anything at this point except
+        # initialize internal state.
+        #
+        # @param [Machine] machine The machine that this will be provisioning.
+        # @param [Object] config Provisioner configuration, if one was set.
+        def initialize(machine, config)
+          @machine = machine
+          @config  = config
+        end
+
+        # Called with the root configuration of the machine so the provisioner
+        # can add some configuration on top of the machine.
+        #
+        # During this step, and this step only, the provisioner should modify
+        # the root machine configuration to add any additional features it
+        # may need. Examples include sharing folders, networking, and so on.
+        # This step is guaranteed to be called before any of those steps are
+        # done so the provisioner may do that.
+        #
+        # No return value is expected.
+        def configure(root_config)
+        end
+
+        # This is the method called when the actual provisioning should be
+        # done. The communicator is guaranteed to be ready at this point,
+        # and any shared folders or networks are already setup.
+        #
+        # No return value is expected.
+        def provision
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/registry.rb

@@ -2,43 +2,62 @@ module Vagrant
   # Register components in a single location that can be queried.
   #
   # This allows certain components (such as guest systems, configuration
-  # pieces, etc.) to be registered and queried.
+  # pieces, etc.) to be registered and queried, lazily.
   class Registry
     def initialize
-      @actions = {}
+      @items = {}
       @results_cache = {}
     end
 
-    # Register a callable by key.
+    # Register a key with a lazy-loaded value.
     #
-    # The callable should be given in a block which will be lazily evaluated
-    # when the action is needed.
-    #
-    # If an action by the given name already exists then it will be
-    # overwritten.
-    def register(key, value=nil, &block)
-      block = lambda { value } if value
-      @actions[key] = block
+    # If a key with the given name already exists, it is overwritten.
+    def register(key, &block)
+      raise ArgumentError, "block required" if !block_given?
+      @items[key] = block
     end
 
-    # Get an action by the given key.
+    # Get a value by the given key.
     #
-    # This will evaluate the block given to `register` and return the resulting
-    # action stack.
+    # This will evaluate the block given to `register` and return the
+    # resulting value.
     def get(key)
-      return nil if !@actions.has_key?(key)
+      return nil if !@items.has_key?(key)
       return @results_cache[key] if @results_cache.has_key?(key)
-      @results_cache[key] = @actions[key].call
+      @results_cache[key] = @items[key].call
     end
     alias :[] :get
 
+    # Checks if the given key is registered with the registry.
+    #
+    # @return [Boolean]
+    def has_key?(key)
+      @items.has_key?(key)
+    end
+
     # Iterate over the keyspace.
     def each(&block)
-      @actions.each do |key, _|
+      @items.each do |key, _|
         yield key, get(key)
       end
     end
 
+    # Merge one registry with another and return a completely new
+    # registry. Note that the result cache is completely busted, so
+    # any gets on the new registry will result in a cache miss.
+    def merge(other)
+      self.class.new.tap do |result|
+        result.merge!(self)
+        result.merge!(other)
+      end
+    end
+
+    # Like #{merge} but merges into self.
+    def merge!(other)
+      @items.merge!(other.__internal_state[:items])
+      self
+    end
+
     # Converts this registry to a hash
     def to_hash
       result = {}
@@ -48,5 +67,12 @@ module Vagrant
 
       result
     end
+
+    def __internal_state
+      {
+        :items => @items,
+        :results_cache => @results_cache
+      }
+    end
   end
 end

data/lib/vagrant/ssh.rb

@@ -1,5 +1,6 @@
 require 'log4r'
 
+require 'vagrant/util/file_util'
 require 'vagrant/util/file_mode'
 require 'vagrant/util/platform'
 require 'vagrant/util/safe_exec'
@@ -55,15 +56,18 @@ module Vagrant
       # Get the SSH information and cache it here
       ssh_info = info
 
-      if Util::Platform.windows?
-        raise Errors::SSHUnavailableWindows, :host => ssh_info[:host],
-                                             :port => ssh_info[:port],
-                                             :username => ssh_info[:username],
-                                             :key_path => ssh_info[:private_key_path]
+      # Ensure the platform supports ssh. On Windows there are several programs which
+      # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
+      if !Util::FileUtil.which("ssh")
+        if Util::Platform.windows?
+          raise Errors::SSHUnavailableWindows, :host => ssh_info[:host],
+                                               :port => ssh_info[:port],
+                                               :username => ssh_info[:username],
+                                               :key_path => ssh_info[:private_key_path]
+        end
+        raise Errors::SSHUnavailable 
       end
 
-      raise Errors::SSHUnavailable if !Kernel.system("which ssh > /dev/null 2>&1")
-
       # If plain mode is enabled then we don't do any authentication (we don't
       # set a user or an identity file)
       plain_mode = opts[:plain_mode]
@@ -76,10 +80,11 @@ module Vagrant
 
       # Command line options
       command_options = ["-p", options[:port].to_s, "-o", "UserKnownHostsFile=/dev/null",
-                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=ERROR"]
+                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=QUIET"]
 
       # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the IdentitiesOnly option
-      command_options += ["-o", "IdentitiesOnly=yes"] unless Util::Platform.solaris?
+      # (Also don't use it in plain mode, it'll skip user agents.)
+      command_options += ["-o", "IdentitiesOnly=yes"] if !(Util::Platform.solaris? || plain_mode)
 
       command_options += ["-i", options[:private_key_path]] if !plain_mode
       command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
@@ -113,6 +118,7 @@ module Vagrant
         @logger.info("Attempting to correct key permissions to 0600")
         File.chmod(0600, key_path)
 
+        stat = File.stat(key_path)
         if Util::FileMode.from_octal(stat.mode) != "600"
           raise Errors::SSHKeyBadPermissions, :key_path => key_path
         end

data/lib/vagrant/ui.rb

@@ -14,7 +14,7 @@ module Vagrant
     class Interface
       attr_accessor :resource
 
-      def initialize(resource)
+      def initialize(resource=nil)
         @logger   = Log4r::Logger.new("vagrant::ui::interface")
         @resource = resource
       end
@@ -73,8 +73,11 @@ module Vagrant
         # Output the data
         say(:info, message, opts)
 
-        # Get the results and chomp off the newline
-        $stdin.gets.chomp
+        # Get the results and chomp off the newline. We do a logical OR
+        # here because `gets` can return a nil, for example in the case
+        # that ctrl-D is pressed on the input.
+        input = $stdin.gets || ""
+        input.chomp
       end
 
       # This is used to output progress reports to the UI.
@@ -96,7 +99,6 @@ module Vagrant
       def clear_line
         reset = "\r"
         reset += "\e[0K" unless Util::Platform.windows?
-        reset
 
         info(reset, :new_line => false)
       end
@@ -123,7 +125,7 @@ module Vagrant
       # This is called by `say` to format the message for output.
       def format_message(type, message, opts=nil)
         opts ||= {}
-        message = "[#{@resource}] #{message}" if opts[:prefix]
+        message = "[#{@resource}] #{message}" if @resource && opts[:prefix]
         message
       end
     end

data/lib/vagrant/util/is_port_open.rb

@@ -29,7 +29,7 @@ module Vagrant
           # to connect.
           return true
         end
-      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
         # Any of the above exceptions signal that the port is closed.
         return false
       end

data/lib/vagrant/util/platform.rb

@@ -1,6 +1,8 @@
 require 'rbconfig'
 require 'tempfile'
 
+require "vagrant/util/subprocess"
+
 module Vagrant
   module Util
     # This class just contains some platform checking code.
@@ -14,6 +16,10 @@ module Vagrant
           platform.include?("darwin9")
         end
 
+        def cygwin?
+          platform.include?("cygwin")
+        end
+
         [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
           define_method("#{type}?") do
             platform.include?(type.to_s)
@@ -44,6 +50,19 @@ module Vagrant
           !bit64?
         end
 
+        # This takes as input a path as a string and converts it into
+        # a platform-friendly version of the path. This is most important
+        # when using the path in shell environments with Cygwin.
+        #
+        # @param [String] path
+        # @return [String]
+        def platform_path(path)
+          return path if !cygwin?
+
+          process = Subprocess.execute("cygpath", "-u", path.to_s)
+          process.stdout.chomp
+        end
+
         # Returns a boolean noting whether the terminal supports color.
         # output.
         def terminal_supports_colors?

data/lib/vagrant/util/retryable.rb

@@ -1,3 +1,5 @@
+require "log4r"
+
 module Vagrant
   module Util
     module Retryable
@@ -8,12 +10,16 @@ module Vagrant
       # This code is adapted slightly from the following blog post:
       # http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
       def retryable(opts=nil)
-        opts = { :tries => 1, :on => Exception }.merge(opts || {})
+        logger = nil
+        opts   = { :tries => 1, :on => Exception }.merge(opts || {})
 
         begin
           return yield
-        rescue *opts[:on]
+        rescue *opts[:on] => e
           if (opts[:tries] -= 1) > 0
+            logger = Log4r::Logger.new("vagrant::util::retryable")
+            logger.info("Retryable exception raised: #{e.inspect}")
+
             sleep opts[:sleep].to_f if opts[:sleep]
             retry
           end

data/lib/vagrant/util/safe_exec.rb

@@ -6,8 +6,8 @@ module Vagrant
     # This issue causes `exec` to fail if there is more than one system
     # thread. In that case, `safe_exec` automatically falls back to
     # forking.
-    module SafeExec
-      def safe_exec(command, *args)
+    class SafeExec
+      def self.exec(command, *args)
         # Create a list of things to rescue from. Since this is OS
         # specific, we need to do some defined? checks here to make
         # sure they exist.

data/lib/vagrant/util/scoped_hash_override.rb

@@ -0,0 +1,45 @@
+module Vagrant
+  module Util
+    # This allows for hash options to be overridden by a scope key
+    # prefix. An example speaks best here. Imagine the following hash:
+    #
+    #     original = {
+    #       :id => "foo",
+    #       :mitchellh__id => "bar",
+    #       :mitchellh__other => "foo"
+    #     }
+    #
+    #     scoped = scoped_hash_override(original, "mitchellh")
+    #
+    #     scoped == {
+    #       :id => "bar",
+    #       :other => "foo"
+    #     }
+    #
+    module ScopedHashOverride
+      def scoped_hash_override(original, scope)
+        # Convert the scope to a string in case a symbol was given since
+        # we use string comparisons for everything.
+        scope = scope.to_s
+
+        # Shallow copy the hash for the result
+        result = original.dup
+
+        original.each do |key, value|
+          parts = key.to_s.split("__", 2)
+
+          # If we don't have the proper parts, then bail
+          next if parts.length != 2
+
+          # If this is our scope, then override
+          if parts[0] == scope
+            result[parts[1].to_sym] = value
+            result.delete(key)
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/vagrant/util/ssh.rb

@@ -0,0 +1,126 @@
+require "log4r"
+
+require "vagrant/util/file_mode"
+require "vagrant/util/platform"
+require "vagrant/util/safe_exec"
+require "vagrant/util/which"
+
+module Vagrant
+  module Util
+    # This is a class that has helpers on it for dealing with SSH. These
+    # helpers don't depend on any part of Vagrant except what is given
+    # via the parameters.
+    class SSH
+      LOGGER = Log4r::Logger.new("vagrant::util::ssh")
+
+      # Checks that the permissions for a private key are valid, and fixes
+      # them if possible. SSH requires that permissions on the private key
+      # are 0600 on POSIX based systems. This will make a best effort to
+      # fix these permissions if they are not properly set.
+      #
+      # @param [Pathname] key_path The path to the private key.
+      def self.check_key_permissions(key_path)
+        # Don't do anything if we're on Windows, since Windows doesn't worry
+        # about key permissions.
+        return if Platform.windows?
+
+        LOGGER.debug("Checking key permissions: #{key_path}")
+        stat = key_path.stat
+
+        if stat.owned? && FileMode.from_octal(stat.mode) != "600"
+          LOGGER.info("Attempting to correct key permissions to 0600")
+          key_path.chmod(0600)
+
+          # Re-stat the file to get the new mode, and verify it worked
+          stat = key_path.stat
+          if FileMode.from_octal(stat.mode) != "600"
+            raise Errors::SSHKeyBadPermissions, :key_path => key_path
+          end
+        end
+      rescue Errno::EPERM
+        # This shouldn't happen since we verify we own the file, but
+        # it is possible in theory, so we raise an error.
+        raise Errors::SSHKeyBadPermissions, :key_path => key_path
+      end
+
+      # Halts the running of this process and replaces it with a full-fledged
+      # SSH shell into a remote machine.
+      #
+      # Note: This method NEVER returns. The process ends after this.
+      #
+      # @param [Hash] ssh_info This is the SSH information. For the keys
+      #   required please see the documentation of {Machine#ssh_info}.
+      # @param [Hash] opts These are additional options that are supported
+      #   by exec.
+      def self.exec(ssh_info, opts={})
+        # Ensure the platform supports ssh. On Windows there are several programs which
+        # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
+        if !Which.which("ssh")
+          if Platform.windows?
+            raise Errors::SSHUnavailableWindows,
+              :host => ssh_info[:host],
+              :port => ssh_info[:port],
+              :username => ssh_info[:username],
+              :key_path => ssh_info[:private_key_path]
+          end
+
+          raise Errors::SSHUnavailable
+        end
+
+        # If plain mode is enabled then we don't do any authentication (we don't
+        # set a user or an identity file)
+        plain_mode = opts[:plain_mode]
+
+        options = {}
+        options[:host] = ssh_info[:host]
+        options[:port] = ssh_info[:port]
+        options[:username] = ssh_info[:username]
+        options[:private_key_path] = ssh_info[:private_key_path]
+
+        # Command line options
+        command_options = [
+          "-p", options[:port].to_s,
+          "-o", "LogLevel=FATAL",
+          "-o", "StrictHostKeyChecking=no",
+          "-o", "UserKnownHostsFile=/dev/null"]
+
+        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
+        # IdentitiesOnly option. Also, we don't enable it in plain mode so
+        # that SSH properly searches our identities and tries to do it itself.
+        if !Platform.solaris? && !plain_mode
+          command_options += ["-o", "IdentitiesOnly=yes"]
+        end
+
+        # If we're not in plain mode, attach the private key path.
+        command_options += ["-i", options[:private_key_path].to_s] if !plain_mode
+
+        if ssh_info[:forward_x11]
+          # Both are required so that no warnings are shown regarding X11
+          command_options += [
+            "-o", "ForwardX11=yes",
+            "-o", "ForwardX11Trusted=yes"]
+        end
+
+        # Configurables -- extra_args should always be last due to the way the
+        # ssh args parser works. e.g. if the user wants to use the -t option,
+        # any shell command(s) she'd like to run on the remote server would
+        # have to be the last part of the 'ssh' command:
+        #
+        #   $ ssh localhost -t -p 2222 "cd mydirectory; bash"
+        #
+        # Without having extra_args be last, the user loses this ability
+        command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
+        command_options.concat(opts[:extra_args]) if opts[:extra_args]
+
+        # Build up the host string for connecting
+        host_string = options[:host]
+        host_string = "#{options[:username]}@#{host_string}" if !plain_mode
+        command_options.unshift(host_string)
+
+        # Invoke SSH with all our options
+        LOGGER.info("Invoking SSH: #{command_options.inspect}")
+        SafeExec.exec("ssh", *command_options)
+      end
+    end
+  end
+end