openstack
/
fuel-qa
Code Issues Proposed changes

Use context manager for ssh sessions 

Change-Id: I4dfd0918b1a9664e5c7a775688a059043b591969
Related-Bug: #1346362
This commit is contained in:
Maksym Strukov 2015-07-31 00:34:38 +03:00
parent 4e8761f8ea
commit 1b432a77a7
30 changed files with 1235 additions and 1055 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
fuelweb_test/helpers/decorators.py
View File

@ -92,8 +92,9 @@ def log_snapshot_after_test(func):
logger.error("Fetching of diagnostic snapshot failed: {0}".
format(traceback.format_exc()))
try:
admin_remote = args[0].env.d_env.get_admin_remote()
pull_out_logs_via_ssh(admin_remote, name)
with args[0].env.d_env.get_admin_remote()\
as admin_remote:
pull_out_logs_via_ssh(admin_remote, name)
except:
logger.error("Fetching of raw logs failed: {0}".
format(traceback.format_exc()))
@ -145,17 +146,17 @@ def upload_manifests(func):
logger.warning("Can't upload manifests: method of "
"unexpected class is decorated.")
return result
remote = environment.d_env.get_admin_remote()
remote.execute('rm -rf /etc/puppet/modules/*')
remote.upload(settings.UPLOAD_MANIFESTS_PATH,
'/etc/puppet/modules/')
logger.info("Copying new site.pp from %s" %
settings.SITEPP_FOR_UPLOAD)
remote.execute("cp %s /etc/puppet/manifests" %
settings.SITEPP_FOR_UPLOAD)
if settings.SYNC_DEPL_TASKS:
remote.execute("fuel release --sync-deployment-tasks"
" --dir /etc/puppet/")
with environment.d_env.get_admin_remote() as remote:
remote.execute('rm -rf /etc/puppet/modules/*')
remote.upload(settings.UPLOAD_MANIFESTS_PATH,
'/etc/puppet/modules/')
logger.info("Copying new site.pp from %s" %
settings.SITEPP_FOR_UPLOAD)
remote.execute("cp %s /etc/puppet/manifests" %
settings.SITEPP_FOR_UPLOAD)
if settings.SYNC_DEPL_TASKS:
remote.execute("fuel release --sync-deployment-tasks"
" --dir /etc/puppet/")
except Exception:
logger.error("Could not upload manifests")
raise
@ -176,8 +177,6 @@ def update_packages(func):
"unexpected class is decorated.")
return result
remote = environment.d_env.get_admin_remote()
if settings.UPDATE_FUEL_MIRROR:
for url in settings.UPDATE_FUEL_MIRROR:
repo_url = urlparse(url)
@ -210,17 +209,19 @@ def update_packages(func):
cmd = ("echo -e '[temporary]\nname=temporary\nbaseurl=file://{0}/"
"\ngpgcheck=0\npriority=1' > {1}").format(
settings.LOCAL_MIRROR_CENTOS, conf_file)
environment.execute_remote_cmd(remote, cmd, exit_code=0)
update_command = 'yum clean expire-cache; yum update -y -d3'
result = remote.execute(update_command)
logger.debug('Result of "yum update" command on master node: '
'{0}'.format(result))
assert_equal(int(result['exit_code']), 0,
'Packages update failed, '
'inspect logs for details')
environment.execute_remote_cmd(remote,
cmd='rm -f {0}'.format(conf_file),
exit_code=0)
with environment.d_env.get_admin_remote() as remote:
environment.execute_remote_cmd(remote, cmd, exit_code=0)
update_command = 'yum clean expire-cache; yum update -y -d3'
result = remote.execute(update_command)
logger.debug('Result of "yum update" command on master node: '
'{0}'.format(result))
assert_equal(int(result['exit_code']), 0,
'Packages update failed, '
'inspect logs for details')
environment.execute_remote_cmd(remote,
cmd='rm -f {0}'
.format(conf_file),
exit_code=0)
except Exception:
logger.error("Could not update packages")
raise
@ -247,7 +248,6 @@ def update_fuel(func):
centos_repo_path=settings.LOCAL_MIRROR_CENTOS,
ubuntu_repo_path=settings.LOCAL_MIRROR_UBUNTU)
remote = environment.d_env.get_admin_remote()
cluster_id = environment.fuel_web.get_last_created_cluster()
if centos_files_count > 0:
@ -259,10 +259,11 @@ def update_fuel(func):
cmd='yum clean expire-cache; yum update -y')
environment.docker_actions.restart_containers()
# Update packages on master node
remote.execute(
'yum -y install yum-plugin-priorities;'
'yum clean expire-cache; yum update -y')
with environment.d_env.get_admin_remote() as remote:
# Update packages on master node
remote.execute(
'yum -y install yum-plugin-priorities;'
'yum clean expire-cache; yum update -y')
# Add auxiliary repository to the cluster attributes
if settings.OPENSTACK_RELEASE_UBUNTU not in \
@ -285,6 +286,7 @@ def update_fuel(func):
" because of deploying wrong release!"
.format(ubuntu_files_count))
if settings.SYNC_DEPL_TASKS:
with environment.d_env.get_admin_remote() as remote:
remote.execute("fuel release --sync-deployment-tasks"
" --dir /etc/puppet/")
return result
@ -318,19 +320,19 @@ def update_ostf(func):
raise ValueError('REFSPEC should be set for CI tests.')
logger.info("Uploading new patchset from {0}"
.format(settings.GERRIT_REFSPEC))
remote = args[0].environment.d_env.get_admin_remote()
remote.upload(settings.PATCH_PATH.rstrip('/'),
'/var/www/nailgun/fuel-ostf')
remote.execute('dockerctl shell ostf '
'bash -c "cd /var/www/nailgun/fuel-ostf; '
'python setup.py develop"')
remote.execute('dockerctl shell ostf '
'bash -c "supervisorctl restart ostf"')
helpers.wait(
lambda: "0" in
with args[0].environment.d_env.get_admin_remote() as remote:
remote.upload(settings.PATCH_PATH.rstrip('/'),
'/var/www/nailgun/fuel-ostf')
remote.execute('dockerctl shell ostf '
'bash -c "pgrep [o]stf; echo $?"')
['stdout'][1], timeout=60)
'bash -c "cd /var/www/nailgun/fuel-ostf; '
'python setup.py develop"')
remote.execute('dockerctl shell ostf '
'bash -c "supervisorctl restart ostf"')
helpers.wait(
lambda: "0" in
remote.execute('dockerctl shell ostf '
'bash -c "pgrep [o]stf; echo $?"')
['stdout'][1], timeout=60)
logger.info("OSTF status: RUNNING")
except Exception as e:
logger.error("Could not upload patch set {e}".format(e=e))
@ -372,22 +374,23 @@ def retry(count=3, delay=30):
def custom_repo(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
custom_pkgs = CustomRepo(args[0].environment.d_env.get_admin_remote())
try:
if settings.CUSTOM_PKGS_MIRROR:
custom_pkgs.prepare_repository()
with args[0].environment.d_env.get_admin_remote() as remote:
custom_pkgs = CustomRepo(remote)
try:
if settings.CUSTOM_PKGS_MIRROR:
custom_pkgs.prepare_repository()
except Exception:
logger.error("Unable to get custom packages from {0}\n{1}"
.format(settings.CUSTOM_PKGS_MIRROR,
traceback.format_exc()))
raise
except Exception:
logger.error("Unable to get custom packages from {0}\n{1}"
.format(settings.CUSTOM_PKGS_MIRROR,
traceback.format_exc()))
raise
try:
return func(*args, **kwargs)
except Exception:
custom_pkgs.check_puppet_logs()
raise
try:
return func(*args, **kwargs)
except Exception:
custom_pkgs.check_puppet_logs()
raise
return wrapper
@ -507,7 +510,7 @@ def check_repos_management(func):
nailgun_nodes = env.fuel_web.client.list_cluster_nodes(
env.fuel_web.get_last_created_cluster())
for n in nailgun_nodes:
check_repo_managment(
env.d_env.get_ssh_to_remote(n['ip']))
with env.d_env.get_ssh_to_remote(n['ip']) as node_ssh:
check_repo_managment(node_ssh)
return result
return wrapper

24
fuelweb_test/helpers/multiple_networks_hacks.py
View File

@ -29,7 +29,6 @@ from fuelweb_test import logwrap
@logwrap
def configure_second_admin_cobbler(self):
dhcp_template = '/etc/cobbler/dnsmasq.template'
remote = self.d_env.get_admin_remote()
admin_net2 = self.d_env.admin_net2
second_admin_if = settings.INTERFACES.get(admin_net2)
second_admin_ip = str(
@ -53,14 +52,14 @@ def configure_second_admin_cobbler(self):
cmd = ("dockerctl shell cobbler sed -r '$a \{0}' -i {1};"
"dockerctl shell cobbler cobbler sync").format(new_range,
dhcp_template)
result = remote.execute(cmd)
with self.d_env.get_admin_remote() as remote:
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0, ('Failed to add second admin'
'network to cobbler: {0}').format(result))
@logwrap
def configure_second_admin_firewall(self, network, netmask):
remote = self.d_env.get_admin_remote()
# Allow input/forwarding for nodes from the second admin network
rules = [
('-I INPUT -i {0} -m comment --comment "input from 2nd admin network" '
@ -69,16 +68,17 @@ def configure_second_admin_firewall(self, network, netmask):
'"004 forward_admin_net2" -j MASQUERADE').
format(network, netmask)
]
for rule in rules:
cmd = 'iptables {0}'.format(rule)
with self.d_env.get_admin_remote() as remote:
for rule in rules:
cmd = 'iptables {0}'.format(rule)
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0,
('Failed to add firewall rule for second admin net'
'on master node: {0}, {1}').format(rule, result))
# Save new firewall configuration
cmd = 'service iptables save'
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0,
('Failed to add firewall rule for second admin net'
'on master node: {0}, {1}').format(rule, result))
# Save new firewall configuration
cmd = 'service iptables save'
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0,
('Failed to save firewall configuration on master node:'
' {0}').format(result))

30
fuelweb_test/helpers/patching.py
View File

@ -269,10 +269,11 @@ def add_remote_repositories(environment, mirrors, prefix_name='custom_repo'):
name = '{0}_{1}'.format(prefix_name, mirrors.index(mir))
local_repo_path = '/'.join([settings.PATCHING_WEB_DIR, name])
remote_repo_url = mir
mirror_remote_repository(
admin_remote=environment.d_env.get_admin_remote(),
remote_repo_url=remote_repo_url,
local_repo_path=local_repo_path)
with environment.d_env.get_admin_remote() as remote:
mirror_remote_repository(
admin_remote=remote,
remote_repo_url=remote_repo_url,
local_repo_path=local_repo_path)
repositories.add(name)
return repositories
@ -303,9 +304,9 @@ def connect_slaves_to_repo(environment, nodes, repo_name):
]
for slave in nodes:
remote = environment.d_env.get_ssh_to_remote(slave['ip'])
for cmd in cmds:
environment.execute_remote_cmd(remote, cmd, exit_code=0)
with environment.d_env.get_ssh_to_remote(slave['ip']) as remote:
for cmd in cmds:
environment.execute_remote_cmd(remote, cmd, exit_code=0)
def connect_admin_to_repo(environment, repo_name):
@ -327,9 +328,9 @@ def connect_admin_to_repo(environment, repo_name):
"yum check-update; [[ $? -eq 100 || $? -eq 0 ]]"
]
remote = environment.d_env.get_admin_remote()
for cmd in cmds:
environment.execute_remote_cmd(remote, cmd, exit_code=0)
with environment.d_env.get_admin_remote() as remote:
for cmd in cmds:
environment.execute_remote_cmd(remote, cmd, exit_code=0)
def update_packages(environment, remote, packages, exclude_packages=None):
@ -358,8 +359,8 @@ def update_packages_on_slaves(environment, slaves, packages=None,
# Install all updates
packages = ' '
for slave in slaves:
remote = environment.d_env.get_ssh_to_remote(slave['ip'])
update_packages(environment, remote, packages, exclude_packages)
with environment.d_env.get_ssh_to_remote(slave['ip']) as remote:
update_packages(environment, remote, packages, exclude_packages)
def get_slaves_ips_by_role(slaves, role=None):
@ -502,6 +503,7 @@ def validate_fix_apply_step(apply_step, environment, slaves):
"command isn't specified".format(apply_step['id'],
apply_step['type']))
command = apply_step['command']
# remotes sessions .clear() placed in run_actions()
remotes = [environment.d_env.get_ssh_to_remote(ip) for ip in remotes_ips] \
if command else []
devops_nodes = devops_nodes if devops_action else []
@ -585,6 +587,10 @@ def run_actions(environment, target, slaves, action_type='patch-scenario'):
elif devops_action == 'reboot':
environment.fuel_web.warm_restart_nodes(devops_nodes)
# clear connections
for remote in remotes:
remote.clear()
def apply_patches(environment, target, slaves=None):
run_actions(environment, target, slaves, action_type='patch-scenario')

32
fuelweb_test/helpers/security.py
View File

@ -33,13 +33,13 @@ class SecurityChecks(object):
@logwrap
def _listen_random_port(self, ip_address, protocol, tmp_file_path):
remote = self.environment.d_env.get_ssh_to_remote(ip_address)
# Install socat
if OPENSTACK_RELEASE_UBUNTU in OPENSTACK_RELEASE:
cmd = '/usr/bin/apt-get install -y {pkg}'.format(pkg='socat')
else:
cmd = '/usr/bin/yum install -y {pkg}'.format(pkg='socat')
result = remote.execute(cmd)
with self.environment.d_env.get_ssh_to_remote(ip_address) as remote:
result = remote.execute(cmd)
if not result['exit_code'] == 0:
raise Exception('Could not install package: {0}\n{1}'.
format(result['stdout'], result['stderr']))
@ -47,8 +47,9 @@ class SecurityChecks(object):
cmd = ('netstat -A inet -ln --{proto} | awk \'$4 ~ /^({ip}'
'|0\.0\.0\.0):[0-9]+/ {{split($4,port,":"); print '
'port[2]}}\'').format(ip=ip_address, proto=protocol)
used_ports = [int(p.strip()) for p in remote.execute(cmd)['stdout']]
with self.environment.d_env.get_ssh_to_remote(ip_address) as remote:
used_ports = [int(p.strip())
for p in remote.execute(cmd)['stdout']]
# Get list of opened ports
cmd = ('iptables -t filter -S INPUT | sed -rn -e \'s/^.*\s\-p\s+'
@ -57,8 +58,9 @@ class SecurityChecks(object):
' while read ports; do if [[ "$ports" =~ [[:digit:]]'
'[[:blank:]][[:digit:]] ]]; then seq $ports; else echo '
'"$ports";fi; done').format(proto=protocol)
allowed_ports = [int(p.strip()) for p in remote.execute(cmd)['stdout']]
with self.environment.d_env.get_ssh_to_remote(ip_address) as remote:
allowed_ports = [int(p.strip())
for p in remote.execute(cmd)['stdout']]
test_port = randrange(10000)
while test_port in used_ports or test_port in allowed_ports:
@ -66,7 +68,8 @@ class SecurityChecks(object):
# Create dump of iptables rules
cmd = 'iptables-save > {0}.dump'.format(tmp_file_path)
result = remote.execute(cmd)
with self.environment.d_env.get_ssh_to_remote(ip_address) as remote:
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0,
'Dumping of iptables rules failed on {0}: {1}; {2}'.
format(ip_address, result['stdout'], result['stderr']))
@ -76,7 +79,9 @@ class SecurityChecks(object):
'&>/dev/null & pid=$! ; disown; sleep 1; kill -0 $pid').\
format(proto=protocol, ip=ip_address, file=tmp_file_path,
port=test_port)
result = remote.execute(cmd)
with self.environment.d_env.get_ssh_to_remote(ip_address) as remote:
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0,
'Listening on {0}:{1}/{2} port failed: {3}'.
format(ip_address, test_port, protocol,
@ -86,7 +91,6 @@ class SecurityChecks(object):
@retry()
@logwrap
def verify_firewall(self, cluster_id):
admin_remote = self.environment.d_env.get_admin_remote()
# Install NetCat
if not self.environment.admin_install_pkg('nc') == 0:
raise Exception('Can not install package "nc".')
@ -108,10 +112,12 @@ class SecurityChecks(object):
cmd = 'echo {string} | nc {opts} {ip} {port}'.\
format(opts=nc_opts, string=check_string, ip=node['ip'],
port=port)
admin_remote.execute(cmd)
remote = self.environment.d_env.get_ssh_to_remote(node['ip'])
cmd = 'cat {0}; mv {0}{{,.old}}'.format(tmp_file_path)
result = remote.execute(cmd)
with self.environment.d_env.get_admin_remote() as admin_remote:
admin_remote.execute(cmd)
with self.environment.d_env\
.get_ssh_to_remote(node['ip']) as remote:
cmd = 'cat {0}; mv {0}{{,.old}}'.format(tmp_file_path)
result = remote.execute(cmd)
if ''.join(result['stdout']).strip() == check_string:
msg = ('Firewall vulnerability detected. Unused port '
'{0}/{1} can be accessed on {2} (node-{3}) node. '

14
fuelweb_test/helpers/utils.py
View File

@ -101,14 +101,14 @@ def store_astute_yaml(env):
nailgun_node = env.fuel_web.get_nailgun_node_by_devops_node(node)
if node.driver.node_active(node) and nailgun_node['roles']:
try:
_ip = env.fuel_web.get_nailgun_node_by_name(node.name)['ip']
remote = env.d_env.get_ssh_to_remote(_ip)
filename = '{0}/{1}-{2}.yaml'.format(settings.LOGS_DIR,
func_name, node.name)
logger.info("Storing {0}".format(filename))
if not remote.download('/etc/astute.yaml', filename):
logger.error("Downloading 'astute.yaml' from the node "
"{0} failed.".format(node.name))
_ip = env.fuel_web.get_nailgun_node_by_name(node.name)['ip']
with env.d_env.get_ssh_to_remote(_ip) as remote:
if not remote.download('/etc/astute.yaml', filename):
logger.error("Downloading 'astute.yaml' from the node "
"{0} failed.".format(node.name))
except Exception:
logger.error(traceback.format_exc())
@ -136,10 +136,10 @@ def store_packages_json(env):
packages = {func_name: {}}
cluster_id = env.fuel_web.get_last_created_cluster()
for nailgun_node in env.fuel_web.client.list_cluster_nodes(cluster_id):
remote = env.d_env.get_ssh_to_remote(nailgun_node['ip'])
role = '_'.join(nailgun_node['roles'])
logger.debug('role is {0}'.format(role))
packages = get_node_packages(remote, func_name, role, packages)
with env.d_env.get_ssh_to_remote(nailgun_node['ip']) as remote:
packages = get_node_packages(remote, func_name, role, packages)
packages_file = '{0}/packages.json'.format(settings.LOGS_DIR)
if os.path.isfile(packages_file):
with open(packages_file, 'r') as outfile:

143
fuelweb_test/models/environment.py
View File

@ -303,33 +303,33 @@ class EnvironmentModel(object):
def set_admin_ssh_password(self):
try:
remote = self.d_env.get_admin_remote(
login=settings.SSH_CREDENTIALS['login'],
password=settings.SSH_CREDENTIALS['password'])
self.execute_remote_cmd(remote, 'date')
with self.d_env.get_admin_remote(
login=settings.SSH_CREDENTIALS['login'],
password=settings.SSH_CREDENTIALS['password']) as remote:
self.execute_remote_cmd(remote, 'date')
logger.debug('Accessing admin node using SSH: SUCCESS')
except Exception:
logger.debug('Accessing admin node using SSH credentials:'
' FAIL, trying to change password from default')
remote = self.d_env.get_admin_remote(
login='root', password='r00tme')
self.execute_remote_cmd(
remote, 'echo -e "{1}\\n{1}" | passwd {0}'
.format(settings.SSH_CREDENTIALS['login'],
settings.SSH_CREDENTIALS['password']))
with self.d_env.get_admin_remote(
login='root', password='r00tme') as remote:
self.execute_remote_cmd(
remote, 'echo -e "{1}\\n{1}" | passwd {0}'
.format(settings.SSH_CREDENTIALS['login'],
settings.SSH_CREDENTIALS['password']))
logger.debug("Admin node password has changed.")
logger.info("Admin node login name: '{0}' , password: '{1}'".
format(settings.SSH_CREDENTIALS['login'],
settings.SSH_CREDENTIALS['password']))
def set_admin_keystone_password(self):
remote = self.d_env.get_admin_remote()
try:
self.fuel_web.client.get_releases()
except exceptions.Unauthorized:
self.execute_remote_cmd(
remote, 'fuel user --newpass {0} --change-password'
.format(settings.KEYSTONE_CREDS['password']))
with self.d_env.get_admin_remote() as remote:
self.execute_remote_cmd(
remote, 'fuel user --newpass {0} --change-password'
.format(settings.KEYSTONE_CREDS['password']))
logger.info(
'New Fuel UI (keystone) username: "{0}", password: "{1}"'
.format(settings.KEYSTONE_CREDS['username'],
@ -396,11 +396,11 @@ class EnvironmentModel(object):
settings.FUEL_STATS_HOST, settings.FUEL_STATS_PORT
))
if settings.PATCHING_DISABLE_UPDATES:
remote = self.d_env.get_admin_remote()
cmd = "find /etc/yum.repos.d/ -type f -regextype posix-egrep" \
" -regex '.*/mos[0-9,\.]+\-(updates|security).repo' | " \
"xargs -n1 -i sed '$aenabled=0' -i {}"
self.execute_remote_cmd(remote, cmd)
with self.d_env.get_admin_remote() as remote:
cmd = "find /etc/yum.repos.d/ -type f -regextype posix-egrep" \
" -regex '.*/mos[0-9,\.]+\-(updates|security).repo' | " \
"xargs -n1 -i sed '$aenabled=0' -i {}"
self.execute_remote_cmd(remote, cmd)
@update_packages
@upload_manifests
@ -413,9 +413,9 @@ class EnvironmentModel(object):
def setup_customisation(self):
self.wait_for_provisioning()
try:
remote = self.d_env.get_admin_remote()
cmd = "pkill -sigusr1 -f '^.*/fuelmenu$'"
wait(lambda: remote.execute(cmd)['exit_code'] == 0, timeout=60)
with self.d_env.get_admin_remote() as remote:
wait(lambda: remote.execute(cmd)['exit_code'] == 0, timeout=60)
except Exception:
logger.error("Could not kill process of fuelmenu")
raise
@ -449,10 +449,8 @@ class EnvironmentModel(object):
def verify_network_configuration(self, node_name):
node = self.fuel_web.get_nailgun_node_by_name(node_name)
checkers.verify_network_configuration(
node=node,
remote=self.d_env.get_ssh_to_remote(node['ip'])
)
with self.fuel_web.get_ssh_for_node(node_name) as ssh:
checkers.verify_network_configuration(node=node, remote=ssh)
def wait_bootstrap(self):
logger.info("Waiting while bootstrapping is in progress")
@ -473,20 +471,24 @@ class EnvironmentModel(object):
raise Exception('Fuel node deployment failed.')
def dhcrelay_check(self):
admin_remote = self.d_env.get_admin_remote()
out = admin_remote.execute("dhcpcheck discover "
"--ifaces eth0 "
"--repeat 3 "
"--timeout 10")['stdout']
with self.d_env.get_admin_remote() as admin_remote:
out = admin_remote.execute("dhcpcheck discover "
"--ifaces eth0 "
"--repeat 3 "
"--timeout 10")['stdout']
assert_true(self.get_admin_node_ip() in "".join(out),
"dhcpcheck doesn't discover master ip")
def get_fuel_settings(self, remote=None):
if not remote:
remote = self.d_env.get_admin_remote()
cmd = 'cat {cfg_file}'.format(cfg_file=settings.FUEL_SETTINGS_YAML)
result = remote.execute(cmd)
if not remote:
with self.d_env.get_admin_remote() as remote:
remote.execute(cmd)
else:
result = remote.execute(cmd)
if result['exit_code'] == 0:
fuel_settings = yaml.load(''.join(result['stdout']))
else:
@ -497,25 +499,26 @@ class EnvironmentModel(object):
def admin_install_pkg(self, pkg_name):
"""Install a package <pkg_name> on the admin node"""
admin_remote = self.d_env.get_admin_remote()
remote_status = admin_remote.execute("rpm -q {0}'".format(pkg_name))
if remote_status['exit_code'] == 0:
logger.info("Package '{0}' already installed.".format(pkg_name))
else:
logger.info("Installing package '{0}' ...".format(pkg_name))
remote_status = admin_remote.execute("yum -y install {0}"
.format(pkg_name))
logger.info("Installation of the package '{0}' has been"
" completed with exit code {1}"
.format(pkg_name, remote_status['exit_code']))
with self.d_env.get_admin_remote() as remote:
remote_status = remote.execute("rpm -q {0}'".format(pkg_name))
if remote_status['exit_code'] == 0:
logger.info("Package '{0}' already installed."
.format(pkg_name))
else:
logger.info("Installing package '{0}' ...".format(pkg_name))
remote_status = remote.execute("yum -y install {0}"
.format(pkg_name))
logger.info("Installation of the package '{0}' has been"
" completed with exit code {1}"
.format(pkg_name, remote_status['exit_code']))
return remote_status['exit_code']
def admin_run_service(self, service_name):
"""Start a service <service_name> on the admin node"""
admin_remote = self.d_env.get_admin_remote()
admin_remote.execute("service {0} start".format(service_name))
remote_status = admin_remote.execute("service {0} status"
.format(service_name))
with self.d_env.get_admin_remote() as admin_remote:
admin_remote.execute("service {0} start".format(service_name))
remote_status = admin_remote.execute("service {0} status"
.format(service_name))
if any('running...' in status for status in remote_status['stdout']):
logger.info("Service '{0}' is running".format(service_name))
else:
@ -530,9 +533,9 @@ class EnvironmentModel(object):
# then `dockerctl destroy all; bootstrap_admin_node.sh;`
def admin_install_updates(self):
logger.info('Searching for updates..')
admin_remote = self.d_env.get_admin_remote()
update_command = 'yum clean expire-cache; yum update -y'
update_result = admin_remote.execute(update_command)
with self.d_env.get_admin_remote() as admin_remote:
update_result = admin_remote.execute(update_command)
logger.info('Result of "{1}" command on master node: '
'{0}'.format(update_result, update_command))
assert_equal(int(update_result['exit_code']), 0,
@ -556,7 +559,8 @@ class EnvironmentModel(object):
logger.info('{0} packet(s) were updated'.format(updates_count))
cmd = 'dockerctl destroy all; bootstrap_admin_node.sh;'
result = admin_remote.execute(cmd)
with self.d_env.get_admin_remote() as admin_remote:
result = admin_remote.execute(cmd)
logger.info('Result of "{1}" command on master node: '
'{0}'.format(result, cmd))
assert_equal(int(result['exit_code']), 0,
@ -568,23 +572,24 @@ class EnvironmentModel(object):
# * adds 'nameservers' at start of resolv.conf if merge=True
# * replaces resolv.conf with 'nameservers' if merge=False
def modify_resolv_conf(self, nameservers=[], merge=True):
remote = self.d_env.get_admin_remote()
resolv_conf = remote.execute('cat /etc/resolv.conf')
assert_equal(0, resolv_conf['exit_code'], 'Executing "{0}" on the '
'admin node has failed with: {1}'
.format('cat /etc/resolv.conf', resolv_conf['stderr']))
if merge:
nameservers.extend(resolv_conf['stdout'])
with self.d_env.get_admin_remote() as remote:
resolv_conf = remote.execute('cat /etc/resolv.conf')
assert_equal(0, resolv_conf['exit_code'], 'Executing "{0}" on the '
'admin node has failed with: {1}'
.format('cat /etc/resolv.conf',
resolv_conf['stderr']))
if merge:
nameservers.extend(resolv_conf['stdout'])
resolv_keys = ['search', 'domain', 'nameserver']
resolv_new = "".join('{0}\n'.format(ns) for ns in nameservers
if any(x in ns for x in resolv_keys))
logger.debug('echo "{0}" > /etc/resolv.conf'.format(resolv_new))
echo_cmd = 'echo "{0}" > /etc/resolv.conf'.format(resolv_new)
echo_result = remote.execute(echo_cmd)
assert_equal(0, echo_result['exit_code'], 'Executing "{0}" on the '
'admin node has failed with: {1}'
.format(echo_cmd, echo_result['stderr']))
resolv_keys = ['search', 'domain', 'nameserver']
resolv_new = "".join('{0}\n'.format(ns) for ns in nameservers
if any(x in ns for x in resolv_keys))
logger.debug('echo "{0}" > /etc/resolv.conf'.format(resolv_new))
echo_cmd = 'echo "{0}" > /etc/resolv.conf'.format(resolv_new)
echo_result = remote.execute(echo_cmd)
assert_equal(0, echo_result['exit_code'], 'Executing "{0}" on the '
'admin node has failed with: {1}'
.format(echo_cmd, echo_result['stderr']))
return resolv_conf['stdout']
@logwrap
@ -597,7 +602,6 @@ class EnvironmentModel(object):
@logwrap
def describe_second_admin_interface(self):
remote = self.d_env.get_admin_remote()
admin_net2_object = self.d_env.get_network(name=self.d_env.admin_net2)
second_admin_network = admin_net2_object.ip.network
second_admin_netmask = admin_net2_object.ip.netmask
@ -625,7 +629,8 @@ class EnvironmentModel(object):
add_second_admin_ip, second_admin_if, second_admin_ip)
logger.debug('Trying to assign {0} IP to the {1} on master node...'.
format(second_admin_ip, second_admin_if))
result = remote.execute(cmd)
with self.d_env.get_admin_remote() as remote:
result = remote.execute(cmd)
assert_equal(result['exit_code'], 0, ('Failed to assign second admin '
'IP address on master node: {0}').format(result))
logger.debug('Done: {0}'.format(result['stdout']))

197
fuelweb_test/models/fuel_web_client.py
View File

@ -342,8 +342,8 @@ class FuelWebClient(object):
@logwrap
def get_pcm_nodes(self, ctrl_node, pure=False):
nodes = {}
remote = self.get_ssh_for_node(ctrl_node)
pcs_status = remote.execute('pcs status nodes')['stdout']
with self.get_ssh_for_node(ctrl_node) as remote:
pcs_status = remote.execute('pcs status nodes')['stdout']
pcm_nodes = yaml.load(''.join(pcs_status).strip())
for status in ('Online', 'Offline', 'Standby'):
list_nodes = (pcm_nodes['Pacemaker Nodes'][status] or '').split()
@ -356,9 +356,9 @@ class FuelWebClient(object):
@logwrap
def get_rabbit_running_nodes(self, ctrl_node):
remote = self.get_ssh_for_node(ctrl_node)
rabbit_status = ''.join(remote.execute(
'rabbitmqctl cluster_status')['stdout']).strip()
with self.get_ssh_for_node(ctrl_node) as remote:
rabbit_status = ''.join(remote.execute(
'rabbitmqctl cluster_status')['stdout']).strip()
rabbit_nodes = re.search(
"\{running_nodes,\[(.*)\]\}",
rabbit_status).group(1).replace("'", "").split(',')
@ -466,13 +466,17 @@ class FuelWebClient(object):
public_gw = self.environment.d_env.router(router_name="public")
if help_data.FUEL_USE_LOCAL_NTPD and ('ntp_list' not in settings)\
remote = self.environment.d_env.get_admin_remote()
if help_data.FUEL_USE_LOCAL_NTPD\
and ('ntp_list' not in settings)\
and checkers.is_ntpd_active(
self.environment.d_env.get_admin_remote(), public_gw):
remote, public_gw):
attributes['editable']['external_ntp']['ntp_list']['value'] =\
public_gw
logger.info("Configuring cluster #{0} to use NTP server {1}"
logger.info("Configuring cluster #{0}"
"to use NTP server {1}"
.format(cluster_id, public_gw))
remote.clear()
if help_data.FUEL_USE_LOCAL_DNS and ('dns_list' not in settings):
attributes['editable']['external_dns']['dns_list']['value'] =\
@ -698,29 +702,29 @@ class FuelWebClient(object):
@logwrap
def get_cluster_floating_list(self, node_name):
logger.info('Get floating IPs list at %s devops node', node_name)
remote = self.get_ssh_for_node(node_name)
ret = remote.check_call('/usr/bin/nova-manage floating list')
with self.get_ssh_for_node(node_name) as remote:
ret = remote.check_call('/usr/bin/nova-manage floating list')
ret_str = ''.join(ret['stdout'])
return re.findall('(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', ret_str)
@logwrap
def get_cluster_block_devices(self, node_name):
logger.info('Get %s node block devices (lsblk)', node_name)
remote = self.get_ssh_for_node(node_name)
ret = remote.check_call('/bin/lsblk')
with self.get_ssh_for_node(node_name) as remote:
ret = remote.check_call('/bin/lsblk')
return ''.join(ret['stdout'])
@logwrap
def get_pacemaker_status(self, controller_node_name):
logger.info('Get pacemaker status at %s node', controller_node_name)
remote = self.get_ssh_for_node(controller_node_name)
return ''.join(remote.check_call('crm_mon -1')['stdout'])
with self.get_ssh_for_node(controller_node_name) as remote:
return ''.join(remote.check_call('crm_mon -1')['stdout'])
@logwrap
def get_pacemaker_config(self, controller_node_name):
logger.info('Get pacemaker config at %s node', controller_node_name)
remote = self.get_ssh_for_node(controller_node_name)
return ''.join(remote.check_call('crm_resource --list')['stdout'])
with self.get_ssh_for_node(controller_node_name) as remote:
return ''.join(remote.check_call('crm_resource --list')['stdout'])
@logwrap
def get_pacemaker_resource_location(self, controller_node_name,
@ -728,14 +732,14 @@ class FuelWebClient(object):
"""Get devops nodes where the resource is running."""
logger.info('Get pacemaker resource %s life status at %s node',
resource_name, controller_node_name)
remote = self.get_ssh_for_node(controller_node_name)
hosts = []
for line in remote.check_call(
'crm_resource --resource {0} '
'--locate --quiet'.format(resource_name))['stdout']:
hosts.append(
self.get_devops_node_by_nailgun_fqdn(line.strip()))
remote.clear()
with self.get_ssh_for_node(controller_node_name) as remote:
for line in remote.check_call(
'crm_resource --resource {0} '
'--locate --quiet'.format(resource_name))['stdout']:
hosts.append(
self.get_devops_node_by_nailgun_fqdn(line.strip()))
return hosts
@logwrap
@ -1402,8 +1406,8 @@ class FuelWebClient(object):
[n.name for n in devops_nodes])
for node in devops_nodes:
logger.debug('Shutdown node %s', node.name)
remote = self.get_ssh_for_node(node.name)
remote.check_call('/sbin/shutdown -Ph now')
with self.get_ssh_for_node(node.name) as remote:
remote.check_call('/sbin/shutdown -Ph now')
for node in devops_nodes:
logger.info('Wait a %s node offline status', node.name)
@ -1480,15 +1484,15 @@ class FuelWebClient(object):
:rtype: String on None
"""
try:
remote = self.get_ssh_for_node(node_name)
if namespace:
cmd = 'ip netns exec {0} ip -4 ' \
'-o address show {1}'.format(namespace, interface)
else:
cmd = 'ip -4 -o address show {1}'.format(interface)
ret = remote.check_call(cmd)
remote.clear()
with self.get_ssh_for_node(node_name) as remote:
ret = remote.check_call(cmd)
ip_search = re.search(
'inet (?P<ip>\d+\.\d+\.\d+.\d+/\d+).*scope .* '
'{0}'.format(interface), ' '.join(ret['stdout']))
@ -1508,11 +1512,10 @@ class FuelWebClient(object):
def ip_address_del(self, node_name, namespace, interface, ip):
logger.info('Delete %s ip address of %s interface at %s node',
ip, interface, node_name)
remote = self.get_ssh_for_node(node_name)
remote.check_call(
'ip netns exec {0} ip addr'
' del {1} dev {2}'.format(namespace, ip, interface))
remote.clear()
with self.get_ssh_for_node(node_name) as remote:
remote.check_call(
'ip netns exec {0} ip addr'
' del {1} dev {2}'.format(namespace, ip, interface))
@logwrap
def provisioning_cluster_wait(self, cluster_id, progress=None):
@ -1568,35 +1571,34 @@ class FuelWebClient(object):
return ''.join(result['stderr']).strip()
for node_name in node_names:
_ip = self.get_nailgun_node_by_name(node_name)['ip']
remote = self.environment.d_env.get_ssh_to_remote(_ip)
try:
wait(lambda: _get_galera_status(remote) == 'ON',
timeout=timeout)
logger.info("MySQL Galera is up on {host} node.".format(
host=node_name))
except TimeoutError:
logger.error("MySQL Galera isn't ready on {0}: {1}"
.format(node_name, _get_galera_status(remote)))
raise TimeoutError(
"MySQL Galera isn't ready on {0}: {1}".format(
node_name, _get_galera_status(remote)))
with self.get_ssh_for_node(node_name) as remote:
try:
wait(lambda: _get_galera_status(remote) == 'ON',
timeout=timeout)
logger.info("MySQL Galera is up on {host} node.".format(
host=node_name))
except TimeoutError:
logger.error("MySQL Galera isn't ready on {0}: {1}"
.format(node_name,
_get_galera_status(remote)))
raise TimeoutError(
"MySQL Galera isn't ready on {0}: {1}".format(
node_name, _get_galera_status(remote)))
return True
@logwrap
def wait_cinder_is_up(self, node_names):
logger.info("Waiting for all Cinder services up.")
for node_name in node_names:
_ip = self.get_nailgun_node_by_name(node_name)['ip']
remote = self.environment.d_env.get_ssh_to_remote(_ip)
try:
wait(lambda: checkers.check_cinder_status(remote),
timeout=300)
logger.info("All Cinder services up.")
except TimeoutError:
logger.error("Cinder services not ready.")
raise TimeoutError(
"Cinder services not ready. ")
with self.get_ssh_for_node(node_name) as remote:
try:
wait(lambda: checkers.check_cinder_status(remote),
timeout=300)
logger.info("All Cinder services up.")
except TimeoutError:
logger.error("Cinder services not ready.")
raise TimeoutError(
"Cinder services not ready. ")
return True
def run_ostf_repeatably(self, cluster_id, test_name=None,
@ -1703,43 +1705,44 @@ class FuelWebClient(object):
logger.info('Waiting until Ceph service become up...')
for node in online_ceph_nodes:
remote = self.environment.d_env.get_ssh_to_remote(node['ip'])
try:
wait(lambda: ceph.check_service_ready(remote) is True,
interval=20, timeout=600)
except TimeoutError:
error_msg = 'Ceph service is not properly started' \
' on {0}'.format(node['name'])
logger.error(error_msg)
raise TimeoutError(error_msg)
with self.environment.d_env\
.get_ssh_to_remote(node['ip']) as remote:
try:
wait(lambda: ceph.check_service_ready(remote) is True,
interval=20, timeout=600)
except TimeoutError:
error_msg = 'Ceph service is not properly started' \
' on {0}'.format(node['name'])
logger.error(error_msg)
raise TimeoutError(error_msg)
logger.info('Ceph service is ready. Checking Ceph Health...')
self.check_ceph_time_skew(cluster_id, offline_nodes)
node = online_ceph_nodes[0]
remote = self.environment.d_env.get_ssh_to_remote(node['ip'])
if not ceph.is_health_ok(remote):
if ceph.is_pgs_recovering(remote) and len(offline_nodes) > 0:
logger.info('Ceph is being recovered after osd node(s)'
' shutdown.')
try:
wait(lambda: ceph.is_health_ok(remote),
interval=30, timeout=recovery_timeout)
except TimeoutError:
result = ceph.health_detail(remote)
msg = 'Ceph HEALTH is not OK on {0}. Details: {1}'.format(
node['name'], result)
logger.error(msg)
raise TimeoutError(msg)
else:
result = ceph.health_detail(remote)
msg = 'Ceph HEALTH is not OK on {0}. Details: {1}'.format(
node['name'], result)
assert_true(ceph.is_health_ok(remote), msg)
with self.environment.d_env.get_ssh_to_remote(node['ip']) as remote:
if not ceph.is_health_ok(remote):
if ceph.is_pgs_recovering(remote) and len(offline_nodes) > 0:
logger.info('Ceph is being recovered after osd node(s)'
' shutdown.')
try:
wait(lambda: ceph.is_health_ok(remote),
interval=30, timeout=recovery_timeout)
except TimeoutError:
result = ceph.health_detail(remote)
msg = 'Ceph HEALTH is not OK on {0}. Details: {1}'\
.format(node['name'], result)
logger.error(msg)
raise TimeoutError(msg)
else:
result = ceph.health_detail(remote)
msg = 'Ceph HEALTH is not OK on {0}. Details: {1}'.format(
node['name'], result)
assert_true(ceph.is_health_ok(remote), msg)
logger.info('Checking Ceph OSD Tree...')
ceph.check_disks(remote, [n['id'] for n in online_ceph_nodes])
logger.info('Checking Ceph OSD Tree...')
ceph.check_disks(remote, [n['id'] for n in online_ceph_nodes])
remote.clear()
logger.info('Ceph cluster status is OK')
@logwrap
@ -2120,17 +2123,17 @@ class FuelWebClient(object):
cluster_id,
roles=['controller', ]) if node['online']]
admin_remote = self.environment.d_env.get_admin_remote()
check_proxy_cmd = ('[[ $(curl -s -w "%{{http_code}}" '
'{0} -o /dev/null) -eq 200 ]]')
with self.environment.d_env.get_admin_remote() as admin_remote:
check_proxy_cmd = ('[[ $(curl -s -w "%{{http_code}}" '
'{0} -o /dev/null) -eq 200 ]]')
for controller in online_controllers:
proxy_url = 'http://{0}:{1}/'.format(controller['ip'], port)
logger.debug('Trying to connect to {0} from master node...'.format(
proxy_url))
if admin_remote.execute(
check_proxy_cmd.format(proxy_url))['exit_code'] == 0:
return proxy_url
for controller in online_controllers:
proxy_url = 'http://{0}:{1}/'.format(controller['ip'], port)
logger.debug('Trying to connect to {0} from master node...'
.format(proxy_url))
if admin_remote.execute(
check_proxy_cmd.format(proxy_url))['exit_code'] == 0:
return proxy_url
assert_true(len(online_controllers) > 0,
'There are no online controllers available '

221
fuelweb_test/tests/gd_based_tests/test_neutron.py
View File

@ -203,72 +203,80 @@ class NeutronTun(TestBasic):
# check hiera
if self.get_post_test(tasks, 'hiera'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'hiera')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, 'hiera')[0]['cmd'])
# check globals
if self.get_post_test(tasks, 'globals'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'globals')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, 'globals')[0]['cmd'])
# check netconfig
if self.get_post_test(tasks, 'netconfig'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'netconfig')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, 'netconfig')[0]['cmd'])
# check firewall
if self.get_post_test(all_tasks, 'firewall'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(all_tasks, 'firewall')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(all_tasks,
'firewall')[0]['cmd'])
# check hosts
if self.get_post_test(tasks, 'hosts'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'hosts')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, 'hosts')[0]['cmd'])
# check tools
if self.get_post_test(all_tasks, 'tools'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(all_tasks, 'tools')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(all_tasks, 'tools')[0]['cmd'])
# check cluster on controller
post_cluster = self.get_post_test(all_tasks, 'cluster')
if post_cluster:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_cluster[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_cluster[0]['cmd'])
post_virtual_ips = self.get_post_test(tasks, 'virtual_ips')
if post_virtual_ips:
try:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node('slave-01'),
path=post_virtual_ips[0]['cmd'])
except AssertionError:
import time
time.sleep(60)
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node('slave-01'),
path=post_virtual_ips[0]['cmd'])
with self.fuel_web.get_ssh_for_node('slave-01') as ssh:
try:
gd.run_check_from_task(
remote=ssh,
path=post_virtual_ips[0]['cmd'])
except AssertionError:
import time
time.sleep(60)
gd.run_check_from_task(
remote=ssh,
path=post_virtual_ips[0]['cmd'])
self.env.make_snapshot("run_tasks_end_with_vips")
@ -309,10 +317,11 @@ class NeutronTun(TestBasic):
pre_cluster_haproxy = self.get_pre_test(tasks, 'cluster-haproxy')
post_cluster_haproxy = self.get_post_test(tasks, 'cluster-haproxy')
if pre_cluster_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_cluster_haproxy[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_cluster_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['conntrackd'],
@ -327,10 +336,11 @@ class NeutronTun(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_cluster_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_cluster_haproxy[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_cluster_haproxy[0]['cmd'])
self.env.make_snapshot("step_5_run_cluster_haproxy_controller")
@ -371,10 +381,11 @@ class NeutronTun(TestBasic):
pre_openstack_haproxy = self.get_pre_test(tasks, 'openstack-haproxy')
post_openstack_haproxy = self.get_post_test(tasks, 'openstack-haproxy')
if pre_openstack_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_openstack_haproxy[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_openstack_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-haproxy'],
@ -400,19 +411,21 @@ class NeutronTun(TestBasic):
logger.debug('res info is {0}'.format(res))
self.fuel_web.assert_task_success(task=res)
if post_openstack_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_openstack_haproxy[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_openstack_haproxy[0]['cmd'])
for service in ['memcached', 'openstack-cinder', 'database'
'rabbitmq', 'apache']:
# for service in ['memcached', 'openstack-cinder', 'database'
# 'rabbitmq', 'keystone', 'glance']:
if self.get_post_test(tasks, service):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, service)[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, service)[0]['cmd'])
self.env.make_snapshot("step_6_run_openstack_haproxy_controller")
@ -454,10 +467,11 @@ class NeutronTun(TestBasic):
pre_openstack_ctr = self.get_pre_test(tasks, 'openstack-controller')
post_openstack_ctr = self.get_post_test(tasks, 'openstack-controller')
if pre_openstack_ctr:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_openstack_ctr[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_openstack_ctr[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-controller'],
@ -466,10 +480,11 @@ class NeutronTun(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_openstack_ctr:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_openstack_ctr[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_openstack_ctr[0]['cmd'])
self.env.make_snapshot("step_7_run_openstack_controller")
@ -517,10 +532,11 @@ class NeutronTun(TestBasic):
pre_net = self.get_pre_test(tasks, 'openstack-network')
if pre_net:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_net[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_net[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=[task['id'] for task in tasks],
@ -548,10 +564,11 @@ class NeutronTun(TestBasic):
for task in expected_task_list:
if self.get_post_test(tasks, task):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, task)[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=self.get_post_test(tasks, task)[0]['cmd'])
try:
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['sanity'],
@ -601,10 +618,11 @@ class NeutronTun(TestBasic):
pre_top_compute = self.get_pre_test(tasks, 'top-role-compute')
post_top_compute = self.get_post_test(tasks, 'top-role-compute')
if pre_top_compute:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_top_compute[0]['cmd'])
for node in ['slave-02']]
for node in ['slave-02']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_top_compute[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['top-role-compute'],
@ -613,18 +631,20 @@ class NeutronTun(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_top_compute:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_top_compute[0]['cmd'])
for node in ['slave-02']]
for node in ['slave-02']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_top_compute[0]['cmd'])
pre_net = self.get_pre_test(tasks, 'openstack-network-compute')
post_net = self.get_post_test(tasks, 'openstack-network-compute')
if pre_net:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_net[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_net[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-network-compute'],
@ -634,10 +654,11 @@ class NeutronTun(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_net:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_net[0]['cmd'])
for node in ['slave-02']]
for node in ['slave-02']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_net[0]['cmd'])
self.env.make_snapshot("step_9_run_top_role_compute")
@ -682,10 +703,11 @@ class NeutronTun(TestBasic):
pre_top_cinder = self.get_pre_test(tasks, 'top-role-cinder')
post_top_cinder = self.get_post_test(tasks, 'top-role-cinder')
if pre_top_cinder:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_top_cinder[0]['cmd'])
for node in ['slave-03']]
for node in ['slave-03']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=pre_top_cinder[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['top-role-cinder'],
@ -694,10 +716,11 @@ class NeutronTun(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_top_cinder:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_top_cinder[0]['cmd'])
for node in ['slave-03']]
for node in ['slave-03']:
with self.fuel_web.get_ssh_for_node(node) as ssh:
gd.run_check_from_task(
remote=ssh,
path=post_top_cinder[0]['cmd'])
# Run post_deployment
tasks = self.fuel_web.client.get_end_deployment_tasks(

363
fuelweb_test/tests/gd_based_tests/test_neutron_vlan_ceph_mongo.py
View File

@ -196,50 +196,57 @@ class NeutronVlanCephMongo(TestBasic):
# check hiera
if self.get_post_test(tasks, 'hiera'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'hiera')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, 'hiera')[0]['cmd'])
# check globals
if self.get_post_test(tasks, 'globals'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'globals')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, 'globals')[0]['cmd'])
# check netcondfig
if self.get_post_test(tasks, 'netconfig'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'netconfig')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, 'netconfig')[0]['cmd'])
# check firewall
if self.get_post_test(all_tasks, 'firewall'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(all_tasks, 'firewall')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(all_tasks,
'firewall')[0]['cmd'])
# check hosts
if self.get_post_test(tasks, 'hosts'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'hosts')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, 'hosts')[0]['cmd'])
# check tools
if self.get_post_test(all_tasks, 'tools'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(all_tasks, 'tools')[0]['cmd'])
for node in nodes]
for node in nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(all_tasks, 'tools')[0]['cmd'])
self.env.make_snapshot('step_2_run_tasks_end_with_hosts')
@ -298,10 +305,12 @@ class NeutronVlanCephMongo(TestBasic):
# check mongo
if self.get_post_test(tasks, 'top-role-mongo'):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, 'tope-role-mongo')[0]['cmd'])
for node in mongo_nodes]
for node in mongo_nodes:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks,
'tope-role-mongo')[0]['cmd'])
self.env.make_snapshot('step_3_run_top_role_mongo_single')
@ -356,10 +365,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task)
if self.get_post_test(tasks, 'top-role-primary-mongo'):
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(primary_mongo.name),
path=self.get_post_test(
tasks, 'top-role-primary-mongo')[0]['cmd'])
with self.fuel_web.get_ssh_for_node(primary_mongo.name) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(
tasks, 'top-role-primary-mongo')[0]['cmd'])
self.env.make_snapshot('step_4_run_top_role_primary_mongo_single')
@ -403,9 +413,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_cluster = self.get_pre_test(tasks, 'cluster')
post_cluster = self.get_post_test(tasks, 'cluster')
if pre_cluster:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(primary_controller.name),
path=pre_cluster[0]['cmd'])
with self.fuel_web.get_ssh_for_node(
primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_cluster[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['cluster'],
@ -413,9 +425,12 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_cluster:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(primary_controller.name),
path=post_cluster[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=post_cluster[0]['cmd'])
self.env.make_snapshot("step_5_run_cluster_primary_controller")
@test(depends_on=[step_5_run_cluster_primary_controller],
@ -458,10 +473,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_virtual_ips = self.get_pre_test(tasks, 'virtual_ips')
post_virtual_ips = self.get_post_test(tasks, 'virtual_ips')
if pre_virtual_ips:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=pre_virtual_ips[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_virtual_ips[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['virtual_ips'],
@ -469,10 +485,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_virtual_ips:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=post_virtual_ips[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=post_virtual_ips[0]['cmd'])
self.env.make_snapshot('step_6_run_virtual_ips_primary_controller')
@ -519,10 +536,11 @@ class NeutronVlanCephMongo(TestBasic):
post_cluster_haproxy = self.get_post_test(tasks, 'cluster-haproxy')
if pre_cluster_haproxy:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=pre_cluster_haproxy[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_cluster_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['cluster-haproxy'],
@ -532,10 +550,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_cluster_haproxy:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=post_cluster_haproxy[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=post_cluster_haproxy[0]['cmd'])
self.env.make_snapshot(
"step_7_run_cluster_haproxy_primary_controller")
@ -581,10 +600,11 @@ class NeutronVlanCephMongo(TestBasic):
post_openstack_haproxy = self.get_post_test(tasks, 'openstack-haproxy')
if pre_openstack_haproxy:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=pre_openstack_haproxy[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_openstack_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-haproxy'],
@ -594,10 +614,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_openstack_haproxy:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=post_openstack_haproxy[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=post_openstack_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['dns-server'],
@ -623,10 +644,11 @@ class NeutronVlanCephMongo(TestBasic):
for service in ['memcached', 'openstack-cinder', 'database'
'rabbitmq', 'keystone', 'glance']:
if self.get_post_test(tasks, service):
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=self.get_post_test(tasks, service)[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, service)[0]['cmd'])
self.env.make_snapshot(
"step_8_run_openstack_haproxy_primary_controller")
@ -674,10 +696,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_openstack_ctr = self.get_pre_test(tasks, 'openstack-controller')
post_openstack_ctr = self.get_post_test(tasks, 'openstack-controller')
if pre_openstack_ctr:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=pre_openstack_ctr[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_openstack_ctr[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-controller'],
@ -686,10 +709,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_openstack_ctr:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=post_openstack_ctr[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=post_openstack_ctr[0]['cmd'])
self.env.make_snapshot(
"step_9_run_openstack_primary_controller")
@ -745,10 +769,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_net = self.get_pre_test(tasks, 'openstack-network')
if pre_net:
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=pre_net[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_net[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=[task['id'] for task in tasks],
@ -770,10 +795,11 @@ class NeutronVlanCephMongo(TestBasic):
for task in expected_task_list:
if self.get_post_test(tasks, task):
gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(
primary_controller.name),
path=self.get_post_test(tasks, task)[0]['cmd'])
with self.fuel_web\
.get_ssh_for_node(primary_controller.name) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, task)[0]['cmd'])
try:
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['sanity'],
@ -834,10 +860,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_cluster = self.get_pre_test(tasks, 'cluster')
post_cluster = self.get_post_test(tasks, 'cluster')
if pre_cluster:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_cluster[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_cluster[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['cluster'],
@ -845,10 +872,12 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_cluster:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_cluster[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_cluster[0]['cmd'])
self.env.make_snapshot("step_11_run_cluster_controller")
@test(depends_on=[step_11_run_cluster_controller],
@ -895,10 +924,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_virtual_ips = self.get_pre_test(tasks, 'virtual_ips')
post_virtual_ips = self.get_post_test(tasks, 'virtual_ips')
if pre_virtual_ips:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_virtual_ips[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_virtual_ips[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['virtual_ips'],
@ -907,10 +937,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_virtual_ips:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_virtual_ips[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_virtual_ips[0]['cmd'])
self.env.make_snapshot("step_12_run_virtual_ips_controller")
@ -958,10 +989,11 @@ class NeutronVlanCephMongo(TestBasic):
post_cluster_haproxy = self.get_post_test(tasks, 'cluster-haproxy')
if pre_cluster_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_cluster_haproxy[0]['cmd'])
for node in ['slave-02', 'slave-3']]
for node in ['slave-02', 'slave-3']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_cluster_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['cluster-haproxy'],
@ -971,10 +1003,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_cluster_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_cluster_haproxy[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_cluster_haproxy[0]['cmd'])
self.env.make_snapshot(
"step_13_run_cluster_haproxy_controller")
@ -1024,10 +1057,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_openstack_haproxy = self.get_pre_test(tasks, 'openstack-haproxy')
post_openstack_haproxy = self.get_post_test(tasks, 'openstack-haproxy')
if pre_openstack_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_openstack_haproxy[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_openstack_haproxy[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-haproxy'],
@ -1057,17 +1091,20 @@ class NeutronVlanCephMongo(TestBasic):
logger.debug('res info is {0}'.format(res))
self.fuel_web.assert_task_success(task=res)
if post_openstack_haproxy:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_openstack_haproxy[0]['cmd'])
for node in ['slave-01']]
for node in ['slave-01']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_openstack_haproxy[0]['cmd'])
for service in ['memcached', 'openstack-cinder'
'rabbitmq', 'keystone', 'glance', 'database']:
if self.get_post_test(tasks, service):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, service)[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, service)[0]['cmd'])
self.env.make_snapshot("step_14_run_openstack_haproxy_controller")
@ -1114,10 +1151,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_openstack_ctr = self.get_pre_test(tasks, 'openstack-controller')
post_openstack_ctr = self.get_post_test(tasks, 'openstack-controller')
if pre_openstack_ctr:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_openstack_ctr[0]['cmd'])
for node in ['slave-02', 'slave-01']]
for node in ['slave-02', 'slave-01']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_openstack_ctr[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['openstack-controller'],
@ -1126,10 +1164,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_openstack_ctr:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_openstack_ctr[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_openstack_ctr[0]['cmd'])
self.env.make_snapshot("step_15_run_openstack_controller")
@ -1183,10 +1222,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_net = self.get_pre_test(tasks, 'openstack-network')
if pre_net:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_net[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_net[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=[task['id'] for task in tasks],
@ -1207,10 +1247,11 @@ class NeutronVlanCephMongo(TestBasic):
for task in expected_task_list:
if self.get_post_test(tasks, task):
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=self.get_post_test(tasks, task)[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=self.get_post_test(tasks, task)[0]['cmd'])
try:
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['sanity'],
@ -1261,10 +1302,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_top_compute = self.get_pre_test(tasks, 'top-role-compute')
post_top_compute = self.get_post_test(tasks, 'top-role-compute')
if pre_top_compute:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_top_compute[0]['cmd'])
for node in ['slave-04', 'slave-05']]
for node in ['slave-04', 'slave-05']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_top_compute[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['top-role-compute'],
@ -1273,19 +1315,21 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_top_compute:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_top_compute[0]['cmd'])
for node in ['slave-04', 'slave-05']]
for node in ['slave-04', 'slave-05']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_top_compute[0]['cmd'])
for service in ['openstack-network-compute', 'ceilometer-compute']:
pre_test = self.get_pre_test(tasks, service)
post_test = self.get_post_test(tasks, service)
if pre_test:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_test[0]['cmd'])
for node in ['slave-04', 'slave-05']]
for node in ['slave-04', 'slave-05']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_test[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=[service],
@ -1295,10 +1339,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_test:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_test[0]['cmd'])
for node in ['slave-04', 'slave-05']]
for node in ['slave-04', 'slave-05']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_test[0]['cmd'])
self.env.make_snapshot("step_17_run_top_role_compute")
@ -1340,10 +1385,11 @@ class NeutronVlanCephMongo(TestBasic):
pre_top_ceph = self.get_pre_test(tasks, 'top-role-ceph-osd')
post_top_ceph = self.get_post_test(tasks, 'top-role-ceph-osd')
if pre_top_ceph:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=pre_top_ceph[0]['cmd'])
for node in ['slave-04', 'slave-05']]
for node in ['slave-04', 'slave-05']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=pre_top_ceph[0]['cmd'])
res = self.fuel_web.client.put_deployment_tasks_for_cluster(
cluster_id, data=['top-role-ceph-osd'],
@ -1352,10 +1398,11 @@ class NeutronVlanCephMongo(TestBasic):
self.fuel_web.assert_task_success(task=res)
if post_top_ceph:
[gd.run_check_from_task(
remote=self.fuel_web.get_ssh_for_node(node),
path=post_top_ceph[0]['cmd'])
for node in ['slave-02', 'slave-03']]
for node in ['slave-02', 'slave-03']:
with self.fuel_web.get_ssh_for_node(node) as remote:
gd.run_check_from_task(
remote=remote,
path=post_top_ceph[0]['cmd'])
self.env.make_snapshot("step_18_run_top_role_ceph_osd")

31
fuelweb_test/tests/plugins/plugin_contrail/test_fuel_plugin_contrail.py
View File

@ -49,14 +49,13 @@ class ContrailPlugin(TestBasic):
_pack_path = [CONTRAIL_PLUGIN_PACK_UB_PATH, CONTRAIL_PLUGIN_PACK_CEN_PATH]
def _upload_contrail_packages(self):
def _upload_contrail_packages(self, remote):
for pack in self._pack_path:
node_ssh = self.env.d_env.get_admin_remote()
if os.path.splitext(pack)[1] in [".deb", ".rpm"]:
pkg_name = os.path.basename(pack)
logger.debug("Uploading package {0} "
"to master node".format(pkg_name))
node_ssh.upload(pack, self._pack_copy_path)
remote.upload(pack, self._pack_copy_path)
else:
logger.error('Failed to upload file')
@ -86,21 +85,23 @@ class ContrailPlugin(TestBasic):
self.env.revert_snapshot("ready_with_%d_slaves" % slaves)
# copy plugin to the master node
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
CONTRAIL_PLUGIN_PATH, '/var')
with self.env.d_env.get_admin_remote() as remote:
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(CONTRAIL_PLUGIN_PATH))
# copy plugin to the master node
checkers.upload_tarball(
remote,
CONTRAIL_PLUGIN_PATH, '/var')
# copy additional packages to the master node
self._upload_contrail_packages()
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(CONTRAIL_PLUGIN_PATH))
# install packages
self._install_packages(self.env.d_env.get_admin_remote())
# copy additional packages to the master node
self._upload_contrail_packages(remote)
# install packages
self._install_packages(remote)
# prepare fuel
self._assign_net_provider(pub_net)

19
fuelweb_test/tests/plugins/plugin_elasticsearch/test_plugin_elasticsearch.py
View File

@ -56,17 +56,16 @@ class TestElasticsearchPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_3_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote,
ELASTICSEARCH_KIBANA_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
ELASTICSEARCH_KIBANA_PLUGIN_PATH, '/var')
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(ELASTICSEARCH_KIBANA_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(ELASTICSEARCH_KIBANA_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,

23
fuelweb_test/tests/plugins/plugin_emc/test_plugin_emc.py
View File

@ -104,17 +104,16 @@ class EMCPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote,
CONF.EMC_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
CONF.EMC_PLUGIN_PATH, '/var')
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(CONF.EMC_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(CONF.EMC_PLUGIN_PATH))
settings = None
@ -200,6 +199,10 @@ class EMCPlugin(TestBasic):
cinder_volume_comps = [self.check_service(compute, "cinder-volume")
for compute in compute_remotes]
# closing connections
[remote.clear() for remote in controller_remotes]
[remote.clear() for remote in compute_remotes]
asserts.assert_equal(sum(cinder_volume_comps), 0,
"Cluster has active cinder-volume on compute")

44
fuelweb_test/tests/plugins/plugin_example/test_fuel_plugin_example.py
View File

@ -56,15 +56,17 @@ class ExamplePlugin(TestBasic):
# copy plugin to the master node
checkers.check_archive_type(EXAMPLE_PLUGIN_PATH)
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
EXAMPLE_PLUGIN_PATH, '/var')
# install plugin
with self.env.d_env.get_admin_remote() as remote:
checkers.upload_tarball(
remote,
EXAMPLE_PLUGIN_PATH, '/var')
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
segment_type = NEUTRON_SEGMENT['vlan']
cluster_id = self.fuel_web.create_cluster(
@ -282,14 +284,16 @@ class ExamplePlugin(TestBasic):
# copy plugin to the master node
checkers.check_archive_type(EXAMPLE_PLUGIN_PATH)
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), EXAMPLE_PLUGIN_PATH, '/var')
# install plugin
with self.env.d_env.get_admin_remote() as remote:
checkers.upload_tarball(
remote, EXAMPLE_PLUGIN_PATH, '/var')
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
@ -373,14 +377,16 @@ class ExamplePlugin(TestBasic):
# copy plugin to the master node
checkers.check_archive_type(EXAMPLE_PLUGIN_PATH)
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), EXAMPLE_PLUGIN_PATH, '/var')
# install plugin
with self.env.d_env.get_admin_remote() as remote:
checkers.upload_tarball(
remote, EXAMPLE_PLUGIN_PATH, '/var')
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(EXAMPLE_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,

60
fuelweb_test/tests/plugins/plugin_glusterfs/test_plugin_glusterfs.py
View File

@ -67,16 +67,15 @@ class GlusterfsPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_3_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote, GLUSTER_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), GLUSTER_PLUGIN_PATH, '/var')
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(GLUSTER_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(GLUSTER_PLUGIN_PATH))
settings = None
@ -113,10 +112,11 @@ class GlusterfsPlugin(TestBasic):
for node in ('slave-01', 'slave-03'):
_ip = self.fuel_web.get_nailgun_node_by_name(node)['ip']
self.check_glusterfs_conf(
remote=self.env.d_env.get_ssh_to_remote(_ip),
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
self.check_glusterfs_conf(
remote=remote,
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
self.fuel_web.verify_network(cluster_id)
@ -153,16 +153,16 @@ class GlusterfsPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote, GLUSTER_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), GLUSTER_PLUGIN_PATH, '/var')
# install plugin
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(GLUSTER_PLUGIN_PATH))
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(GLUSTER_PLUGIN_PATH))
settings = None
@ -198,10 +198,11 @@ class GlusterfsPlugin(TestBasic):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-03")['ip']
self.check_glusterfs_conf(
remote=self.env.d_env.get_ssh_to_remote(_ip),
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
self.check_glusterfs_conf(
remote=remote,
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
self.fuel_web.verify_network(cluster_id)
@ -220,10 +221,11 @@ class GlusterfsPlugin(TestBasic):
for node in ('slave-03', 'slave-04', 'slave-05'):
_ip = self.fuel_web.get_nailgun_node_by_name(node)['ip']
self.check_glusterfs_conf(
remote=self.env.d_env.get_ssh_to_remote(_ip),
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
self.check_glusterfs_conf(
remote=remote,
path='/etc/cinder/glusterfs',
gfs_endpoint=GLUSTER_CLUSTER_ENDPOINT)
self.fuel_web.run_ostf(
cluster_id=cluster_id)

33
fuelweb_test/tests/plugins/plugin_lbaas/test_plugin_lbaas.py
View File

@ -113,16 +113,16 @@ class LbaasPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_3_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote, LBAAS_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), LBAAS_PLUGIN_PATH, '/var')
# install plugin
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(LBAAS_PLUGIN_PATH))
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(LBAAS_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
@ -198,16 +198,15 @@ class LbaasPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_3_slaves")
# copy plugin to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugin to the master node
checkers.upload_tarball(
remote, LBAAS_PLUGIN_PATH, '/var')
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), LBAAS_PLUGIN_PATH, '/var')
# install plugin
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(LBAAS_PLUGIN_PATH))
# install plugin
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(LBAAS_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,

43
fuelweb_test/tests/plugins/plugin_lma_collector/test_plugin_lma_collector.py
View File

@ -58,29 +58,28 @@ class TestLmaCollectorPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
# copy plugins to the master node
with self.env.d_env.get_admin_remote() as remote:
# copy plugins to the master node
checkers.upload_tarball(
remote,
conf.LMA_COLLECTOR_PLUGIN_PATH, "/var")
checkers.upload_tarball(
remote,
conf.ELASTICSEARCH_KIBANA_PLUGIN_PATH, "/var")
checkers.upload_tarball(
remote,
conf.INFLUXDB_GRAFANA_PLUGIN_PATH, "/var")
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
conf.LMA_COLLECTOR_PLUGIN_PATH, "/var")
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
conf.ELASTICSEARCH_KIBANA_PLUGIN_PATH, "/var")
checkers.upload_tarball(
self.env.d_env.get_admin_remote(),
conf.INFLUXDB_GRAFANA_PLUGIN_PATH, "/var")
# install plugins
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(conf.LMA_COLLECTOR_PLUGIN_PATH))
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(conf.ELASTICSEARCH_KIBANA_PLUGIN_PATH))
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(conf.INFLUXDB_GRAFANA_PLUGIN_PATH))
# install plugins
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(conf.LMA_COLLECTOR_PLUGIN_PATH))
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(conf.ELASTICSEARCH_KIBANA_PLUGIN_PATH))
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(conf.INFLUXDB_GRAFANA_PLUGIN_PATH))
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,

61
fuelweb_test/tests/plugins/plugin_zabbix/test_plugin_zabbix.py
View File

@ -165,11 +165,13 @@ class ZabbixPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), conf.ZABBIX_PLUGIN_PATH, "/var")
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(conf.ZABBIX_PLUGIN_PATH))
with self.env.d_env.get_admin_remote() as remote:
checkers.upload_tarball(
remote, conf.ZABBIX_PLUGIN_PATH, "/var")
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(conf.ZABBIX_PLUGIN_PATH))
settings = None
if conf.NEUTRON_ENABLE:
@ -251,13 +253,14 @@ class ZabbixPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH]:
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), plugin, "/var")
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(plugin))
with self.env.d_env.get_admin_remote() as remote:
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH]:
checkers.upload_tarball(
remote, plugin, "/var")
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(plugin))
settings = None
@ -373,14 +376,15 @@ class ZabbixPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH,
conf.ZABBIX_SNMP_EMC_PLUGIN_PATH]:
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), plugin, "/var")
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(plugin))
with self.env.d_env.get_admin_remote() as remote:
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH,
conf.ZABBIX_SNMP_EMC_PLUGIN_PATH]:
checkers.upload_tarball(
remote, plugin, "/var")
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(plugin))
settings = None
@ -463,14 +467,15 @@ class ZabbixPlugin(TestBasic):
"""
self.env.revert_snapshot("ready_with_5_slaves")
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH,
conf.ZABBIX_SNMP_EXTREME_PLUGIN_PATH]:
checkers.upload_tarball(
self.env.d_env.get_admin_remote(), plugin, "/var")
checkers.install_plugin_check_code(
self.env.d_env.get_admin_remote(),
plugin=os.path.basename(plugin))
with self.env.d_env.get_admin_remote() as remote:
for plugin in [conf.ZABBIX_PLUGIN_PATH,
conf.ZABBIX_SNMP_PLUGIN_PATH,
conf.ZABBIX_SNMP_EXTREME_PLUGIN_PATH]:
checkers.upload_tarball(
remote, plugin, "/var")
checkers.install_plugin_check_code(
remote,
plugin=os.path.basename(plugin))
settings = None

23
fuelweb_test/tests/test_admin_node.py
View File

@ -80,8 +80,8 @@ class TestAdminNode(TestBasic):
"""
self.env.revert_snapshot("empty")
ps_output = self.env.d_env.get_admin_remote().execute(
'ps ax')['stdout']
with self.env.d_env.get_admin_remote() as remote:
ps_output = remote.execute('ps ax')['stdout']
astute_master = filter(lambda x: 'astute master' in x, ps_output)
logger.info("Found astute processes: %s" % astute_master)
assert_equal(len(astute_master), 1)
@ -521,14 +521,14 @@ class FuelMasterMigrate(TestBasic):
wait(lambda: icmp_ping(self.env.get_admin_node_ip()),
timeout=60 * 15, timeout_msg='Master node has not become online '
'after rebooting')
wait(lambda: self.env.d_env.get_admin_remote(), timeout=60 * 15,
timeout_msg='Master node has not become online after rebooting')
checkers.wait_phrase_in_log(self.env.d_env.get_admin_remote(),
60 * 90, interval=0.1,
phrase='Stop network and up with '
'new settings',
log_path='/var/log/fuel-migrate.log')
self.env.d_env.nodes().admin.await(network_name=self.d_env.admin_net,
timeout=60 * 15)
with self.env.d_env.get_admin_remote() as remote:
checkers.wait_phrase_in_log(remote,
60 * 90, interval=0.1,
phrase='Stop network and up with '
'new settings',
log_path='/var/log/fuel-migrate.log')
logger.info('Shutting down network')
wait(lambda: not icmp_ping(self.env.get_admin_node_ip()),
@ -538,7 +538,8 @@ class FuelMasterMigrate(TestBasic):
timeout=60 * 15,
timeout_msg='Master node has not become online shutting network')
wait(lambda: self.env.d_env.get_admin_remote(), timeout=60 * 10)
self.env.d_env.nodes().admin.await(network_name=self.d_env.admin_net,
timeout=60 * 10)
logger.info("Check containers")
self.env.docker_actions.wait_for_ready_containers(timeout=60 * 30)

61
fuelweb_test/tests/test_ceph.py
View File

@ -120,8 +120,8 @@ class CephCompact(TestBasic):
data=image_data)
volume = os_conn.create_volume(size=1, image_id=image.id)
remote = self.fuel_web.get_ssh_for_node('slave-01')
rbd_list = ceph.get_rbd_images_list(remote, 'volumes')
with self.fuel_web.get_ssh_for_node('slave-01') as remote:
rbd_list = ceph.get_rbd_images_list(remote, 'volumes')
for item in rbd_list:
if volume.id in item['image']:
@ -342,17 +342,18 @@ class CephHA(TestBasic):
# create image
devops_node = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0])
slave = self.fuel_web.get_ssh_for_node(devops_node.name)
if settings.OPENSTACK_RELEASE_CENTOS in settings.OPENSTACK_RELEASE:
slave.execute(". openrc; glance image-create --name"
" 'custom-image' --disk-format qcow2"
" --container-format bare"
" --file /opt/vm/cirros-x86_64-disk.img")
else:
slave.execute(". openrc; glance image-create --name"
" 'custom-image' --disk-format qcow2"
" --container-format bare --file"
" /usr/share/cirros-testvm/cirros-x86_64-disk.img")
with self.fuel_web.get_ssh_for_node(devops_node.name) as slave:
if settings.OPENSTACK_RELEASE_CENTOS in settings.OPENSTACK_RELEASE:
slave.execute(". openrc; glance image-create --name"
" 'custom-image' --disk-format qcow2"
" --container-format bare"
" --file /opt/vm/cirros-x86_64-disk.img")
else:
slave.execute(
". openrc; glance image-create --name"
" 'custom-image' --disk-format qcow2"
" --container-format bare --file"
" /usr/share/cirros-testvm/cirros-x86_64-disk.img")
image = os_conn.get_image_by_name('custom-image')
@ -478,10 +479,10 @@ class CephRadosGW(TestBasic):
logger.info("Check all HAProxy backends on {}".format(
node['meta']['system']['fqdn']))
haproxy_status = checkers.check_haproxy_backend(remote)
remote.clear()
assert_equal(haproxy_status['exit_code'], 1,
"HAProxy backends are DOWN. {0}".format(
haproxy_status))
remote.clear()
self.fuel_web.check_ceph_status(cluster_id)
@ -490,12 +491,11 @@ class CephRadosGW(TestBasic):
test_sets=['ha', 'smoke', 'sanity'])
# Check the radosqw daemon is started
remote = self.fuel_web.get_ssh_for_node('slave-01')
radosgw_started = lambda: len(remote.check_call(
'ps aux | grep "/usr/bin/radosgw -n '
'client.radosgw.gateway"')['stdout']) == 3
assert_true(radosgw_started(), 'radosgw daemon started')
remote.clear()
with self.fuel_web.get_ssh_for_node('slave-01') as remote:
radosgw_started = lambda: len(remote.check_call(
'ps aux | grep "/usr/bin/radosgw -n '
'client.radosgw.gateway"')['stdout']) == 3
assert_true(radosgw_started(), 'radosgw daemon started')
self.env.make_snapshot("ceph_rados_gw")
@ -829,9 +829,10 @@ class CheckCephPartitionsAfterReboot(TestBasic):
self.show_step(7, node)
logger.info("Get partitions for {node}".format(node=node))
_ip = self.fuel_web.get_nailgun_node_by_name(node)['ip']
before_reboot_partitions = [checkers.get_ceph_partitions(
self.env.d_env.get_ssh_to_remote(_ip),
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
before_reboot_partitions = [checkers.get_ceph_partitions(
remote,
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
self.show_step(8, node)
logger.info("Warm-restart nodes")
@ -843,9 +844,10 @@ class CheckCephPartitionsAfterReboot(TestBasic):
node=node
))
_ip = self.fuel_web.get_nailgun_node_by_name(node)['ip']
after_reboot_partitions = [checkers.get_ceph_partitions(
self.env.d_env.get_ssh_to_remote(_ip),
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
after_reboot_partitions = [checkers.get_ceph_partitions(
remote,
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
if before_reboot_partitions != after_reboot_partitions:
logger.info("Partitions don`t match")
@ -864,9 +866,10 @@ class CheckCephPartitionsAfterReboot(TestBasic):
self.show_step(12, node)
_ip = self.fuel_web.get_nailgun_node_by_name(node)['ip']
after_reboot_partitions = [checkers.get_ceph_partitions(
self.env.d_env.get_ssh_to_remote(_ip),
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
after_reboot_partitions = [checkers.get_ceph_partitions(
remote,
"/dev/vd{p}".format(p=part)) for part in ["b", "c"]]
if before_reboot_partitions != after_reboot_partitions:
logger.info("Partitions don`t match")

112
fuelweb_test/tests/test_cli.py
View File

@ -69,23 +69,23 @@ class CommandLineMinimal(TestBasic):
cluster_id,
{'slave-01': ['controller']}
)
remote = self.env.d_env.get_admin_remote()
node_id = self.fuel_web.get_nailgun_node_by_devops_node(
self.env.d_env.nodes().slaves[0])['id']
remote.execute('fuel node --node {0} --provision --env {1}'.format
(node_id, cluster_id))
self.fuel_web.provisioning_cluster_wait(cluster_id)
remote.execute('fuel node --node {0} --end hiera --env {1}'.format
(node_id, cluster_id))
try:
wait(lambda: int(
remote.execute(
'fuel task | grep deployment | awk \'{print $9}\'')
['stdout'][0].rstrip()) == 100, timeout=120)
except TimeoutError:
raise TimeoutError("hiera manifest was not applyed")
role = remote.execute('ssh -q node-{0} "hiera role"'.format
(node_id))['stdout'][0].rstrip()
with self.env.d_env.get_admin_remote() as remote:
node_id = self.fuel_web.get_nailgun_node_by_devops_node(
self.env.d_env.nodes().slaves[0])['id']
remote.execute('fuel node --node {0} --provision --env {1}'.format
(node_id, cluster_id))
self.fuel_web.provisioning_cluster_wait(cluster_id)
remote.execute('fuel node --node {0} --end hiera --env {1}'.format
(node_id, cluster_id))
try:
wait(lambda: int(
remote.execute(
'fuel task | grep deployment | awk \'{print $9}\'')
['stdout'][0].rstrip()) == 100, timeout=120)
except TimeoutError:
raise TimeoutError("hiera manifest was not applyed")
role = remote.execute('ssh -q node-{0} "hiera role"'
.format(node_id))['stdout'][0].rstrip()
assert_equal(role, 'primary-controller', "node with deployed hiera "
"was not found")
@ -303,12 +303,12 @@ class CommandLine(TestBasic):
"""
self.env.revert_snapshot("cli_selected_nodes_deploy")
remote = self.env.d_env.get_admin_remote()
node_id = self.fuel_web.get_nailgun_node_by_devops_node(
self.env.d_env.nodes().slaves[2])['id']
with self.env.d_env.get_admin_remote() as remote:
node_id = self.fuel_web.get_nailgun_node_by_devops_node(
self.env.d_env.nodes().slaves[2])['id']
assert_true(check_cobbler_node_exists(remote, node_id),
"node-{0} is not found".format(node_id))
assert_true(check_cobbler_node_exists(remote, node_id),
"node-{0} is not found".format(node_id))
self.env.d_env.nodes().slaves[2].destroy()
try:
wait(
@ -317,25 +317,35 @@ class CommandLine(TestBasic):
slaves[2])['online'], timeout=60 * 6)
except TimeoutError:
raise
with self.env.d_env.get_admin_remote() as remote:
res = remote.execute('fuel node --node-id {0} --delete-from-db'
.format(node_id))
assert_true(
remote.execute('fuel node --node-id {0} --delete-from-db'.
format(node_id))['exit_code'] == 0,
"Offline node-{0} was not deleted from database".format(node_id)
)
try:
wait(
lambda: not remote.execute(
"fuel node | awk '{{print $1}}' | grep -w '{0}'".
format(node_id))['exit_code'] == 0, timeout=60 * 2)
except TimeoutError:
raise TimeoutError(
"After deletion node-{0} is found in fuel list".
format(node_id))
assert_false(check_cobbler_node_exists(remote, node_id),
res['exit_code'] == 0,
"Offline node-{0} was not"
"deleted from database".format(node_id))
with self.env.d_env.get_admin_remote() as remote:
try:
wait(
lambda: not remote.execute(
"fuel node | awk '{{print $1}}' | grep -w '{0}'".
format(node_id))['exit_code'] == 0, timeout=60 * 2)
except TimeoutError:
raise TimeoutError(
"After deletion node-{0} is found in fuel list".
format(node_id))
with self.env.d_env.get_admin_remote() as remote:
is_cobler_node_exists = check_cobbler_node_exists(remote, node_id)
assert_false(is_cobler_node_exists,
"After deletion node-{0} is found in cobbler list".
format(node_id))
cluster_id = ''.join(remote.execute(
"fuel env | tail -n 1 | awk {'print $1'}")['stdout']).rstrip()
with self.env.d_env.get_admin_remote() as remote:
cluster_id = ''.join(remote.execute(
"fuel env | tail -n 1 | awk {'print $1'}")['stdout']).rstrip()
self.fuel_web.verify_network(cluster_id)
@ -359,19 +369,23 @@ class CommandLine(TestBasic):
"""
self.env.revert_snapshot("cli_selected_nodes_deploy")
remote = self.env.d_env.get_admin_remote()
cluster_id = self.fuel_web.get_last_created_cluster()
with self.env.d_env.get_admin_remote() as remote:
res = remote.execute('fuel --env {0} env delete'
.format(cluster_id))
assert_true(
remote.execute('fuel --env {0} env delete'.format(cluster_id))
['exit_code'] == 0)
try:
wait(lambda:
remote.execute(
"fuel env | awk '{print $1}' | tail -n 1 | grep '^.$'")
['exit_code'] == 1, timeout=60 * 6)
except TimeoutError:
raise TimeoutError(
"cluster {0} was not deleted".format(cluster_id))
res['exit_code'] == 0)
with self.env.d_env.get_admin_remote() as remote:
try:
wait(lambda:
remote.execute("fuel env | awk '{print $1}'"
" | tail -n 1 | grep '^.$'")
['exit_code'] == 1, timeout=60 * 6)
except TimeoutError:
raise TimeoutError(
"cluster {0} was not deleted".format(cluster_id))
assert_false(
check_cluster_presence(cluster_id, self.env.postgres_actions),
"cluster {0} is found".format(cluster_id))

18
fuelweb_test/tests/test_custom_hostname.py
View File

@ -95,6 +95,8 @@ class CustomHostname(TestBasic):
"{0} node is not accessible by its default "
"hostname {1}".format(devops_node.name, node['hostname']))
admin_remote.clear()
self.env.make_snapshot("default_hostname")
@test(depends_on=[SetupEnvironment.prepare_slaves_5],
@ -120,8 +122,6 @@ class CustomHostname(TestBasic):
for method in ('API', 'CLI'):
self.env.revert_snapshot("ready_with_5_slaves")
admin_remote = self.env.d_env.get_admin_remote()
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
@ -150,9 +150,10 @@ class CustomHostname(TestBasic):
self.fuel_web.client.set_hostname(node['id'],
custom_hostname)
elif method == 'CLI':
admin_remote.execute(
'fuel node --node-id {0} --hostname '
'{1}'.format(node['id'], custom_hostname))
with self.env.d_env.get_admin_remote() as admin_remote:
admin_remote.execute(
'fuel node --node-id {0} --hostname '
'{1}'.format(node['id'], custom_hostname))
self.fuel_web.deploy_cluster_wait(cluster_id, check_services=False)
@ -169,9 +170,10 @@ class CustomHostname(TestBasic):
custom_hostnames):
devops_node = self.fuel_web.get_devops_node_by_nailgun_node(
node)
hostname = admin_remote.execute(
"ssh -q {0} hostname "
"-s".format(custom_hostname))['stdout'][0].strip()
with self.env.d_env.get_admin_remote() as admin_remote:
hostname = admin_remote.execute(
"ssh -q {0} hostname "
"-s".format(custom_hostname))['stdout'][0].strip()
assert_equal(
custom_hostname,
hostname,

5
fuelweb_test/tests/test_ha_one_controller.py
View File

@ -291,9 +291,8 @@ class HAOneControllerNeutron(HAOneControllerNeutronBase):
self.fuel_web.run_ostf(cluster_id=cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-03")['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
result = remote.execute('readlink /etc/astute.yaml')['stdout']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
result = remote.execute('readlink /etc/astute.yaml')['stdout']
assert_true("base-os" in result[0],
"Role mismatch. Node slave-03 is not base-os")

42
fuelweb_test/tests/test_neutron.py
View File

@ -137,17 +137,18 @@ class NeutronGreHa(TestBasic):
self.env.d_env.nodes().slaves[0])
logger.debug("devops node name is {0}".format(devops_node.name))
_ip = self.fuel_web.get_nailgun_node_by_name(devops_node.name)['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
for i in range(5):
try:
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
for i in range(5):
try:
checkers.check_swift_ring(remote)
break
except AssertionError:
result = remote.execute(
"/usr/local/bin/swift-rings-rebalance.sh")
logger.debug("command execution result is {0}"
.format(result))
else:
checkers.check_swift_ring(remote)
break
except AssertionError:
result = remote.execute(
"/usr/local/bin/swift-rings-rebalance.sh")
logger.debug("command execution result is {0}".format(result))
else:
checkers.check_swift_ring(remote)
self.fuel_web.run_ostf(
cluster_id=cluster_id,
@ -215,17 +216,18 @@ class NeutronVlanHa(TestBasic):
self.env.d_env.nodes().slaves[0])
logger.debug("devops node name is {0}".format(devops_node.name))
_ip = self.fuel_web.get_nailgun_node_by_name(devops_node.name)['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
for i in range(5):
try:
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
for i in range(5):
try:
checkers.check_swift_ring(remote)
break
except AssertionError:
result = remote.execute(
"/usr/local/bin/swift-rings-rebalance.sh")
logger.debug("command execution result is {0}"
.format(result))
else:
checkers.check_swift_ring(remote)
break
except AssertionError:
result = remote.execute(
"/usr/local/bin/swift-rings-rebalance.sh")
logger.debug("command execution result is {0}".format(result))
else:
checkers.check_swift_ring(remote)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['ha', 'smoke', 'sanity'])

109
fuelweb_test/tests/test_services.py
View File

@ -90,12 +90,13 @@ class SaharaHAOneController(TestBasic):
LOGGER.debug('Verify Sahara service on controller')
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='sahara-api')
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='sahara-engine')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='sahara-api')
checkers.verify_service(
remote,
service_name='sahara-engine')
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
@ -198,12 +199,13 @@ class SaharaHA(TestBasic):
LOGGER.debug('Verify Sahara service on all controllers')
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='sahara-api')
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='sahara-engine')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='sahara-api')
checkers.verify_service(
remote,
service_name='sahara-engine')
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
@ -292,9 +294,10 @@ class MuranoHAOneController(TestBasic):
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='murano-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='murano-api')
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
@ -380,9 +383,10 @@ class MuranoHA(TestBasic):
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=13)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='murano-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='murano-api')
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
@ -543,13 +547,15 @@ class CeilometerHAOneControllerMongo(OSTFCeilometerHelper):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
_ip = self.fuel_web.get_nailgun_node_by_name("slave-03")['ip']
partitions = checkers.get_mongo_partitions(
self.env.d_env.get_ssh_to_remote(_ip), "vda5")
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
partitions = checkers.get_mongo_partitions(remote, "vda5")
assert_equal(partitions[0].rstrip(), mongo_disk_gb,
'Mongo size {0} before deployment is not equal'
' to size after {1}'.format(mongo_disk_gb, partitions))
@ -598,9 +604,10 @@ class CeilometerHAOneControllerMongo(OSTFCeilometerHelper):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_one_controller_multirole")
@ -655,9 +662,10 @@ class CeilometerHAMongo(OSTFCeilometerHelper):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
self.run_tests(cluster_id,
skip_tests=['test_check_volume_notifications'])
@ -706,9 +714,10 @@ class CeilometerHAMongo(OSTFCeilometerHelper):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_multirole", is_make=True)
@ -800,9 +809,10 @@ class CeilometerHAMongo(OSTFCeilometerHelper):
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_external_mongo")
@ -863,14 +873,16 @@ class HeatHAOneController(TestBasic):
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='heat-api', count=3)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='heat-api', count=3)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')
@ -955,14 +967,13 @@ class HeatHA(TestBasic):
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='heat-api', count=3)
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='heat-api', count=3)
checkers.verify_service(
remote,
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')

26
fuelweb_test/tests/tests_patching/test_patching.py
View File

@ -130,10 +130,10 @@ class PatchingTests(TestBasic):
for repo in patching_repos:
patching.connect_slaves_to_repo(self.env, slaves, repo)
if settings.PATCHING_MASTER_MIRRORS:
for repo in patching_master_repos:
remote = self.env.d_env.get_admin_remote()
install_pkg(remote, 'yum-utils')
patching.connect_admin_to_repo(self.env, repo)
with self.env.d_env.get_admin_remote() as remote:
for repo in patching_master_repos:
install_pkg(remote, 'yum-utils')
patching.connect_admin_to_repo(self.env, repo)
# Step #5
if settings.LATE_ARTIFACTS_JOB_URL:
@ -219,9 +219,10 @@ class PatchingTests(TestBasic):
test_sets=['smoke', 'ha'])
if "ceph-osd" in roles:
remote_ceph = self.fuel_web.get_ssh_for_node(
'slave-0{}'.format(number_of_nodes + 1))
self.fuel_web.prepare_ceph_to_delete(remote_ceph)
with self.fuel_web.get_ssh_for_node(
'slave-0{}'.format(number_of_nodes + 1)
) as remote_ceph:
self.fuel_web.prepare_ceph_to_delete(remote_ceph)
nailgun_node = self.fuel_web.update_nodes(
cluster_id, node, False, True)
@ -302,8 +303,8 @@ class PatchingMasterTests(TestBasic):
'" failed.'.format(self.snapshot_name))
# Step #1
remote = self.env.d_env.get_admin_remote()
install_pkg(remote, 'yum-utils')
with self.env.d_env.get_admin_remote() as remote:
install_pkg(remote, 'yum-utils')
patching_repos = patching.add_remote_repositories(
self.env, settings.PATCHING_MASTER_MIRRORS)
@ -377,9 +378,10 @@ class PatchingMasterTests(TestBasic):
test_sets=['smoke', 'ha'])
if "ceph-osd" in roles:
remote_ceph = self.fuel_web.get_ssh_for_node(
'slave-0{}'.format(number_of_nodes + 1))
self.fuel_web.prepare_ceph_to_delete(remote_ceph)
with self.fuel_web.get_ssh_for_node(
'slave-0{}'.format(number_of_nodes + 1)
) as remote:
self.fuel_web.prepare_ceph_to_delete(remote)
nailgun_node = self.fuel_web.update_nodes(
cluster_id, node, False, True)
nodes = filter(

329
fuelweb_test/tests/tests_strength/test_failover_base.py
View File

@ -298,17 +298,18 @@ class TestHaFailoverBase(TestBasic):
self.env.revert_snapshot(self.snapshot_name)
for devops_node in self.env.d_env.nodes().slaves[:3]:
remote = self.fuel_web.get_ssh_for_node(devops_node.name)
logger.info('Terminating MySQL on {0}'.format(devops_node.name))
with self.fuel_web.get_ssh_for_node(devops_node.name) as remote:
logger.info('Terminating MySQL on {0}'
.format(devops_node.name))
try:
remote.check_call('pkill -9 -x "mysqld"')
except:
logger.error('MySQL on {0} is down after snapshot revert'.
format(devops_node.name))
raise
try:
remote.check_call('pkill -9 -x "mysqld"')
except:
logger.error('MySQL on {0} is down after snapshot revert'.
format(devops_node.name))
raise
check_mysql(remote, devops_node.name)
check_mysql(remote, devops_node.name)
cluster_id = self.fuel_web.client.get_cluster_id(
self.__class__.__name__)
@ -327,16 +328,16 @@ class TestHaFailoverBase(TestBasic):
self.env.revert_snapshot(self.snapshot_name)
for devops_node in self.env.d_env.nodes().slaves[:3]:
remote = self.fuel_web.get_ssh_for_node(devops_node.name)
remote.check_call('kill -9 $(pidof haproxy)')
with self.fuel_web.get_ssh_for_node(devops_node.name) as remote:
remote.check_call('kill -9 $(pidof haproxy)')
def haproxy_started():
ret = remote.execute(
'[ -f /var/run/haproxy.pid ] && '
'[ "$(ps -p $(cat /var/run/haproxy.pid) -o pid=)" == '
'"$(pidof haproxy)" ]'
)
return ret['exit_code'] == 0
def haproxy_started():
ret = remote.execute(
'[ -f /var/run/haproxy.pid ] && '
'[ "$(ps -p $(cat /var/run/haproxy.pid) -o pid=)" == '
'"$(pidof haproxy)" ]'
)
return ret['exit_code'] == 0
wait(haproxy_started, timeout=20)
assert_true(haproxy_started(), 'haproxy restarted')
@ -413,51 +414,62 @@ class TestHaFailoverBase(TestBasic):
" AMQP server: AMQP connection test returned 1"
heat_name = 'heat-engine'
ocf_status = \
'script -q -c "OCF_ROOT=/usr/lib/ocf' \
' /usr/lib/ocf/resource.d/fuel/{0}' \
' monitor 2>&1"'.format(heat_name)
remote = self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name)
pid = ''.join(remote.execute('pgrep heat-engine')['stdout'])
get_ocf_status = ''.join(
remote.execute(ocf_status)['stdout']).rstrip()
node_name = self.env.d_env.nodes().slaves[0].name
with self.fuel_web.get_ssh_for_node(node_name) as remote:
pid = ''.join(remote.execute('pgrep {0}'
.format(heat_name))['stdout'])
get_ocf_status = ''.join(
remote.execute(ocf_status)['stdout']).rstrip()
assert_true(ocf_success in get_ocf_status,
"heat engine is not succeeded, status is {0}".format(
get_ocf_status))
assert_true(len(remote.execute(
"netstat -nap | grep {0} | grep :5673".
format(pid))['stdout']) > 0, 'There is no amqp connections')
remote.execute("iptables -I OUTPUT 1 -m owner --uid-owner heat -m"
" state --state NEW,ESTABLISHED,RELATED -j DROP")
cmd = "netstat -nap | grep {0} | grep :5673".format(pid)
wait(lambda: len(remote.execute(cmd)['stdout']) == 0, timeout=300)
with self.fuel_web.get_ssh_for_node(node_name) as remote:
amqp_con = len(remote.execute(
"netstat -nap | grep {0} | grep :5673".
format(pid))['stdout'])
assert_true(amqp_con > 0, 'There is no amqp connections')
get_ocf_status = ''.join(
remote.execute(ocf_status)['stdout']).rstrip()
with self.fuel_web.get_ssh_for_node(node_name) as remote:
remote.execute("iptables -I OUTPUT 1 -m owner --uid-owner heat -m"
" state --state NEW,ESTABLISHED,RELATED -j DROP")
cmd = "netstat -nap | grep {0} | grep :5673".format(pid)
wait(lambda: len(remote.execute(cmd)['stdout']) == 0, timeout=300)
get_ocf_status = ''.join(
remote.execute(ocf_status)['stdout']).rstrip()
logger.info('ocf status after blocking is {0}'.format(
get_ocf_status))
assert_true(ocf_error in get_ocf_status,
"heat engine is running, status is {0}".format(
get_ocf_status))
remote.execute("iptables -D OUTPUT 1 -m owner --uid-owner heat -m"
" state --state NEW,ESTABLISHED,RELATED")
_wait(lambda: assert_true(ocf_success in ''.join(
remote.execute(ocf_status)['stdout']).rstrip()), timeout=240)
newpid = ''.join(remote.execute('pgrep heat-engine')['stdout'])
assert_true(pid != newpid, "heat pid is still the same")
get_ocf_status = ''.join(remote.execute(
ocf_status)['stdout']).rstrip()
with self.fuel_web.get_ssh_for_node(node_name) as remote:
remote.execute("iptables -D OUTPUT 1 -m owner --uid-owner heat -m"
" state --state NEW,ESTABLISHED,RELATED")
_wait(lambda: assert_true(ocf_success in ''.join(
remote.execute(ocf_status)['stdout']).rstrip()), timeout=240)
newpid = ''.join(remote.execute('pgrep {0}'
.format(heat_name))['stdout'])
assert_true(pid != newpid, "heat pid is still the same")
get_ocf_status = ''.join(remote.execute(
ocf_status)['stdout']).rstrip()
assert_true(ocf_success in get_ocf_status,
"heat engine is not succeeded, status is {0}".format(
get_ocf_status))
assert_true(len(
remote.execute("netstat -nap | grep {0} | grep :5673".format(
newpid))['stdout']) > 0)
with self.fuel_web.get_ssh_for_node(node_name) as remote:
heat = len(
remote.execute("netstat -nap | grep {0} | grep :5673"
.format(newpid))['stdout'])
assert_true(heat > 0)
cluster_id = self.fuel_web.get_last_created_cluster()
self.fuel_web.run_ostf(cluster_id=cluster_id)
@ -467,17 +479,17 @@ class TestHaFailoverBase(TestBasic):
self.env.revert_snapshot(self.snapshot_name)
for devops_node in self.env.d_env.nodes().slaves[3:5]:
remote = self.fuel_web.get_ssh_for_node(devops_node.name)
remote.execute("kill -9 `pgrep nova-compute`")
wait(
lambda: len(remote.execute('pgrep nova-compute')['stdout'])
== 1, timeout=120)
assert_true(len(remote.execute('pgrep nova-compute')['stdout'])
== 1, 'Nova service was not restarted')
assert_true(len(remote.execute(
"grep \"nova-compute.*trying to restart\" "
"/var/log/monit.log")['stdout']) > 0,
'Nova service was not restarted')
with self.fuel_web.get_ssh_for_node(devops_node.name) as remote:
remote.execute("kill -9 `pgrep nova-compute`")
wait(
lambda: len(remote.execute('pgrep nova-compute')['stdout'])
== 1, timeout=120)
assert_true(len(remote.execute('pgrep nova-compute')['stdout'])
== 1, 'Nova service was not restarted')
assert_true(len(remote.execute(
"grep \"nova-compute.*trying to restart\" "
"/var/log/monit.log")['stdout']) > 0,
'Nova service was not restarted')
def check_firewall_vulnerability(self):
if not self.env.d_env.has_snapshot(self.snapshot_name):
@ -494,30 +506,35 @@ class TestHaFailoverBase(TestBasic):
self.env.revert_snapshot(self.snapshot_name)
cluster_id = self.fuel_web.get_last_created_cluster()
for node in self.fuel_web.client.list_cluster_nodes(cluster_id):
remote = self.env.d_env.get_ssh_to_remote(node['ip'])
assert_true(
check_ping(remote, DNS, deadline=120, interval=10),
"No Internet access from {0}".format(node['fqdn'])
)
remote_compute = self.fuel_web.get_ssh_for_node('slave-05')
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
assert_true(
check_ping(remote, DNS, deadline=120, interval=10),
"No Internet access from {0}".format(node['fqdn'])
)
devops_node = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0])
file_name = DOWNLOAD_LINK.split('/')[-1]
file_path = '/root/tmp'
remote_compute.execute(
"screen -S download -d -m bash -c 'mkdir -p {0} &&"
" cd {0} && wget --limit-rate=100k {1}'".format(file_path,
DOWNLOAD_LINK))
try:
wait(
lambda: remote_compute.execute("ls -1 {0}/{1}".format(
file_path, file_name))['exit_code'] == 0, timeout=60)
except TimeoutError:
raise TimeoutError(
"File download was not started")
file_size1 = get_file_size(remote_compute, file_name, file_path)
time.sleep(60)
file_size2 = get_file_size(remote_compute, file_name, file_path)
with self.fuel_web.get_ssh_for_node('slave-05') as remote:
remote.execute(
"screen -S download -d -m bash -c 'mkdir -p {0} &&"
" cd {0} && wget --limit-rate=100k {1}'".format(file_path,
DOWNLOAD_LINK))
with self.fuel_web.get_ssh_for_node('slave-05') as remote:
try:
wait(
lambda: remote.execute("ls -1 {0}/{1}".format(
file_path, file_name))['exit_code'] == 0, timeout=60)
except TimeoutError:
raise TimeoutError(
"File download was not started")
with self.fuel_web.get_ssh_for_node('slave-05') as remote:
file_size1 = get_file_size(remote, file_name, file_path)
time.sleep(60)
file_size2 = get_file_size(remote, file_name, file_path)
assert_true(file_size2 > file_size1,
"File download was interrupted, size of downloading "
"does not change")
@ -529,14 +546,16 @@ class TestHaFailoverBase(TestBasic):
except TimeoutError:
raise TimeoutError(
"Primary controller was not destroyed")
assert_true(
check_ping(remote_compute, DNS, deadline=120, interval=10),
"No Internet access from {0}".format(node['fqdn'])
)
with self.fuel_web.get_ssh_for_node('slave-05') as remote:
assert_true(
check_ping(remote, DNS, deadline=120, interval=10),
"No Internet access from {0}".format(node['fqdn'])
)
if OPENSTACK_RELEASE == OPENSTACK_RELEASE_UBUNTU:
file_size1 = get_file_size(remote_compute, file_name, file_path)
time.sleep(60)
file_size2 = get_file_size(remote_compute, file_name, file_path)
with self.fuel_web.get_ssh_for_node('slave-05') as remote:
file_size1 = get_file_size(remote, file_name, file_path)
time.sleep(60)
file_size2 = get_file_size(remote, file_name, file_path)
assert_true(file_size2 > file_size1,
"File download was interrupted, size of downloading "
"does not change")
@ -566,6 +585,8 @@ class TestHaFailoverBase(TestBasic):
logger.error('command failed to be executed'.format(
self.env.d_env.nodes().slaves[:1].name))
raise
finally:
remote.clear()
cluster_id = self.fuel_web.client.get_cluster_id(
self.__class__.__name__)
@ -764,11 +785,11 @@ class TestHaFailoverBase(TestBasic):
for node in pcm_nodes]
logger.debug("rabbit nodes are {}".format(rabbit_nodes))
slave1_remote = self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name)
rabbit_slave1_name = None
slave1_name = ''.join(
slave1_remote.execute('hostname')['stdout']).strip()
with self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name) as remote:
slave1_name = ''.join(
remote.execute('hostname')['stdout']).strip()
logger.debug('slave1 name is {}'.format(slave1_name))
for rabbit_node in rabbit_nodes:
if rabbit_node in slave1_name:
@ -777,32 +798,36 @@ class TestHaFailoverBase(TestBasic):
pcm_nodes.remove(slave1_name)
slave1_remote.execute('crm configure property maintenance-mode=true')
slave1_remote.execute('service corosync stop')
with self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name) as remote:
remote.execute('crm configure property maintenance-mode=true')
remote.execute('service corosync stop')
remote = self.env.d_env.get_admin_remote()
cmd = "grep 'Ignoring alive node rabbit@{0}' /var/log/remote" \
"/{1}/rabbit-fence.log".format(rabbit_slave1_name, pcm_nodes[0])
try:
wait(
lambda: not remote.execute(cmd)['exit_code'], timeout=2 * 60)
except TimeoutError:
result = remote.execute(cmd)
assert_equal(0, result['exit_code'],
'alive rabbit node was not ignored,'
' result is {}'.format(result))
assert_equal(0, remote.execute(
"grep 'Got {0} that left cluster' /var/log/remote/{1}/"
"rabbit-fence.log".format(slave1_name,
pcm_nodes[0]))['exit_code'],
"slave {} didn't leave cluster".format(slave1_name))
assert_equal(0, remote.execute(
"grep 'Preparing to fence node rabbit@{0} from rabbit cluster'"
" /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't prepared for"
" fencing".format(rabbit_slave1_name))
with self.env.d_env.get_admin_remote() as remote:
cmd = "grep 'Ignoring alive node rabbit@{0}' /var/log/remote" \
"/{1}/rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0])
try:
wait(
lambda: not remote.execute(cmd)['exit_code'],
timeout=2 * 60)
except TimeoutError:
result = remote.execute(cmd)
assert_equal(0, result['exit_code'],
'alive rabbit node was not ignored,'
' result is {}'.format(result))
assert_equal(0, remote.execute(
"grep 'Got {0} that left cluster' /var/log/remote/{1}/"
"rabbit-fence.log".format(slave1_name,
pcm_nodes[0]))['exit_code'],
"slave {} didn't leave cluster".format(slave1_name))
assert_equal(0, remote.execute(
"grep 'Preparing to fence node rabbit@{0} from rabbit cluster'"
" /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't prepared for"
" fencing".format(rabbit_slave1_name))
rabbit_status = self.fuel_web.get_rabbit_running_nodes(
self.env.d_env.nodes().slaves[1].name)
@ -812,8 +837,10 @@ class TestHaFailoverBase(TestBasic):
"rabbit node {} is not in"
" rabbit status".format(rabbit_node))
slave1_remote.execute("service corosync start")
slave1_remote.execute("service pacemaker restart")
with self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name) as remote:
remote.execute("service corosync start")
remote.execute("service pacemaker restart")
self.fuel_web.assert_pacemaker(self.env.d_env.nodes().slaves[0].name,
self.env.d_env.nodes().slaves[:3], [])
@ -831,11 +858,10 @@ class TestHaFailoverBase(TestBasic):
for node in pcm_nodes]
logger.debug("rabbit nodes are {}".format(rabbit_nodes))
slave1_remote = self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name)
slave1_name = ''.join(
slave1_remote.execute('hostname')['stdout']).strip()
with self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name) as remote:
slave1_name = ''.join(
remote.execute('hostname')['stdout']).strip()
logger.debug('slave1 name is {}'.format(slave1_name))
for rabbit_node in rabbit_nodes:
if rabbit_node in slave1_name:
@ -844,40 +870,45 @@ class TestHaFailoverBase(TestBasic):
pcm_nodes.remove(slave1_name)
slave1_remote.execute('crm configure property maintenance-mode=true')
slave1_remote.execute('rabbitmqctl stop_app')
slave1_remote.execute('service corosync stop')
with self.fuel_web.get_ssh_for_node(
self.env.d_env.nodes().slaves[0].name) as remote:
remote.execute('crm configure property maintenance-mode=true')
remote.execute('rabbitmqctl stop_app')
remote.execute('service corosync stop')
remote = self.env.d_env.get_admin_remote()
with self.env.d_env.get_admin_remote() as remote:
cmd = "grep 'Forgetting cluster node rabbit@{0}' /var/log/remote" \
"/{1}/rabbit-fence.log".format(rabbit_slave1_name, pcm_nodes[0])
try:
wait(
lambda: not remote.execute(cmd)['exit_code'], timeout=2 * 60)
except TimeoutError:
result = remote.execute(cmd)
assert_equal(0, result['exit_code'],
'dead rabbit node was not removed,'
' result is {}'.format(result))
cmd = "grep 'Forgetting cluster node rabbit@{0}' /var/log/remote" \
"/{1}/rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0])
try:
wait(
lambda: not remote.execute(cmd)['exit_code'],
timeout=2 * 60)
except TimeoutError:
result = remote.execute(cmd)
assert_equal(0, result['exit_code'],
'dead rabbit node was not removed,'
' result is {}'.format(result))
assert_equal(0, remote.execute(
"grep 'Got {0} that left cluster' /var/log/remote/{1}/"
"rabbit-fence.log".format(slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} didn't leave cluster".format(slave1_name))
assert_equal(0, remote.execute(
"grep 'Preparing to fence node rabbit@{0} from rabbit cluster'"
" /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't prepared for"
" fencing".format(rabbit_slave1_name))
assert_equal(0, remote.execute(
"grep 'Disconnecting node rabbit@{0}' /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't disconnected".format(rabbit_slave1_name))
assert_equal(0, remote.execute(
"grep 'Got {0} that left cluster' /var/log/remote/{1}/"
"rabbit-fence.log".format(slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} didn't leave cluster".format(slave1_name))
assert_equal(0, remote.execute(
"grep 'Preparing to fence node rabbit@{0} from rabbit cluster'"
" /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't prepared for"
" fencing".format(rabbit_slave1_name))
assert_equal(0, remote.execute(
"grep 'Disconnecting node rabbit@{0}' /var/log/remote/{1}/"
"rabbit-fence.log".format(rabbit_slave1_name,
pcm_nodes[0]))['exit_code'],
"node {} wasn't disconnected"
.format(rabbit_slave1_name))
rabbit_nodes.remove(rabbit_slave1_name)
rabbit_status = self.fuel_web.get_rabbit_running_nodes(

23
fuelweb_test/tests/tests_strength/test_master_node_failover.py
View File

@ -205,11 +205,11 @@ class DeployHAOneControllerMasterNodeFail(base_test_case.TestBasic):
self.env.revert_snapshot("deploy_ha_dns_ntp")
remote = self.env.d_env.get_admin_remote()
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
remote_slave = self.env.d_env.get_ssh_to_remote(_ip)
remote.execute("dockerctl shell cobbler killall dnsmasq")
checkers.external_dns_check(remote_slave)
with self.env.d_env.get_admin_remote() as remote:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote_slave:
remote.execute("dockerctl shell cobbler killall dnsmasq")
checkers.external_dns_check(remote_slave)
@test(depends_on=[deploy_ha_dns_ntp],
groups=["external_ntp_ha"])
@ -227,9 +227,10 @@ class DeployHAOneControllerMasterNodeFail(base_test_case.TestBasic):
self.env.revert_snapshot("deploy_ha_dns_ntp")
cluster_id = self.fuel_web.get_last_created_cluster()
remote = self.env.d_env.get_admin_remote()
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
remote_slave = self.env.d_env.get_ssh_to_remote(_ip)
vrouter_vip = self.fuel_web.get_management_vrouter_vip(cluster_id)
remote.execute("pkill -9 ntpd")
checkers.external_ntp_check(remote_slave, vrouter_vip)
with self.env.d_env.get_admin_remote() as remote:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote_slave:
vrouter_vip = self.fuel_web\
.get_management_vrouter_vip(cluster_id)
remote.execute("pkill -9 ntpd")
checkers.external_ntp_check(remote_slave, vrouter_vip)

9
fuelweb_test/tests/tests_strength/test_neutron.py
View File

@ -214,6 +214,9 @@ class TestNeutronFailover(base_test_case.TestBasic):
new_remote.execute("pcs resource clear p_neutron-l3-agent {0}".
format(node_with_l3))
new_remote.clear()
remote.clear()
@test(depends_on=[deploy_ha_neutron],
groups=["neutron_l3_migration_after_reset"])
@log_snapshot_after_test
@ -284,6 +287,8 @@ class TestNeutronFailover(base_test_case.TestBasic):
self.check_instance_connectivity(remote, dhcp_namespace, instance_ip)
remote.clear()
self.fuel_web.run_ostf(
cluster_id=cluster_id,
test_sets=['ha', 'smoke', 'sanity'])
@ -356,6 +361,8 @@ class TestNeutronFailover(base_test_case.TestBasic):
self.check_instance_connectivity(remote, dhcp_namespace, instance_ip)
remote.clear()
@retry(count=3, delay=120)
def run_single_test(cluster_id):
self.fuel_web.run_single_ostf_test(
@ -436,6 +443,6 @@ class TestNeutronFailover(base_test_case.TestBasic):
.format(cmd))
res = remote.execute(cmd)
break
remote.clear()
assert_equal(0, res['exit_code'],
'Most packages were dropped, result is {0}'.format(res))

70
fuelweb_test/tests/tests_upgrade/test_upgrade.py
View File

@ -66,8 +66,8 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
cluster_id = self.fuel_web.get_last_created_cluster()
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
expected_kernel = self.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
expected_kernel = self.get_slave_kernel(remote)
self.env.admin_actions.upgrade_master_node()
@ -91,8 +91,8 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
test_sets=['ha', 'smoke', 'sanity'])
if hlp_data.OPENSTACK_RELEASE_UBUNTU in hlp_data.OPENSTACK_RELEASE:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-04')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
kernel = self.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
kernel = self.get_slave_kernel(remote)
checkers.check_kernel(kernel, expected_kernel)
create_diagnostic_snapshot(
self.env, "pass", "upgrade_ha_one_controller")
@ -134,8 +134,8 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
self.fuel_web.verify_network(cluster_id)
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['ha', 'smoke', 'sanity'])
remote_ceph = self.fuel_web.get_ssh_for_node('slave-03')
self.fuel_web.prepare_ceph_to_delete(remote_ceph)
with self.fuel_web.get_ssh_for_node('slave-03') as remote_ceph:
self.fuel_web.prepare_ceph_to_delete(remote_ceph)
nailgun_nodes = self.fuel_web.update_nodes(
cluster_id, {'slave-03': ['compute', 'ceph-osd']}, False, True)
task = self.fuel_web.deploy_cluster(cluster_id)
@ -216,8 +216,8 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
if hlp_data.OPENSTACK_RELEASE_UBUNTU in hlp_data.OPENSTACK_RELEASE:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-06')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
kernel = self.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
kernel = self.get_slave_kernel(remote)
logger.debug("ubuntu kernel version"
" on new node is {}".format(kernel))
self.fuel_web.verify_network(cluster_id)
@ -263,30 +263,30 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['ha', 'smoke', 'sanity'])
remote = self.env.d_env.get_admin_remote()
with self.env.d_env.get_admin_remote() as remote:
# Patching
update_command = 'yum update -y'
update_result = remote.execute(update_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(update_result, update_command))
assert_equal(int(update_result['exit_code']), 0,
'Packages update failed, '
'inspect logs for details')
# Patching
update_command = 'yum update -y'
update_result = remote.execute(update_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(update_result, update_command))
assert_equal(int(update_result['exit_code']), 0,
'Packages update failed, '
'inspect logs for details')
# Restart containers
destroy_command = 'dockerctl destroy all'
destroy_result = remote.execute(destroy_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(destroy_result, destroy_command))
assert_equal(int(destroy_result['exit_code']), 0,
'Destroy containers failed, '
'inspect logs for details')
# Restart containers
destroy_command = 'dockerctl destroy all'
destroy_result = remote.execute(destroy_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(destroy_result, destroy_command))
assert_equal(int(destroy_result['exit_code']), 0,
'Destroy containers failed, '
'inspect logs for details')
start_command = 'dockerctl start all'
start_result = remote.execute(start_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(start_result, start_command))
start_command = 'dockerctl start all'
start_result = remote.execute(start_command)
logger.debug('Result of "{1}" command on master node: '
'{0}'.format(start_result, start_command))
assert_equal(int(start_result['exit_code']), 0,
'Start containers failed, '
'inspect logs for details')
@ -395,8 +395,8 @@ class UpgradeFuelMaster(base_test_data.TestBasic):
assert_equal(str(cluster['net_provider']), 'neutron')
if hlp_data.OPENSTACK_RELEASE_UBUNTU in hlp_data.OPENSTACK_RELEASE:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-04')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
kernel = self.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
kernel = self.get_slave_kernel(remote)
logger.debug("ubuntu kernel version"
" on new node is {}".format(kernel))
self.fuel_web.verify_network(cluster_id=cluster_id)
@ -563,8 +563,8 @@ class RollbackFuelMaster(base_test_data.TestBasic):
cluster_id = self.fuel_web.get_last_created_cluster()
_ip = self.fuel_web.get_nailgun_node_by_name('slave-01')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
expected_kernel = UpgradeFuelMaster.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
expected_kernel = UpgradeFuelMaster.get_slave_kernel(remote)
self.env.admin_actions.upgrade_master_node(rollback=True)
@ -587,8 +587,8 @@ class RollbackFuelMaster(base_test_data.TestBasic):
self.fuel_web.deploy_cluster_wait(cluster_id)
if hlp_data.OPENSTACK_RELEASE_UBUNTU in hlp_data.OPENSTACK_RELEASE:
_ip = self.fuel_web.get_nailgun_node_by_name('slave-04')['ip']
remote = self.env.d_env.get_ssh_to_remote(_ip)
kernel = UpgradeFuelMaster.get_slave_kernel(remote)
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
kernel = UpgradeFuelMaster.get_slave_kernel(remote)
checkers.check_kernel(kernel, expected_kernel)
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['ha', 'smoke', 'sanity'])

4
fuelweb_test/tests/tests_upgrade/test_upgrade_chains.py
View File

@ -167,8 +167,8 @@ class UpgradeFuelChains(base_test_data.TestBasic):
if not self.env.revert_snapshot('upgrade_first_stage'):
raise SkipTest()
remote = self.env.d_env.get_admin_remote()
remote.execute("rm -rf /var/*upgrade*")
with self.env.d_env.get_admin_remote() as remote:
remote.execute("rm -rf /var/*upgrade*")
self.env.admin_actions.upgrade_master_node()