def test_stop_start_instance(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(KeyName=key_name,
ImageId=CONF.aws.image_id_ubuntu,
SecurityGroups=[sec_group_name])
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address,
CONF.aws.image_user_ubuntu,
pkey=pkey)
ssh_client.exec_command('last -x')
self.client.stop_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped'))
self.client.start_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
# Amazon can change auto-assigned public ip
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address,
CONF.aws.image_user_ubuntu,
pkey=pkey)
data = ssh_client.exec_command('last -x')
self.assertIn("shutdown", data)
def test_pkey_calls_paramiko_RSAKey(self, cs_mock, rsa_mock):
cs_mock.return_value = mock.sentinel.csio
pkey = 'mykey'
ssh.Client('localhost', 'root', pkey=pkey)
rsa_mock.assert_called_once_with(mock.sentinel.csio)
cs_mock.assert_called_once_with('mykey')
rsa_mock.reset_mock()
cs_mock.reset_mock()
pkey = mock.sentinel.pkey
# Shouldn't call out to load a file from RSAKey, since
# a sentinel isn't a basestring...
ssh.Client('localhost', 'root', pkey=pkey)
self.assertEqual(0, rsa_mock.call_count)
self.assertEqual(0, cs_mock.call_count)
def get_remote_client(self, ip, username=None):
"""Get a SSH client to a remote server
:param server_or_ip: a server object as returned by Tempest compute
client or an IP address to connect to
:param username: name of the Linux account on the remote server
:return: a RemoteClient object
"""
if username is None:
username = CONF.validation.image_ssh_user
password = CONF.validation.image_ssh_password
linux_client = ssh.Client(ip, username, password)
try:
linux_client.test_connection_auth()
except Exception as e:
message = ('Initializing SSH connection to %(ip)s failed. '
'Error: %(error)s' % {
'ip': ip,
'error': e
})
caller = misc_utils.find_test_caller()
if caller:
message = '(%s) %s' % (caller, message)
LOG.exception(message)
raise
return linux_client
def execute(cmd,
action,
flags='',
params='',
fail_ok=False,
merge_stderr=False):
"""Executes specified command for the given action."""
LOG.info("Executing CLI: '%s %s %s'", cmd, action, params)
LOG.debug("using flags: '%s'", flags)
ssh_timeout = 10
ssh_channel_timeout = 10
uri = CONF.identity.uri
uri_object = urlparse.urlparse(uri)
netloc_parts = uri_object.netloc.rsplit(':')
ip_address = netloc_parts[0]
username = CONF.nuage_sut.controller_user
password = CONF.nuage_sut.controller_password
ssh_client = ssh.Client(ip_address,
username,
password,
ssh_timeout,
channel_timeout=ssh_channel_timeout)
cmd = ' '.join([os.path.join(cmd), flags, action, params])
LOG.debug("running: '%s'" % cmd)
response = ssh_client.exec_command(cmd)
LOG.debug("Response: \n'%s'" % response)
return response
def execute(cmd):
"""Executes specified command for the given action."""
LOG.info("Executing: '%s" % cmd)
ssh_timeout = 10
ssh_channel_timeout = 10
# TODO: derive from tempest.conf or nuage.conf
uri = CONF.identity.uri
uri_object = urlparse.urlparse(uri)
netloc_parts = uri_object.netloc.rsplit(':')
ip_address = netloc_parts[0]
username = CONF.nuage_sut.controller_user
password = CONF.nuage_sut.controller_password
ssh_client = ssh.Client(ip_address,
username,
password,
ssh_timeout,
channel_timeout=ssh_channel_timeout)
response = ssh_client.exec_command(cmd)
LOG.debug("Response: \n'%s'" % response)
return response
def _test_vpnaas(self):
# RIGHT
right_server = self._create_server(network=self._right_network,
create_floating_ip=False)
right_ip = self._get_ip_on_subnet_for_port(
right_server['port'], self._right_subnet['id'])
# LEFT
left_server = self._create_server()
ssh_client = ssh.Client(left_server['fip']['floating_ip_address'],
CONF.validation.image_ssh_user,
pkey=self.keypair['private_key'],
ssh_key_type=CONF.validation.ssh_key_type)
# check LEFT -> RIGHT connectivity via VPN
self.check_remote_connectivity(ssh_client, right_ip,
should_succeed=False)
self._setup_vpn()
self.check_remote_connectivity(ssh_client, right_ip)
# Test VPN traffic and floating IP traffic don't interfere each other.
if not self.inner_ipv6:
# Assign a floating-ip and check connectivity.
# This is NOT via VPN.
fip = self.create_and_associate_floatingip(
right_server['port']['id'])
self.check_remote_connectivity(ssh_client,
fip['floating_ip_address'])
# check LEFT -> RIGHT connectivity via VPN again, to ensure
# the above floating-ip doesn't interfere the traffic.
self.check_remote_connectivity(ssh_client, right_ip)
def __init__(self, ip_address, username, password=None, pkey=None):
ssh_timeout = CONF.validation.ssh_timeout
connect_timeout = CONF.validation.connect_timeout
self.ssh_client = ssh.Client(ip_address, username, password,
ssh_timeout, pkey=pkey,
channel_timeout=connect_timeout)
def test_exec_command(self):
chan_mock, poll_mock, select_mock, client_mock = (
self._set_mocks_for_select([[1, 0, 0]], True))
chan_mock.recv_exit_status.return_value = 0
chan_mock.recv.return_value = b''
chan_mock.recv_stderr.return_value = b''
client = ssh.Client('localhost', 'root', timeout=2)
client.exec_command("test")
chan_mock.fileno.assert_called_once_with()
chan_mock.exec_command.assert_called_once_with("test")
chan_mock.shutdown_write.assert_called_once_with()
select_mock.assert_called_once_with()
poll_mock.register.assert_called_once_with(chan_mock,
self.SELECT_POLLIN)
poll_mock.poll.assert_called_once_with(10)
chan_mock.recv_ready.assert_called_once_with()
chan_mock.recv.assert_called_once_with(1024)
chan_mock.recv_stderr_ready.assert_called_once_with()
chan_mock.recv_stderr.assert_called_once_with(1024)
chan_mock.recv_exit_status.assert_called_once_with()
client_mock.close.assert_called_once_with()
def test_compare_console_output(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(KeyName=key_name,
SecurityGroups=[sec_group_name])
data_to_check = data_utils.rand_uuid()
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user, pkey=pkey)
cmd = 'sudo sh -c "echo \\"%s\\" >/dev/console"' % data_to_check
ssh_client.exec_command(cmd)
waiter = base.EC2Waiter(self.client.get_console_output)
waiter.wait_no_exception(InstanceId=instance_id)
def _compare_console_output():
data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data)
self.assertIn(data_to_check, data['Output'])
waiter = base.EC2Waiter(_compare_console_output)
waiter.wait_no_exception()
def test_exec_command_no_select(self):
gsc_mock = self.patch('tempest.lib.common.ssh.Client.'
'_get_ssh_connection')
csp_mock = self.patch('tempest.lib.common.ssh.Client._can_system_poll')
csp_mock.return_value = False
select_mock = self.patch('select.poll', create=True)
client_mock = mock.MagicMock()
tran_mock = mock.MagicMock()
chan_mock = mock.MagicMock()
# Test for proper reading of STDOUT and STDERROR
gsc_mock.return_value = client_mock
client_mock.get_transport.return_value = tran_mock
tran_mock.open_session().__enter__.return_value = chan_mock
chan_mock.recv_exit_status.return_value = 0
std_out_mock = mock.MagicMock(StringIO)
std_err_mock = mock.MagicMock(StringIO)
chan_mock.makefile.return_value = std_out_mock
chan_mock.makefile_stderr.return_value = std_err_mock
client = ssh.Client('localhost', 'root', timeout=2)
client.exec_command("test")
chan_mock.makefile.assert_called_once_with('rb', 1024)
chan_mock.makefile_stderr.assert_called_once_with('rb', 1024)
std_out_mock.read.assert_called_once_with()
std_err_mock.read.assert_called_once_with()
self.assertFalse(select_mock.called)
def test_metadata(self):
key_name = data_utils.rand_name('testkey')
self.client.import_key_pair(KeyName=key_name,
PublicKeyMaterial=PUBLIC_KEY_MATERIAL)
self.addResourceCleanUp(self.client.delete_key_pair, KeyName=key_name)
sec_group_name = self.create_standard_security_group()
user_data = six.text_type(data_utils.rand_uuid()) + six.unichr(1071)
instance_id = self.run_instance(KeyName=key_name, UserData=user_data,
SecurityGroups=[sec_group_name])
data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='userData')
self.assertEqual(
data['UserData']['Value'],
base64.b64encode(user_data.encode("utf-8")).decode("utf-8"))
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user,
pkey=PRIVATE_KEY_MATERIAL)
url = 'http://169.254.169.254'
data = ssh_client.exec_command('curl %s/latest/user-data' % url)
if isinstance(data, six.binary_type):
data = data.decode("utf-8")
self.assertEqual(user_data, data)
data = ssh_client.exec_command('curl %s/latest/meta-data/ami-id' % url)
self.assertEqual(CONF.aws.image_id, data)
data = ssh_client.exec_command(
'curl %s/latest/meta-data/public-keys/0/openssh-key' % url)
# compare only keys. without 'sha-rsa' and owner
self.assertEqual(PUBLIC_KEY_MATERIAL.split()[1], data.split()[1])
def _test_instances(self, subnet_size):
cidr = netaddr.IPNetwork('10.20.0.0/8')
cidr.prefixlen = subnet_size
vpc_id, subnet_id = self.create_vpc_and_subnet(str(cidr))
gw_id = self.create_and_attach_internet_gateway(vpc_id)
self.prepare_vpc_default_security_group(vpc_id)
self.prepare_route(vpc_id, gw_id)
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
first_ip = str(netaddr.IPAddress(cidr.first + 4))
last_ip = str(netaddr.IPAddress(cidr.last - 1))
instance_id1 = self.run_instance(KeyName=key_name,
SubnetId=subnet_id,
PrivateIpAddress=first_ip)
instance_id2 = self.run_instance(KeyName=key_name,
SubnetId=subnet_id,
PrivateIpAddress=last_ip)
instance = self.get_instance(instance_id1)
self.assertEqual(first_ip, instance['PrivateIpAddress'])
instance = self.get_instance(instance_id2)
self.assertEqual(last_ip, instance['PrivateIpAddress'])
ip_address = self.get_instance_ip(instance_id1)
ssh_client = ssh.Client(ip_address, CONF.aws.image_user, pkey=pkey)
waiter = base.EC2Waiter(ssh_client.exec_command)
waiter.wait_no_exception('ping %s -c 1' % last_ip)
def test_get_ssh_connection(self):
c_mock, aa_mock, client_mock = self._set_ssh_connection_mocks()
s_mock = self.patch('time.sleep')
c_mock.return_value = client_mock
aa_mock.return_value = mock.sentinel.aa
# Test normal case for successful connection on first try
client = ssh.Client('localhost', 'root', timeout=2)
client._get_ssh_connection(sleep=1)
aa_mock.assert_called_once_with()
client_mock.set_missing_host_key_policy.assert_called_once_with(
mock.sentinel.aa)
expected_connect = [
mock.call('localhost',
port=22,
username='******',
pkey=None,
key_filename=None,
look_for_keys=False,
timeout=10.0,
password=None,
sock=None)
]
self.assertEqual(expected_connect, client_mock.connect.mock_calls)
self.assertEqual(0, s_mock.call_count)
def test_reboot_instance(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
sec_group_name = self.create_standard_security_group()
instance_id = self.run_instance(KeyName=key_name,
ImageId=CONF.aws.image_id_ubuntu,
SecurityGroups=[sec_group_name])
ip_address = self.get_instance_ip(instance_id)
ssh_client = ssh.Client(ip_address,
CONF.aws.image_user_ubuntu,
pkey=pkey)
last_lines = ssh_client.exec_command('last -x').split('\n')
self.client.reboot_instances(InstanceIds=[instance_id])
def _last_state():
current = ssh_client.exec_command('last -x').split('\n')
if len(current) > len(last_lines):
return
raise Exception()
waiter = base.EC2Waiter(_last_state)
waiter.wait_no_exception()
data = ssh_client.exec_command('last -x')
self.assertIn("shutdown", data)
def test_vpnaas(self):
# RIGHT
right_server = self._create_server(network=self._right_network,
create_floating_ip=False)
# LEFT
left_server = self._create_server()
ssh_client = ssh.Client(left_server['fip']['floating_ip_address'],
CONF.validation.image_ssh_user,
pkey=self.keypair['private_key'])
# check LEFT -> RIGHT connectivity via VPN
self.check_remote_connectivity(
ssh_client,
right_server['port']['fixed_ips'][0]['ip_address'],
should_succeed=False)
self._setup_vpn()
self.check_remote_connectivity(
ssh_client, right_server['port']['fixed_ips'][0]['ip_address'])
# Assign a floating-ip and check connectivity.
# This is NOT via VPN.
fip = self.create_and_associate_floatingip(right_server['port']['id'])
self.check_remote_connectivity(ssh_client, fip['floating_ip_address'])
# check LEFT -> RIGHT connectivity via VPN again, to ensure
# the above floating-ip doesn't interfere the traffic.
self.check_remote_connectivity(
ssh_client, right_server['port']['fixed_ips'][0]['ip_address'])
def __init__(self, ip_address, username, password=None, pkey=None,
server=None, servers_client=None, ssh_timeout=300,
connect_timeout=60, console_output_enabled=True,
ssh_shell_prologue="set -eu -o pipefail; PATH=$PATH:/sbin;",
ping_count=1, ping_size=56, ssh_key_type='rsa'):
"""Executes commands in a VM over ssh
:param ip_address: IP address to ssh to
:param username: Ssh username
:param password: Ssh password
:param pkey: Ssh public key
:param server: Server dict, used for debugging purposes
:param servers_client: Servers client, used for debugging purposes
:param ssh_timeout: Timeout in seconds to wait for the ssh banner
:param connect_timeout: Timeout in seconds to wait for TCP connection
:param console_output_enabled: Support serial console output?
:param ssh_shell_prologue: Shell fragments to use before command
:param ping_count: Number of ping packets
:param ping_size: Packet size for ping packets
:param ssh_key_type: ssh key type (rsa, ecdsa)
"""
self.server = server
self.servers_client = servers_client
self.ip_address = ip_address
self.console_output_enabled = console_output_enabled
self.ssh_shell_prologue = ssh_shell_prologue
self.ping_count = ping_count
self.ping_size = ping_size
self.ssh_key_type = ssh_key_type
self.ssh_client = ssh.Client(ip_address, username, password,
ssh_timeout, pkey=pkey,
channel_timeout=connect_timeout,
ssh_key_type=ssh_key_type)
def __init__(self,
ip_address,
username,
password=None,
pkey=None,
server=None,
servers_client=None):
"""Executes commands in a VM over ssh
:param ip_address: IP address to ssh to
:param username: ssh username
:param password: ssh password (optional)
:param pkey: ssh public key (optional)
:param server: server dict, used for debugging purposes
:param servers_client: servers client, used for debugging purposes
"""
self.server = server
self.servers_client = servers_client
self.log_console = CONF.compute_feature_enabled.console_output
kwargs = {}
try:
kwargs['ssh_key_type'] = CONF.validation.ssh_key_type
except Exception:
# Not all versions of tempest support the
# "validation.ssh_key_type" config option
pass
self.ssh_client = ssh.Client(ip_address,
username,
password,
pkey=pkey,
**kwargs)
def _create_server_with_port_and_subport(self, vlan_network, vlan_tag):
parent_port = self.create_port(
self.network,
security_groups=[self.secgroup['security_group']['id']])
port_for_subport = self.create_port(
vlan_network,
security_groups=[self.secgroup['security_group']['id']],
mac_address=parent_port['mac_address'])
subport = {
'port_id': port_for_subport['id'],
'segmentation_type': 'vlan',
'segmentation_id': vlan_tag
}
trunk = self.client.create_trunk(parent_port['id'],
subports=[subport])['trunk']
server, fip = self._create_server_with_fip(parent_port['id'])
self.addCleanup(self._detach_and_delete_trunk, server, trunk)
server_ssh_client = ssh.Client(fip['floating_ip_address'],
CONF.validation.image_ssh_user,
pkey=self.keypair['private_key'])
return {
'server': server,
'fip': fip,
'ssh_client': server_ssh_client,
'subport': port_for_subport,
}
def __init__(self,
ip_address,
username,
password=None,
pkey=None,
server=None,
servers_client=None):
"""Executes commands in a VM over ssh
:param ip_address: IP address to ssh to
:param username: ssh username
:param password: ssh password (optional)
:param pkey: ssh public key (optional)
:param server: server dict, used for debugging purposes
:param servers_client: servers client, used for debugging purposes
"""
self.server = server
self.servers_client = servers_client
ssh_timeout = CONF.validation.ssh_timeout
connect_timeout = CONF.validation.connect_timeout
self.log_console = CONF.compute_feature_enabled.console_output
self.ssh_client = ssh.Client(ip_address,
username,
password,
ssh_timeout,
pkey=pkey,
channel_timeout=connect_timeout)
def test_get_ssh_connection_over_ssh(self):
c_mock, aa_mock, client_mock = self._set_ssh_connection_mocks()
proxy_client_mock = mock.MagicMock()
proxy_client_mock.connect.return_value = True
s_mock = self.patch('time.sleep')
c_mock.side_effect = [client_mock, proxy_client_mock]
aa_mock.return_value = mock.sentinel.aa
proxy_client = ssh.Client('proxy-host', 'proxy-user', timeout=2)
client = ssh.Client('localhost',
'root',
timeout=2,
proxy_client=proxy_client)
client._get_ssh_connection(sleep=1)
aa_mock.assert_has_calls([mock.call(), mock.call()])
proxy_client_mock.set_missing_host_key_policy.assert_called_once_with(
mock.sentinel.aa)
proxy_expected_connect = [
mock.call('proxy-host',
port=22,
username='******',
pkey=None,
key_filename=None,
look_for_keys=False,
timeout=10.0,
password=None,
sock=None)
]
self.assertEqual(proxy_expected_connect,
proxy_client_mock.connect.mock_calls)
client_mock.set_missing_host_key_policy.assert_called_once_with(
mock.sentinel.aa)
expected_connect = [
mock.call('localhost',
port=22,
username='******',
pkey=None,
key_filename=None,
look_for_keys=False,
timeout=10.0,
password=None,
sock=proxy_client_mock.get_transport().open_session())
]
self.assertEqual(expected_connect, client_mock.connect.mock_calls)
self.assertEqual(0, s_mock.call_count)
def check_connectivity(self, host, ssh_user, ssh_key, servers=None):
ssh_client = ssh.Client(host, ssh_user, pkey=ssh_key)
try:
ssh_client.test_connection_auth()
except lib_exc.SSHTimeout as ssh_e:
LOG.debug(ssh_e)
self._log_console_output(servers)
raise
def do_ssh(command, host, ssh_user, ssh_key=None):
ssh_client = ssh.Client(host, ssh_user, key_filename=ssh_key)
try:
return ssh_client.exec_command(command)
except exceptions.SSHExecCommandFailed:
LOG.error('do_ssh raise exception. command:%s, host:%s.'
% (command, host))
return None
def test_get_ssh_connection_two_attemps(self, sleep_mock):
c_mock, aa_mock, client_mock = self._set_ssh_connection_mocks()
c_mock.return_value = client_mock
client_mock.connect.side_effect = [socket.error, mock.MagicMock()]
client = ssh.Client('localhost', 'root', timeout=1)
client._get_ssh_connection(sleep=1)
# We slept 2 seconds: because sleep is "1" and backoff is "1" too
sleep_mock.assert_called_once_with(2)
self.assertEqual(2, client_mock.connect.call_count)
def test_exec_good_command_output(self):
chan_mock, poll_mock, _ = self._set_mocks_for_select([1, 0, 0])
closed_prop = mock.PropertyMock(return_value=True)
type(chan_mock).closed = closed_prop
chan_mock.recv_exit_status.return_value = 0
chan_mock.recv.side_effect = [self._utf8_bytes[0:1],
self._utf8_bytes[1:], b'R', b'']
chan_mock.recv_stderr.return_value = b''
client = ssh.Client('localhost', 'root', timeout=2)
out_data = client.exec_command("test")
self.assertEqual(self._utf8_string + 'R', out_data)
def test_exec_bad_command_output(self):
chan_mock, poll_mock, _ = self._set_mocks_for_select([1, 0, 0])
closed_prop = mock.PropertyMock(return_value=True)
type(chan_mock).closed = closed_prop
chan_mock.recv_exit_status.return_value = 1
chan_mock.recv.return_value = b''
chan_mock.recv_stderr.side_effect = [b'R', self._utf8_bytes[0:1],
self._utf8_bytes[1:], b'']
client = ssh.Client('localhost', 'root', timeout=2)
exc = self.assertRaises(exceptions.SSHExecCommandFailed,
client.exec_command, "test")
self.assertIn('R' + self._utf8_string, six.text_type(exc))
def test_timeout_in_exec_command(self):
chan_mock, poll_mock, _ = self._set_mocks_for_select([0, 0, 0], True)
# Test for a timeout condition immediately raised
client = ssh.Client('localhost', 'root', timeout=2)
with testtools.ExpectedException(exceptions.TimeoutException):
client.exec_command("test")
chan_mock.fileno.assert_called_once_with()
chan_mock.exec_command.assert_called_once_with("test")
chan_mock.shutdown_write.assert_called_once_with()
poll_mock.register.assert_called_once_with(chan_mock,
self.SELECT_POLLIN)
poll_mock.poll.assert_called_once_with(10)
def _run_command_on_node(self, node_ip, command):
host_ip = node_ip
if self.proxy:
host_ip = self.proxy
command = ("echo '{pkey}' > {filename} && chmod 600 {filename} && "
"ssh -o StrictHostKeyChecking=no {ip} -i {filename} "
"'{cmd}' && rm {filename}".format(
pkey=self.private_key,
filename='scenario.pem',
ip=node_ip,
cmd=command))
ssh_session = connection.Client(host_ip,
self.testcase['ssh_username'],
pkey=self.private_key)
return ssh_session.exec_command(command)
def test_qos(self):
"""This is a basic test that check that a QoS policy with
a bandwidth limit rule is applied correctly by sending
a file from the instance to the test node.
Then calculating the bandwidth every ~1 sec by the number of bits
received / elapsed time.
"""
NC_PORT = 1234
self.setup_network_and_server()
self.check_connectivity(self.fip['floating_ip_address'],
CONF.validation.image_ssh_user,
self.keypair['private_key'])
rulesets = [{'protocol': 'tcp',
'direction': 'ingress',
'port_range_min': NC_PORT,
'port_range_max': NC_PORT,
'remote_ip_prefix': '0.0.0.0/0'}]
self.create_secgroup_rules(rulesets,
self.security_groups[-1]['id'])
ssh_client = ssh.Client(self.fip['floating_ip_address'],
CONF.validation.image_ssh_user,
pkey=self.keypair['private_key'])
policy = self.admin_manager.network_client.create_qos_policy(
name='test-policy',
description='test-qos-policy',
shared=True)
policy_id = policy['policy']['id']
self.admin_manager.network_client.create_bandwidth_limit_rule(
policy_id, max_kbps=constants.LIMIT_KILO_BITS_PER_SECOND,
max_burst_kbps=constants.LIMIT_KILO_BITS_PER_SECOND)
port = self.client.list_ports(network_id=self.network['id'],
device_id=self.server[
'server']['id'])['ports'][0]
self.admin_manager.network_client.update_port(port['id'],
qos_policy_id=policy_id)
self._create_file_for_bw_tests(ssh_client)
utils.wait_until_true(lambda: self._check_bw(
ssh_client,
self.fip['floating_ip_address'],
port=NC_PORT),
timeout=120,
sleep=1)
def check_connectivity(self,
ip_address,
username=None,
private_key=None,
should_connect=True,
check_icmp=True,
check_ssh=True,
check_reverse_icmp_ip=None,
should_reverse_connect=True):
if should_connect:
msg = "Timed out waiting for %s to become reachable" % ip_address
else:
msg = "ip address %s is reachable" % ip_address
if check_icmp:
ok = self.ping_ip_address(ip_address,
should_succeed=should_connect)
self.assertTrue(ok, msg=msg)
if check_ssh:
connect_timeout = CONF.validation.connect_timeout
kwargs = {}
if not should_connect:
# Use a shorter timeout for negative case
kwargs['timeout'] = 1
try:
client = ssh.Client(ip_address,
username,
pkey=private_key,
channel_timeout=connect_timeout,
**kwargs)
client.test_connection_auth()
self.assertTrue(should_connect, "Unexpectedly reachable")
if check_reverse_icmp_ip:
cmd = 'ping -c1 -w1 %s' % check_reverse_icmp_ip
try:
client.exec_command(cmd)
self.assertTrue(should_reverse_connect,
"Unexpectedly reachable (reverse)")
except lib_exc.SSHExecCommandFailed:
if should_reverse_connect:
raise
except lib_exc.SSHTimeout:
if should_connect:
raise
def test_bgp(self):
# RIGHT
right_server = self._create_server(network=self._right_network,
create_floating_ip=False)
# LEFT
left_server = self._create_server()
ssh_client = ssh.Client(left_server['fip']['floating_ip_address'],
CONF.validation.image_ssh_user,
pkey=self.keypair['private_key'],
ssh_key_type=CONF.validation.ssh_key_type)
# check LEFT -> RIGHT connectivity via BGP advertised routes
self.check_remote_connectivity(
ssh_client,
right_server['port']['fixed_ips'][0]['ip_address'],
should_succeed=False)
self._setup_bgp()
self.check_remote_connectivity(
ssh_client, right_server['port']['fixed_ips'][0]['ip_address'])