ceph/tasks/calamari_nosetests.py

282 lines
9.0 KiB
Python
Raw Normal View History

import contextlib
import logging
import os
import textwrap
import yaml
from teuthology import contextutil
from teuthology import misc
from teuthology import packaging
from teuthology.orchestra import run
log = logging.getLogger(__name__)
# extra stuff we need to do our job here
EXTRA_PKGS = [
'git',
]
# stuff that would be in a devmode install, but should be
# installed in the system for running nosetests against
# a production install.
EXTRA_NOSETEST_PKGS = [
'python-psutil',
'python-mock',
]
def find_client0(cluster):
''' Find remote that has client.0 role, or None '''
for rem, roles in cluster.remotes.iteritems():
if 'client.0' in roles:
return rem
return None
def pip(remote, package, venv=None, uninstall=False, force=False):
''' {un}install a package with pip, possibly in a virtualenv '''
if venv:
pip = os.path.join(venv, 'bin', 'pip')
args = ['sudo', pip]
else:
args = ['sudo', 'pip']
if uninstall:
args.extend(['uninstall', '-y'])
else:
args.append('install')
if force:
args.append('-I')
args.append(package)
remote.run(args=args)
@contextlib.contextmanager
def install_epel(remote):
''' install a disabled-by-default epel repo config file '''
remove = False
try:
if remote.os.package_type == 'deb':
yield
else:
remove = True
distromajor = remote.os.version.split('.')[0]
repofiledata = textwrap.dedent('''
[epel]
name=epel{version}
metalink=http://mirrors.fedoraproject.org/metalink?repo=epel-{version}&arch=$basearch
enabled=0
gpgcheck=0
''').format(version=distromajor)
misc.create_file(remote, '/etc/yum.repos.d/epel.repo',
data=repofiledata, sudo=True)
remote.run(args='sudo yum clean all')
yield
finally:
if remove:
misc.delete_file(remote, '/etc/yum.repos.d/epel.repo', sudo=True)
def enable_epel(remote, enable=True):
''' enable/disable the epel repo '''
args = 'sudo sed -i'.split()
if enable:
args.extend(['s/enabled=0/enabled=1/'])
else:
args.extend(['s/enabled=1/enabled=0/'])
args.extend(['/etc/yum.repos.d/epel.repo'])
remote.run(args=args)
remote.run(args='sudo yum clean all')
@contextlib.contextmanager
def install_extra_pkgs(client):
''' Install EXTRA_PKGS '''
try:
for pkg in EXTRA_PKGS:
packaging.install_package(pkg, client)
yield
finally:
for pkg in EXTRA_PKGS:
packaging.remove_package(pkg, client)
@contextlib.contextmanager
def clone_calamari(config, client):
''' clone calamari source into current directory on remote '''
branch = config.get('calamari_branch', 'master')
url = config.get('calamari_giturl', 'git://github.com/ceph/calamari')
try:
cmd = 'git clone -b {branch} {giturl}'.format(
branch=branch, giturl=url
)
client.run(args=cmd)
yield
finally:
# sudo python setup.py develop may have left some root files around
client.run(args='sudo rm -rf calamari')
@contextlib.contextmanager
def write_info_yaml(cluster, client):
''' write info.yaml to client for nosetests '''
try:
info = {
'cluster': {
rem.name: {'roles': roles}
for rem, roles in cluster.remotes.iteritems()
}
}
misc.create_file(client, 'calamari/info.yaml',
data=yaml.safe_dump(info, default_flow_style=False))
yield
finally:
misc.delete_file(client, 'calamari/info.yaml')
@contextlib.contextmanager
def write_test_conf(client):
''' write calamari/tests/test.conf to client for nosetests '''
try:
testconf = textwrap.dedent('''
[testing]
calamari_control = external
ceph_control = external
bootstrap = False
api_username = admin
api_password = admin
embedded_timeout_factor = 1
external_timeout_factor = 3
external_cluster_path = info.yaml
''')
misc.create_file(client, 'calamari/tests/test.conf', data=testconf)
yield
finally:
misc.delete_file(client, 'calamari/tests/test.conf')
@contextlib.contextmanager
def prepare_nosetest_env(client):
try:
# extra dependencies that would be in the devmode venv
if client.os.package_type == 'rpm':
enable_epel(client, enable=True)
for package in EXTRA_NOSETEST_PKGS:
packaging.install_package(package, client)
if client.os.package_type == 'rpm':
enable_epel(client, enable=False)
# install nose itself into the calamari venv, force it in case it's
# already installed in the system, so we can invoke it by path without
# fear that it's not present
pip(client, 'nose', venv='/opt/calamari/venv', force=True)
# install a later version of requests into the venv as well
# (for precise)
pip(client, 'requests', venv='/opt/calamari/venv', force=True)
# link (setup.py develop) calamari/rest-api into the production venv
# because production does not include calamari_rest.management, needed
# for test_rest_api.py's ApiIntrospection
args = 'cd calamari/rest-api'.split() + [run.Raw(';')] + \
'sudo /opt/calamari/venv/bin/python setup.py develop'.split()
client.run(args=args)
# because, at least in Python 2.6/Centos, site.py uses
# 'os.path.exists()' to process .pth file entries, and exists() uses
# access(2) to check for existence, all the paths leading up to
# $HOME/calamari/rest-api need to be searchable by all users of
# the package, which will include the WSGI/Django app, running
# as the Apache user. So make them all world-read-and-execute.
args = 'sudo chmod a+x'.split() + \
['.', './calamari', './calamari/rest-api']
client.run(args=args)
# make one dummy request just to get the WSGI app to do
# all its log creation here, before the chmod below (I'm
# looking at you, graphite -- /var/log/calamari/info.log and
# /var/log/calamari/exception.log)
client.run(args='wget -q -O /dev/null http://localhost')
# /var/log/calamari/* is root-or-apache write-only
client.run(args='sudo chmod a+w /var/log/calamari/*')
yield
finally:
args = 'cd calamari/rest-api'.split() + [run.Raw(';')] + \
'sudo /opt/calamari/venv/bin/python setup.py develop -u'.split()
client.run(args=args)
for pkg in ('nose', 'requests'):
pip(client, pkg, venv='/opt/calamari/venv', uninstall=True)
for package in EXTRA_NOSETEST_PKGS:
packaging.remove_package(package, client)
@contextlib.contextmanager
def run_nosetests(client):
''' Actually run the tests '''
args = [
'cd',
'calamari',
run.Raw(';'),
'CALAMARI_CONFIG=/etc/calamari/calamari.conf',
'/opt/calamari/venv/bin/nosetests',
'-v',
'tests/',
]
client.run(args=args)
yield
@contextlib.contextmanager
def task(ctx, config):
"""
Run Calamari tests against an instance set up by 'calamari_server'.
-- clone the Calamari source into $HOME (see options)
-- write calamari/info.yaml describing the cluster
-- write calamari/tests/test.conf containing
'external' for calamari_control and ceph_control
'bootstrap = False' to disable test bootstrapping (installing minions)
no api_url necessary (inferred from client.0)
'external_cluster_path = info.yaml'
-- modify the production Calamari install to allow test runs:
install nose in the venv
install EXTRA_NOSETEST_PKGS
link in, with setup.py develop, calamari_rest (for ApiIntrospection)
-- set CALAMARI_CONFIG to point to /etc/calamari/calamari.conf
-- nosetests -v tests/
Options are:
calamari_giturl: url from which to git clone calamari
(default: git://github.com/ceph/calamari)
calamari_branch: git branch of calamari to check out
(default: master)
Note: the tests must find a clean cluster, so don't forget to
set the crush default type appropriately, or install min_size OSD hosts
"""
client0 = find_client0(ctx.cluster)
if client0 is None:
raise RuntimeError("must have client.0 role")
with contextutil.nested(
lambda: install_epel(client0),
lambda: install_extra_pkgs(client0),
lambda: clone_calamari(config, client0),
lambda: write_info_yaml(ctx.cluster, client0),
lambda: write_test_conf(client0),
lambda: prepare_nosetest_env(client0),
lambda: run_nosetests(client0),
):
yield