neutron_tempest_plugin/common/ssh.py - packaging/sources/neutron-tempest-plugin - Gitiles

 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
 #    not use this file except in compliance with the License. You may obtain
 #    a copy of the License at
 #
 #         http://www.apache.org/licenses/LICENSE-2.0
 #
 #    Unless required by applicable law or agreed to in writing, software
 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.

 import os
 import time

 from oslo_log import log
 import paramiko
 from tempest.lib.common import ssh
 from tempest.lib import exceptions

 from neutron_tempest_plugin import config


 CONF = config.CONF
 LOG = log.getLogger(__name__)


 class Client(ssh.Client):

     default_ssh_lang = 'en_US.UTF-8'

     timeout = CONF.validation.ssh_timeout

     proxy_jump_host = CONF.neutron_plugin_options.ssh_proxy_jump_host
     proxy_jump_username = CONF.neutron_plugin_options.ssh_proxy_jump_username
     proxy_jump_password = CONF.neutron_plugin_options.ssh_proxy_jump_password
     proxy_jump_keyfile = CONF.neutron_plugin_options.ssh_proxy_jump_keyfile
     proxy_jump_port = CONF.neutron_plugin_options.ssh_proxy_jump_port

     def __init__(self, host, username, password=None, timeout=None, pkey=None,
                  channel_timeout=10, look_for_keys=False, key_filename=None,
                  port=22, proxy_client=None):

         timeout = timeout or self.timeout

         if self.proxy_jump_host:
             # Perform all SSH connections passing through configured SSH server
             proxy_client = proxy_client or self.create_proxy_client(
                 timeout=timeout, channel_timeout=channel_timeout)

         super(Client, self).__init__(
             host=host, username=username, password=password, timeout=timeout,
             pkey=pkey, channel_timeout=channel_timeout,
             look_for_keys=look_for_keys, key_filename=key_filename, port=port,
             proxy_client=proxy_client)

     @classmethod
     def create_proxy_client(cls, look_for_keys=True, **kwargs):
         host = cls.proxy_jump_host
         if not host:
             # proxy_jump_host string cannot be empty or None
             raise ValueError(
                 "'proxy_jump_host' configuration option is empty.")

         # Let accept an empty string as a synonymous of default value on below
         # options
         password = cls.proxy_jump_password or None
         key_file = cls.proxy_jump_keyfile or None
         username = cls.proxy_jump_username

         # Port must be a positive integer
         port = cls.proxy_jump_port
         if port <= 0 or port > 65535:
             raise ValueError(
                 "Invalid value for 'proxy_jump_port' configuration option: "
                 "{!r}".format(port))

         login = "{username}@{host}:{port}".format(username=username, host=host,
                                                   port=port)

         if key_file:
             # expand ~ character with user HOME directory
             key_file = os.path.expanduser(key_file)
             if os.path.isfile(key_file):
                 LOG.debug("Going to create SSH connection to %r using key "
                           "file: %s", login, key_file)

             else:
                 # This message could help the user to identify a
                 # mis-configuration in tempest.conf
                 raise ValueError(
                     "Cannot find file specified as 'proxy_jump_keyfile' "
                     "option: {!r}".format(key_file))

         elif password:
             LOG.debug("Going to create SSH connection to %r using password.",
                       login)

         elif look_for_keys:
             # This message could help the user to identify a mis-configuration
             # in tempest.conf
             LOG.info("Both 'proxy_jump_password' and 'proxy_jump_keyfile' "
                      "options are empty. Going to create SSH connection to %r "
                      "looking for key file location into %r directory.",
                      login, os.path.expanduser('~/.ssh'))
         else:
             # An user that forces look_for_keys=False should really know what
             # he really wants
             LOG.warning("No authentication method provided to create an SSH "
                         "connection to %r. If it fails, then please "
                         "set 'proxy_jump_keyfile' to provide a valid SSH key "
                         "file.", login)

         return ssh.Client(
             host=host, username=username, password=password,
             look_for_keys=look_for_keys, key_filename=key_file,
             port=port, proxy_client=None, **kwargs)

     # attribute used to keep reference to opened client connection
     _client = None

     def connect(self, *args, **kwargs):
         """Creates paramiko.SSHClient and connect it to remote SSH server

         In case this method is called more times it returns the same client
         and no new SSH connection is created until close method is called.

         :returns: paramiko.Client connected to remote server.

         :raises tempest.lib.exceptions.SSHTimeout: in case it fails to connect
         to remote server.
         """
         client = self._client
         if client is None:
             client = super(Client, self)._get_ssh_connection(
                 *args, **kwargs)
             self._client = client

         return client

     # This overrides superclass protected method to make sure exec_command
     # method is going to reuse the same SSH client and connection if called
     # more times
     _get_ssh_connection = connect

     def close(self):
         """Closes connection to SSH server and cleanup resources.
         """
         client = self._client
         if client is not None:
             client.close()
             self._client = None

     def open_session(self):
         """Gets connection to SSH server and open a new paramiko.Channel

         :returns: new paramiko.Channel
         """

         client = self.connect()

         try:
             return client.get_transport().open_session()
         except paramiko.SSHException:
             # the request is rejected, the session ends prematurely or
             # there is a timeout opening a channel
             LOG.exception("Unable to open SSH session")
             raise exceptions.SSHTimeout(host=self.host,
                                         user=self.username,
                                         password=self.password)

     def execute_script(self, script, become_root=False,
                        combine_stderr=True, shell='sh -eux'):
         """Connect to remote machine and executes script.

         Implementation note: it passes script lines to shell interpreter via
         STDIN. Therefore script line number could be not available to some
         script interpreters for debugging porposes.

         :param script: script lines to be executed.

         :param become_root: executes interpreter as root with sudo.

         :param combine_stderr (bool): whenever to redirect STDERR to STDOUT so
         that output from both streams are returned together. True by default.

         :param shell: command line used to launch script interpreter. By
         default it executes Bash with -eux options enabled. This means that
         any command returning non-zero exist status or any any undefined
         variable would interrupt script execution with an error and every
         command executed by the script is going to be traced to STDERR.

         :returns output written by script to STDOUT.

         :raises tempest.lib.exceptions.SSHTimeout: in case it fails to connect
         to remote server or it fails to open a channel.

         :raises tempest.lib.exceptions.SSHExecCommandFailed: in case command
         script exits with non zero exit status.
         """

         channel = self.open_session()
         with channel:

             # Combine STOUT and STDERR to have to handle with only one stream
             channel.set_combine_stderr(combine_stderr)

             # Set default environment
             channel.update_environment({
                 # Language and encoding
                 'LC_ALL': os.environ.get('LC_ALL') or self.default_ssh_lang,
                 'LANG': os.environ.get('LANG') or self.default_ssh_lang
             })

             if become_root:
                 shell = 'sudo ' + shell
             # Spawn a Bash
             channel.exec_command(shell)

             lines_iterator = iter(script.splitlines())
             output_data = b''
             error_data = b''

             while not channel.exit_status_ready():
                 # Drain incoming data buffers
                 while channel.recv_ready():
                     output_data += channel.recv(self.buf_size)
                 while channel.recv_stderr_ready():
                     error_data += channel.recv_stderr(self.buf_size)

                 if channel.send_ready():
                     try:
                         line = next(lines_iterator)
                     except StopIteration:
                         # Finalize Bash script execution
                         channel.shutdown_write()
                     else:
                         # Send script to Bash STDIN line by line
                         channel.send((line + '\n').encode('utf-8'))
                 else:
                     time.sleep(.1)

             # Get exit status and drain incoming data buffers
             exit_status = channel.recv_exit_status()
             while channel.recv_ready():
                 output_data += channel.recv(self.buf_size)
             while channel.recv_stderr_ready():
                 error_data += channel.recv_stderr(self.buf_size)

         if exit_status != 0:
             raise exceptions.SSHExecCommandFailed(
                 command='bash', exit_status=exit_status,
                 stderr=error_data.decode('utf-8'),
                 stdout=output_data.decode('utf-8'))

         return output_data.decode('utf-8')
	# All Rights Reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License"); you may
	# not use this file except in compliance with the License. You may obtain
	# a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	# License for the specific language governing permissions and limitations
	# under the License.

	import os
	import time

	from oslo_log import log
	import paramiko
	from tempest.lib.common import ssh
	from tempest.lib import exceptions

	from neutron_tempest_plugin import config


	CONF = config.CONF
	LOG = log.getLogger(__name__)


	class Client(ssh.Client):

	default_ssh_lang = 'en_US.UTF-8'

	timeout = CONF.validation.ssh_timeout

	proxy_jump_host = CONF.neutron_plugin_options.ssh_proxy_jump_host
	proxy_jump_username = CONF.neutron_plugin_options.ssh_proxy_jump_username
	proxy_jump_password = CONF.neutron_plugin_options.ssh_proxy_jump_password
	proxy_jump_keyfile = CONF.neutron_plugin_options.ssh_proxy_jump_keyfile
	proxy_jump_port = CONF.neutron_plugin_options.ssh_proxy_jump_port

	def __init__(self, host, username, password=None, timeout=None, pkey=None,
	channel_timeout=10, look_for_keys=False, key_filename=None,
	port=22, proxy_client=None):

	timeout = timeout or self.timeout

	if self.proxy_jump_host:
	# Perform all SSH connections passing through configured SSH server
	proxy_client = proxy_client or self.create_proxy_client(
	timeout=timeout, channel_timeout=channel_timeout)

	super(Client, self).__init__(
	host=host, username=username, password=password, timeout=timeout,
	pkey=pkey, channel_timeout=channel_timeout,
	look_for_keys=look_for_keys, key_filename=key_filename, port=port,
	proxy_client=proxy_client)

	@classmethod
	def create_proxy_client(cls, look_for_keys=True, **kwargs):
	host = cls.proxy_jump_host
	if not host:
	# proxy_jump_host string cannot be empty or None
	raise ValueError(
	"'proxy_jump_host' configuration option is empty.")

	# Let accept an empty string as a synonymous of default value on below
	# options
	password = cls.proxy_jump_password or None
	key_file = cls.proxy_jump_keyfile or None
	username = cls.proxy_jump_username

	# Port must be a positive integer
	port = cls.proxy_jump_port
	if port <= 0 or port > 65535:
	raise ValueError(
	"Invalid value for 'proxy_jump_port' configuration option: "
	"{!r}".format(port))

	login = "{username}@{host}:{port}".format(username=username, host=host,
	port=port)

	if key_file:
	# expand ~ character with user HOME directory
	key_file = os.path.expanduser(key_file)
	if os.path.isfile(key_file):
	LOG.debug("Going to create SSH connection to %r using key "
	"file: %s", login, key_file)

	else:
	# This message could help the user to identify a
	# mis-configuration in tempest.conf
	raise ValueError(
	"Cannot find file specified as 'proxy_jump_keyfile' "
	"option: {!r}".format(key_file))

	elif password:
	LOG.debug("Going to create SSH connection to %r using password.",
	login)

	elif look_for_keys:
	# This message could help the user to identify a mis-configuration
	# in tempest.conf
	LOG.info("Both 'proxy_jump_password' and 'proxy_jump_keyfile' "
	"options are empty. Going to create SSH connection to %r "
	"looking for key file location into %r directory.",
	login, os.path.expanduser('~/.ssh'))
	else:
	# An user that forces look_for_keys=False should really know what
	# he really wants
	LOG.warning("No authentication method provided to create an SSH "
	"connection to %r. If it fails, then please "
	"set 'proxy_jump_keyfile' to provide a valid SSH key "
	"file.", login)

	return ssh.Client(
	host=host, username=username, password=password,
	look_for_keys=look_for_keys, key_filename=key_file,
	port=port, proxy_client=None, **kwargs)

	# attribute used to keep reference to opened client connection
	_client = None

	def connect(self, args, *kwargs):
	"""Creates paramiko.SSHClient and connect it to remote SSH server

	In case this method is called more times it returns the same client
	and no new SSH connection is created until close method is called.

	:returns: paramiko.Client connected to remote server.

	:raises tempest.lib.exceptions.SSHTimeout: in case it fails to connect
	to remote server.
	"""
	client = self._client
	if client is None:
	client = super(Client, self)._get_ssh_connection(
	args, *kwargs)
	self._client = client

	return client

	# This overrides superclass protected method to make sure exec_command
	# method is going to reuse the same SSH client and connection if called
	# more times
	_get_ssh_connection = connect

	def close(self):
	"""Closes connection to SSH server and cleanup resources.
	"""
	client = self._client
	if client is not None:
	client.close()
	self._client = None

	def open_session(self):
	"""Gets connection to SSH server and open a new paramiko.Channel

	:returns: new paramiko.Channel
	"""

	client = self.connect()

	try:
	return client.get_transport().open_session()
	except paramiko.SSHException:
	# the request is rejected, the session ends prematurely or
	# there is a timeout opening a channel
	LOG.exception("Unable to open SSH session")
	raise exceptions.SSHTimeout(host=self.host,
	user=self.username,
	password=self.password)

	def execute_script(self, script, become_root=False,
	combine_stderr=True, shell='sh -eux'):
	"""Connect to remote machine and executes script.

	Implementation note: it passes script lines to shell interpreter via
	STDIN. Therefore script line number could be not available to some
	script interpreters for debugging porposes.

	:param script: script lines to be executed.

	:param become_root: executes interpreter as root with sudo.

	:param combine_stderr (bool): whenever to redirect STDERR to STDOUT so
	that output from both streams are returned together. True by default.

	:param shell: command line used to launch script interpreter. By
	default it executes Bash with -eux options enabled. This means that
	any command returning non-zero exist status or any any undefined
	variable would interrupt script execution with an error and every
	command executed by the script is going to be traced to STDERR.

	:returns output written by script to STDOUT.

	:raises tempest.lib.exceptions.SSHTimeout: in case it fails to connect
	to remote server or it fails to open a channel.

	:raises tempest.lib.exceptions.SSHExecCommandFailed: in case command
	script exits with non zero exit status.
	"""

	channel = self.open_session()
	with channel:

	# Combine STOUT and STDERR to have to handle with only one stream
	channel.set_combine_stderr(combine_stderr)

	# Set default environment
	channel.update_environment({
	# Language and encoding
	'LC_ALL': os.environ.get('LC_ALL') or self.default_ssh_lang,
	'LANG': os.environ.get('LANG') or self.default_ssh_lang
	})

	if become_root:
	shell = 'sudo ' + shell
	# Spawn a Bash
	channel.exec_command(shell)

	lines_iterator = iter(script.splitlines())
	output_data = b''
	error_data = b''

	while not channel.exit_status_ready():
	# Drain incoming data buffers
	while channel.recv_ready():
	output_data += channel.recv(self.buf_size)
	while channel.recv_stderr_ready():
	error_data += channel.recv_stderr(self.buf_size)

	if channel.send_ready():
	try:
	line = next(lines_iterator)
	except StopIteration:
	# Finalize Bash script execution
	channel.shutdown_write()
	else:
	# Send script to Bash STDIN line by line
	channel.send((line + '\n').encode('utf-8'))
	else:
	time.sleep(.1)

	# Get exit status and drain incoming data buffers
	exit_status = channel.recv_exit_status()
	while channel.recv_ready():
	output_data += channel.recv(self.buf_size)
	while channel.recv_stderr_ready():
	error_data += channel.recv_stderr(self.buf_size)

	if exit_status != 0:
	raise exceptions.SSHExecCommandFailed(
	command='bash', exit_status=exit_status,
	stderr=error_data.decode('utf-8'),
	stdout=output_data.decode('utf-8'))

	return output_data.decode('utf-8')