Communication abstraction. Started SSH.
This commit is contained in:
Mitchell Hashimoto
parent
396beb9faf
commit
00a31ff27b
|
|
@ -24,6 +24,7 @@ module Vagrant
|
|||
autoload :BoxCollection, 'vagrant/box_collection'
|
||||
autoload :CLI, 'vagrant/cli'
|
||||
autoload :Command, 'vagrant/command'
|
||||
autoload :Communication, 'vagrant/communication'
|
||||
autoload :Config, 'vagrant/config'
|
||||
autoload :DataStore, 'vagrant/data_store'
|
||||
autoload :Downloaders, 'vagrant/downloaders'
|
||||
|
|
|
|||
|
|
@ -0,0 +1,7 @@
|
|||
module Vagrant
|
||||
module Communication
|
||||
autoload :Base, 'vagrant/communication/base'
|
||||
|
||||
autoload :SSH, 'vagrant/communication/ssh'
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
module Vagrant
|
||||
module Communication
|
||||
# The base class for any classes that provide an API for communicating
|
||||
# with the virtual machine.
|
||||
#
|
||||
# There are various stages that require Vagrant to copy files or
|
||||
# run commands on the target system, and communication classes provide
|
||||
# the abstraction necessary to perform these tasks, via SSH or some
|
||||
# other mechanism.
|
||||
#
|
||||
# Any subclasses of this class **must** implement all of the methods
|
||||
# below.
|
||||
class Base
|
||||
# Checks if the target machine is ready for communication.
|
||||
#
|
||||
# @return [Boolean]
|
||||
def ready?
|
||||
end
|
||||
|
||||
# Upload a file to the virtual machine.
|
||||
#
|
||||
# @param [String] from Path to a file to upload.
|
||||
# @param [String] to Path to where to save this file.
|
||||
def upload(from, to)
|
||||
end
|
||||
|
||||
# Execute a command on the remote machine.
|
||||
#
|
||||
# @param [String] command Command to execute.
|
||||
# @yield [type, data] Realtime output of the command being executed.
|
||||
# @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
|
||||
# @yieldparam [String] data Data for the given output.
|
||||
# @return [Integer] Exit code of the command.
|
||||
def execute(command)
|
||||
end
|
||||
|
||||
# Execute a comand with super user privileges.
|
||||
#
|
||||
# See #execute for parameter information.
|
||||
def sudo(command)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,177 @@
|
|||
require 'timeout'
|
||||
|
||||
require 'log4r'
|
||||
require 'net/ssh'
|
||||
require 'net/scp'
|
||||
|
||||
require 'vagrant/util/file_mode'
|
||||
require 'vagrant/util/platform'
|
||||
require 'vagrant/util/retryable'
|
||||
|
||||
module Vagrant
|
||||
module Communication
|
||||
# Provides communication with the VM via SSH.
|
||||
class SSH
|
||||
include Util::Retryable
|
||||
|
||||
def initialize(vm)
|
||||
@vm = vm
|
||||
@logger = Log4r::Logger.new("vagrant::communication::ssh")
|
||||
end
|
||||
|
||||
def ready?
|
||||
@logger.debug("Checking whether SSH is ready...")
|
||||
|
||||
Timeout.timeout(@vm.config.ssh.timeout) do
|
||||
connect
|
||||
end
|
||||
|
||||
# If we reached this point then we successfully connected
|
||||
@logger.info("SSH is ready!")
|
||||
true
|
||||
rescue Timeout::Error, Errors::SSHConnectionRefused, Net::SSH::Disconnect => e
|
||||
# The above errors represent various reasons that SSH may not be
|
||||
# ready yet. Return false.
|
||||
@logger.info("SSH not up: #{e.inspect}")
|
||||
return false
|
||||
end
|
||||
|
||||
def execute(command, &block)
|
||||
# Connect via SSH and execute the command in the shell.
|
||||
connect do |connection|
|
||||
shell_execute(connection, command, &block)
|
||||
end
|
||||
end
|
||||
|
||||
def sudo(command, &block)
|
||||
# Connect ia SSH and execute the command with super-user
|
||||
# privileges in a shell.
|
||||
connect do |connection|
|
||||
shell_execute(connection, command, true, &block)
|
||||
end
|
||||
end
|
||||
|
||||
def upload(from, to)
|
||||
# Do an SCP-based upload...
|
||||
connect do |connection|
|
||||
scp = Net::SCP.new(connection)
|
||||
scp.upload!(from, to)
|
||||
end
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
# Opens an SSH connection and yields it to a block.
|
||||
def connect
|
||||
ssh_info = @vm.ssh_info
|
||||
|
||||
# Build the options we'll use to initiate the connection via Net::SSH
|
||||
opts = {
|
||||
:port => ssh_info[:port],
|
||||
:keys => [ssh_info[:private_key_path]],
|
||||
:keys_only => true,
|
||||
:user_known_hosts_file => [],
|
||||
:paranoid => false,
|
||||
:config => false,
|
||||
:forward_agent => ssh_info[:forward_agent]
|
||||
}
|
||||
|
||||
# Check that the private key permissions are valid
|
||||
check_key_permissions(ssh_info[:private_key_path])
|
||||
|
||||
# Connect to SSH, giving it a few tries
|
||||
@logger.debug("Connecting to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
|
||||
exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
|
||||
connection = retryable(:tries => @vm.config.ssh.max_tries, :on => exceptions) do
|
||||
Net::SSH.start(ssh_info[:host], ssh_info[:username], opts)
|
||||
end
|
||||
|
||||
# This is hacky but actually helps with some issues where
|
||||
# Net::SSH is simply not robust enough to handle... see
|
||||
# issue #391, #455, etc.
|
||||
sleep 4
|
||||
|
||||
# Yield the connection that is ready to be used and
|
||||
# return the value of the block
|
||||
return yield connection if block_given?
|
||||
rescue Net::SSH::AuthenticationFailed
|
||||
# This happens if authentication failed. We wrap the error in our
|
||||
# own exception.
|
||||
raise Errors::SSHAuthenticationFailed
|
||||
rescue Errno::ECONNREFUSED
|
||||
# This is raised if we failed to connect the max amount of times
|
||||
raise Errors::SSHConnectionRefused
|
||||
ensure
|
||||
# Be sure the connection is always closed
|
||||
connection.close if connection && !connection.closed?
|
||||
end
|
||||
|
||||
# Executes the command on an SSH connection within a login shell.
|
||||
def shell_execute(connection, command, sudo=false)
|
||||
exit_status = nil
|
||||
|
||||
# Determine the shell to execute. If we are using `sudo` then we
|
||||
# need to wrap the shell in a `sudo` call.
|
||||
shell = "#{@vm.config.ssh.shell} -l"
|
||||
shell = "sudo -H #{shell}" if sudo
|
||||
|
||||
# Open the channel so we can execute or command
|
||||
channel = connection.open_channel do |ch|
|
||||
ch.exec(shell) do |ch2, _|
|
||||
# Setup the channel callbacks so we can get data and exit status
|
||||
ch2.on_data do |ch3, data|
|
||||
yield :stdout, data if block_given?
|
||||
end
|
||||
|
||||
ch2.on_extended_data do |ch3, type, data|
|
||||
yield :stderr, data if block_given?
|
||||
end
|
||||
|
||||
ch2.on_request("exit-status") do |ch3, data|
|
||||
exit_status = data.read_long
|
||||
yield :exit_status, exit_status if block_given?
|
||||
end
|
||||
|
||||
# Set the terminal
|
||||
ch2.send_data "export TERM=vt100\n"
|
||||
|
||||
# Output the command
|
||||
ch2.send_data "#{command}\n"
|
||||
|
||||
# Remember to exit or this channel will hang open
|
||||
ch2.send_data "exit\n"
|
||||
end
|
||||
end
|
||||
|
||||
# Wait for the channel to complete
|
||||
channel.wait
|
||||
|
||||
# Return the final exit status
|
||||
return exit_status
|
||||
end
|
||||
|
||||
# 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?
|
||||
|
||||
@logger.debug("Checking key permissions: #{key_path}")
|
||||
stat = File.stat(key_path)
|
||||
|
||||
if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
|
||||
@logger.info("Attempting to correct key permissions to 0600")
|
||||
File.chmod(0600, key_path)
|
||||
|
||||
if Util::FileMode.from_octal(stat.mode) != "600"
|
||||
raise Errors::SSHKeyBadPermissions, :key_path => key_path
|
||||
end
|
||||
end
|
||||
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
|
||||
end
|
||||
|
|
@ -74,6 +74,28 @@ module Vagrant
|
|||
@ssh ||= SSH.new(self)
|
||||
end
|
||||
|
||||
# Returns a hash of information necessary for accessing this
|
||||
# virtual machine via SSH.
|
||||
#
|
||||
# @return [Hash]
|
||||
def ssh_info
|
||||
results = {
|
||||
:host => config.ssh.host,
|
||||
:port => config.ssh.port || driver.ssh_port,
|
||||
:username => config.ssh.username,
|
||||
:forward_agent => config.ssh.forward_agent,
|
||||
:forward_x11 => config.ssh.forward_x11
|
||||
}
|
||||
|
||||
# Determine the private key path, which is either set by the
|
||||
# configuration or uses just the built-in insecure key.
|
||||
pk_path = config.ssh.private_key_path || env.default_private_key_path
|
||||
results[:private_key_path] = File.expand_path(pk_path, env.root_path)
|
||||
|
||||
# Return the results
|
||||
return results
|
||||
end
|
||||
|
||||
# Returns the state of the VM as a symbol.
|
||||
#
|
||||
# @return [Symbol]
|
||||
|
|
|
|||
Loading…
Reference in New Issue