vagrant 0.8.10 → 0.9.0

data/lib/vagrant/provisioners/puppet_server.rb

@@ -5,8 +5,6 @@ module Vagrant
     end
 
     class PuppetServer < Base
-      register :puppet_server
-
       class Config < Vagrant::Config::Base
         attr_accessor :puppet_server
         attr_accessor :puppet_node
@@ -19,15 +17,20 @@ module Vagrant
         end
       end
 
+      def self.config_class
+        Config
+      end
+
       def provision!
         verify_binary("puppetd")
         run_puppetd_client
       end
 
       def verify_binary(binary)
-        vm.ssh.execute do |ssh|
-          ssh.sudo!("which #{binary}", :error_class => PuppetServerError, :_key => :puppetd_not_detected, :binary => binary)
-        end
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => PuppetServerError,
+                              :error_key => :puppetd_not_detected,
+                              :binary => binary)
       end
 
       def run_puppetd_client
@@ -36,18 +39,14 @@ module Vagrant
         if config.puppet_node
           cn = config.puppet_node
         else
-          cn = env.config.vm.box
+          cn = env[:vm].config.vm.box
         end
 
-        commands = "puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
+        command = "puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
 
         env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
-
-        vm.ssh.execute do |ssh|
-          ssh.sudo!(commands) do |channel, type, data|
-            ssh.check_exit_status(data, commands) if type == :exit_status
-            env.ui.info(data) if type != :exit_status
-          end
+        env[:vm].channel.sudo(command) do |type, data|
+          env.ui.info(data)
         end
       end
     end

data/lib/vagrant/provisioners/shell.rb

@@ -1,8 +1,8 @@
+require 'tempfile'
+
 module Vagrant
   module Provisioners
     class Shell < Base
-      register :shell
-
       class Config < Vagrant::Config::Base
         attr_accessor :inline
         attr_accessor :path
@@ -10,19 +10,10 @@ module Vagrant
         attr_accessor :args
 
         def initialize
-          @inline = nil
-          @path = nil
           @upload_path = "/tmp/vagrant-shell"
-          @args = nil
         end
 
-        def expanded_path
-          Pathname.new(path).expand_path(env.root_path) if path
-        end
-
-        def validate(errors)
-          super
-
+        def validate(env, errors)
           # Validate that the parameters are properly set
           if path && inline
             errors.add(I18n.t("vagrant.provisioners.shell.path_and_inline_set"))
@@ -31,8 +22,12 @@ module Vagrant
           end
 
           # Validate the existence of a script to upload
-          if path && !expanded_path.file?
-            errors.add(I18n.t("vagrant.provisioners.shell.path_invalid", :path => expanded_path))
+          if path
+            expanded_path = Pathname.new(path).expand_path(env.root_path)
+            if !expanded_path.file?
+              errors.add(I18n.t("vagrant.provisioners.shell.path_invalid",
+                                :path => expanded_path))
+            end
           end
 
           # There needs to be a path to upload the script to
@@ -47,13 +42,17 @@ module Vagrant
         end
       end
 
+      def self.config_class
+        Config
+      end
+
       # This method yields the path to a script to upload and execute
       # on the remote server. This method will properly clean up the
       # script file if needed.
       def with_script_file
         if config.path
           # Just yield the path to that file...
-          yield config.expanded_path
+          yield Pathname.new(config.path).expand_path(env[:root_path])
           return
         end
 
@@ -73,20 +72,21 @@ module Vagrant
       def provision!
         args = ""
         args = " #{config.args}" if config.args
-        commands = ["chmod +x #{config.upload_path}", "#{config.upload_path}#{args}"]
+        command = "chmod +x #{config.upload_path} && #{config.upload_path}#{args}"
 
         with_script_file do |path|
           # Upload the script to the VM
-          vm.ssh.upload!(path.to_s, config.upload_path)
+          env[:vm].channel.upload(path.to_s, config.upload_path)
 
           # Execute it with sudo
-          vm.ssh.execute do |ssh|
-            ssh.sudo!(commands) do |ch, type, data|
-              if type == :exit_status
-                ssh.check_exit_status(data, commands)
-              else
-                env.ui.info(data)
-              end
+          env[:vm].channel.sudo(command) do |type, data|
+            if [:stderr, :stdout].include?(type)
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              # Note: Be sure to chomp the data to avoid the newlines that the
+              # Chef outputs.
+              env[:ui].info(data.chomp, :color => color, :prefix => false)
             end
           end
         end

data/lib/vagrant/registry.rb

@@ -0,0 +1,49 @@
+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.
+  class Registry
+    def initialize
+      @actions = {}
+    end
+
+    # Register a callable by key.
+    #
+    # 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
+    end
+
+    # Get an action by the given key.
+    #
+    # This will evaluate the block given to `register` and return the resulting
+    # action stack.
+    def get(key)
+      return nil if !@actions.has_key?(key)
+      @actions[key].call
+    end
+
+    # Iterate over the keyspace.
+    def each(&block)
+      @actions.each do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Converts this registry to a hash
+    def to_hash
+      result = {}
+      self.each do |key, value|
+        result[key] = value
+      end
+
+      result
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -1,194 +1,123 @@
-require 'net/ssh'
-require 'net/scp'
+require 'log4r'
+
+require 'vagrant/util/file_mode'
+require 'vagrant/util/platform'
+require 'vagrant/util/safe_exec'
 
 module Vagrant
-  # Manages SSH access to a specific environment. Allows an environment to
-  # replace the process with SSH itself, run a specific set of commands,
-  # upload files, or even check if a host is up.
+  # Manages SSH connection information as well as allows opening an
+  # SSH connection.
   class SSH
-    # Autoload this guy because he is really only used in one location
-    # and not for every Vagrant command.
-    autoload :Session, 'vagrant/ssh/session'
-
-    include Util::Retryable
     include Util::SafeExec
 
-    # Reference back up to the environment which this SSH object belongs
-    # to
-    attr_accessor :env
+    def initialize(vm)
+      @vm     = vm
+      @logger = Log4r::Logger.new("vagrant::ssh")
+    end
 
-    def initialize(environment)
-      @env = environment
+    # Returns a hash of information necessary for accessing this
+    # virtual machine via SSH.
+    #
+    # @return [Hash]
+    def info
+      results = {
+        :host          => @vm.config.ssh.host,
+        :port          => @vm.config.ssh.port || @vm.driver.ssh_port(@vm.config.ssh.guest_port),
+        :username      => @vm.config.ssh.username,
+        :forward_agent => @vm.config.ssh.forward_agent,
+        :forward_x11   => @vm.config.ssh.forward_x11
+      }
+
+      # This can happen if no port is set and for some reason Vagrant
+      # can't detect an SSH port.
+      raise Errors::SSHPortNotDetected if !results[:port]
+
+      # Determine the private key path, which is either set by the
+      # configuration or uses just the built-in insecure key.
+      pk_path = @vm.config.ssh.private_key_path || @vm.env.default_private_key_path
+      results[:private_key_path] = File.expand_path(pk_path, @vm.env.root_path)
+
+      # We need to check and fix the private key permissions
+      # to make sure that SSH gets a key with 0600 perms.
+      check_key_permissions(results[:private_key_path])
+
+      # Return the results
+      return results
     end
 
     # Connects to the environment's virtual machine, replacing the ruby
-    # process with an SSH process. This method optionally takes a hash
-    # of options which override the configuration values.
-    def connect(opts={})
+    # process with an SSH process.
+    #
+    # @param [Hash] opts Options hash
+    # @options opts [Boolean] :plain_mode If True, doesn't authenticate with
+    #   the machine, only connects, allowing the user to connect.
+    def exec(opts={})
+      # Get the SSH information and cache it here
+      ssh_info = info
+
       if Util::Platform.windows?
-        raise Errors::SSHUnavailableWindows, :key_path => env.config.ssh.private_key_path,
-                                             :ssh_port => port(opts)
+        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 if !Kernel.system("which ssh > /dev/null 2>&1")
 
-      options = {}
-      options[:port] = port(opts)
-      [:host, :username, :private_key_path].each do |param|
-        options[param] = opts[param] || env.config.ssh.send(param)
-      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]
 
-      check_key_permissions(options[:private_key_path])
+      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]}", "-o UserKnownHostsFile=/dev/null",
                          "-o StrictHostKeyChecking=no", "-o IdentitiesOnly=yes",
-                         "-i #{options[:private_key_path]}", "-o LogLevel=ERROR"]
-      command_options << "-o ForwardAgent=yes" if env.config.ssh.forward_agent
+                         "-o LogLevel=ERROR"]
+      command_options << "-i #{options[:private_key_path]}" if !plain_mode
+      command_options << "-o ForwardAgent=yes" if ssh_info[:forward_agent]
+
+      # If there are extra options, then we append those
+      command_options.concat(opts[:extra_args]) if opts[:extra_args]
 
-      if env.config.ssh.forward_x11
+      if ssh_info[:forward_x11]
         # Both are required so that no warnings are shown regarding X11
         command_options << "-o ForwardX11=yes"
         command_options << "-o ForwardX11Trusted=yes"
       end
 
-      command = "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip
-      env.logger.info("ssh") { "Invoking SSH: #{command}" }
+      host_string = options[:host]
+      host_string = "#{options[:username]}@#{host_string}" if !plain_mode
+      command = "ssh #{command_options.join(" ")} #{host_string}".strip
+      @logger.info("Invoking SSH: #{command}")
       safe_exec(command)
     end
 
-    # Opens an SSH connection to this environment's virtual machine and yields
-    # a Net::SSH object which can be used to execute remote commands.
-    def execute(opts={})
-      # Check the key permissions to avoid SSH hangs
-      check_key_permissions(env.config.ssh.private_key_path)
-
-      # Merge in any additional options
-      opts = opts.dup
-      opts[:forward_agent] = true if env.config.ssh.forward_agent
-      opts[:port] ||= port
-
-      env.logger.info("ssh") { "Connecting to SSH: #{env.config.ssh.host} #{opts[:port]}" }
-
-      # The exceptions which are acceptable to retry on during
-      # attempts to connect to SSH
-      exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
-
-      # Connect to SSH and gather the session
-      session = retryable(:tries => env.config.ssh.max_tries, :on => exceptions) do
-        connection = Net::SSH.start(env.config.ssh.host,
-                                    env.config.ssh.username,
-                                    opts.merge( :keys => [env.config.ssh.private_key_path],
-                                                :keys_only => true,
-                                                :user_known_hosts_file => [],
-                                                :paranoid => false,
-                                                :config => false))
-        SSH::Session.new(connection, env)
-      end
-
-      # Yield our session for executing
-      return yield session if block_given?
-    rescue Errno::ECONNREFUSED
-      raise Errors::SSHConnectionRefused
-    end
-
-    # Uploads a file from `from` to `to`. `from` is expected to be a filename
-    # or StringIO, and `to` is expected to be a path. This method simply forwards
-    # the arguments to `Net::SCP#upload!` so view that for more information.
-    def upload!(from, to)
-      retryable(:tries => 5, :on => IOError) do
-        execute do |ssh|
-          scp = Net::SCP.new(ssh.session)
-          scp.upload!(from, to)
-        end
-      end
-    end
-
-    # Checks if this environment's machine is up (i.e. responding to SSH).
-    #
-    # @return [Boolean]
-    def up?
-      # We have to determine the port outside of the block since it uses
-      # API calls which can only be used from the main thread in JRuby on
-      # Windows
-      ssh_port = port
-
-      require 'timeout'
-      Timeout.timeout(env.config.ssh.timeout) do
-        execute(:timeout => env.config.ssh.timeout, :port => ssh_port) { |ssh| }
-      end
-
-      true
-    rescue Net::SSH::AuthenticationFailed
-      raise Errors::SSHAuthenticationFailed
-    rescue Timeout::Error, Errno::ECONNREFUSED, Net::SSH::Disconnect,
-           Errors::SSHConnectionRefused
-      return false
-    end
-
-    # Checks the file permissions for the private key, resetting them
-    # if needed, or on failure erroring.
+    # Checks the file permissions for a private key, resetting them
+    # if needed.
     def check_key_permissions(key_path)
       # Windows systems don't have this issue
       return if Util::Platform.windows?
 
-      env.logger.info("ssh") { "Checking key permissions: #{key_path}" }
-
+      @logger.debug("Checking key permissions: #{key_path}")
       stat = File.stat(key_path)
 
-      if stat.owned? && file_perms(key_path) != "600"
-        env.logger.info("ssh") { "Attempting to correct key permissions to 0600" }
-
+      if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
+        @logger.info("Attempting to correct key permissions to 0600")
         File.chmod(0600, key_path)
-        raise Errors::SSHKeyBadPermissions, :key_path => key_path if file_perms(key_path) != "600"
-      end
-    rescue Errno::EPERM
-      # This shouldn't happen since we verify we own the file, but just
-      # in case.
-      raise Errors::SSHKeyBadPermissions, :key_path => key_path
-    end
 
-    # Returns the file permissions of a given file. This is fairly unix specific
-    # and probably doesn't belong in this class. Will be refactored out later.
-    def file_perms(path)
-      perms = sprintf("%o", File.stat(path).mode)
-      perms.reverse[0..2].reverse
-    end
-
-    # Returns the port which is either given in the options hash or taken from
-    # the config by finding it in the forwarded ports hash based on the
-    # `config.ssh.forwarded_port_key`.
-    def port(opts={})
-      # Check if port was specified in options hash
-      return opts[:port] if opts[:port]
-
-      # Check if a port was specified in the config
-      return env.config.ssh.port if env.config.ssh.port
-
-      # Check if we have an SSH forwarded port
-      pnum_by_name = nil
-      pnum_by_destination = nil
-      env.vm.vm.network_adapters.each do |na|
-        # Look for the port number by name...
-        pnum_by_name = na.nat_driver.forwarded_ports.detect do |fp|
-          fp.name == env.config.ssh.forwarded_port_key
+        if Util::FileMode.from_octal(stat.mode) != "600"
+          raise Errors::SSHKeyBadPermissions, :key_path => key_path
         end
-
-        # Look for the port number by destination...
-        pnum_by_destination = na.nat_driver.forwarded_ports.detect do |fp|
-          fp.guestport == env.config.ssh.forwarded_port_destination
-        end
-
-        # pnum_by_name is what we're looking for here, so break early
-        # if we have it.
-        break if pnum_by_name
       end
-
-      return pnum_by_name.hostport if pnum_by_name
-      return pnum_by_destination.hostport if pnum_by_destination
-
-      # This should NEVER happen.
-      raise Errors::SSHPortNotDetected
+    rescue Errno::EPERM
+      # This shouldn't happen since we verified we own the file, but
+      # it is possible in theory, so we raise an error.
+      raise Errors::SSHKeyBadPermissions, :key_path => key_path
     end
   end
 end