396 lines
14 KiB
Python
396 lines
14 KiB
Python
import re
|
|
import os
|
|
import subprocess
|
|
import time
|
|
|
|
import glanceclient
|
|
import keystoneclient.v2_0 as keystoneclient
|
|
import neutronclient.v2_0.client as neutronclient
|
|
import novaclient.v2 as novaclient
|
|
import urllib
|
|
|
|
import charms_openstack.charm as charm
|
|
import charms_openstack.adapters as adapters
|
|
import charmhelpers.core.hookenv as hookenv
|
|
import charmhelpers.fetch as fetch
|
|
|
|
|
|
def install():
|
|
"""Use the singleton from the TempestCharm to install the packages on the
|
|
unit
|
|
"""
|
|
TempestCharm.singleton.install()
|
|
|
|
|
|
def render_configs(interfaces_list):
|
|
"""Using a list of interfaces, render the configs and, if they have
|
|
changes, restart the services on the unit.
|
|
"""
|
|
if not os.path.isdir(TempestCharm.TEMPEST_LOGDIR):
|
|
os.makedirs(TempestCharm.TEMPEST_LOGDIR)
|
|
TempestCharm.singleton.render_with_interfaces(interfaces_list)
|
|
TempestCharm.singleton.assess_status()
|
|
|
|
|
|
def run_test(tox_target):
|
|
"""Use the singleton from the TempestCharm to install the packages on the
|
|
unit
|
|
"""
|
|
TempestCharm.singleton.run_test(tox_target)
|
|
|
|
|
|
def assess_status():
|
|
"""Use the singleton from the TempestCharm to install the packages on the
|
|
unit
|
|
"""
|
|
TempestCharm.singleton.assess_status()
|
|
|
|
|
|
class TempestAdminAdapter(adapters.OpenStackRelationAdapter):
|
|
|
|
"""Inspect relations and provide properties that can be used when
|
|
rendering templates"""
|
|
|
|
interface_type = "identity-admin"
|
|
|
|
def __init__(self, relation):
|
|
"""Initialise a keystone client and collect user defined config"""
|
|
self.kc = None
|
|
super(TempestAdminAdapter, self).__init__(relation)
|
|
self.init_keystone_client()
|
|
self.uconfig = hookenv.config()
|
|
|
|
@property
|
|
def keystone_info(self):
|
|
"""Collection keystone information from keystone relation"""
|
|
return self.relation.credentials()
|
|
|
|
@property
|
|
def ks_client(self):
|
|
if not self.kc:
|
|
self.init_keystone_client()
|
|
return self.kc
|
|
|
|
@property
|
|
def keystone_auth_url(self):
|
|
return '{}://{}:{}/v2.0'.format(
|
|
'http',
|
|
self.keystone_info['service_hostname'],
|
|
self.keystone_info['service_port']
|
|
)
|
|
|
|
def init_keystone_client(self):
|
|
"""Initialise keystone client"""
|
|
if self.kc:
|
|
return
|
|
auth = {
|
|
'username': self.keystone_info['service_username'],
|
|
'password': self.keystone_info['service_password'],
|
|
'auth_url': self.keystone_auth_url,
|
|
'tenant_name': self.keystone_info['service_tenant_name'],
|
|
'region_name': self.keystone_info['service_region'],
|
|
}
|
|
try:
|
|
self.kc = keystoneclient.client.Client(**auth)
|
|
except:
|
|
hookenv.log("Keystone is not ready, deferring keystone query")
|
|
|
|
@property
|
|
def ec2_creds(self):
|
|
"""Generate EC2 style tokens or return existing EC2 tokens
|
|
|
|
@returns {'access_token' token1, 'secret_token': token2}
|
|
"""
|
|
if not self.ks_client:
|
|
return {}
|
|
current_creds = self.ks_client.ec2.list(self.ks_client.user_id)
|
|
if current_creds:
|
|
creds = current_creds[0]
|
|
else:
|
|
creds = self.ks_client.ec2.create(
|
|
self.ks_client.user_id,
|
|
self.ks_client.tenant_id)
|
|
return {'access_token': creds.access, 'secret_token': creds.secret}
|
|
|
|
@property
|
|
def image_info(self):
|
|
"""Return image ids for the user-defined image names
|
|
|
|
@returns {'image_id' id1, 'image_alt_id': id2}
|
|
"""
|
|
image_info = {}
|
|
try:
|
|
glance_endpoint = self.ks_client.service_catalog.url_for(
|
|
service_type='image',
|
|
endpoint_type='publicURL')
|
|
glance_client = glanceclient.Client(
|
|
'2', glance_endpoint, token=self.ks_client.auth_token)
|
|
for image in glance_client.images.list():
|
|
if self.uconfig.get('glance-image-name') == image.name:
|
|
image_info['image_id'] = image.id
|
|
if self.uconfig.get('image-ssh-user'):
|
|
image_info['image_ssh_user'] = \
|
|
self.uconfig.get('image-ssh-user')
|
|
if self.uconfig.get('glance-alt-image-name') == image.name:
|
|
image_info['image_alt_id'] = image.id
|
|
if self.uconfig.get('image-alt-ssh-user'):
|
|
image_info['image_alt_ssh_user'] = \
|
|
self.uconfig.get('image-alt-ssh-user')
|
|
except:
|
|
hookenv.log("Glance is not ready, deferring glance query")
|
|
return image_info
|
|
|
|
@property
|
|
def network_info(self):
|
|
"""Return public network and router ids for user-defined router and
|
|
network names
|
|
|
|
@returns {'public_network_id' id1, 'router_id': id2}
|
|
"""
|
|
network_info = {}
|
|
try:
|
|
neutron_ep = self.ks_client.service_catalog.url_for(
|
|
service_type='network',
|
|
endpoint_type='publicURL')
|
|
neutron_client = neutronclient.Client(
|
|
endpoint_url=neutron_ep,
|
|
token=self.ks_client.auth_token)
|
|
routers = neutron_client.list_routers(
|
|
name=self.uconfig['router-name'])
|
|
if len(routers['routers']) == 0:
|
|
hookenv.log("Router not found")
|
|
else:
|
|
router = routers['routers'][0]
|
|
network_info['router_id'] = router['id']
|
|
networks = neutron_client.list_networks(
|
|
name=self.uconfig['network-name'])
|
|
if len(networks['networks']) == 0:
|
|
hookenv.log("network not found")
|
|
else:
|
|
network = networks['networks'][0]
|
|
network_info['public_network_id'] = network['id']
|
|
networks = neutron_client.list_networks(
|
|
name=self.uconfig['floating-network-name'])
|
|
if len(networks['networks']) == 0:
|
|
hookenv.log("Floating network name not found")
|
|
else:
|
|
network_info['floating-network-name'] = \
|
|
self.uconfig['floating-network-name']
|
|
except:
|
|
hookenv.log("Neutron is not ready, deferring neutron query")
|
|
return network_info
|
|
|
|
@property
|
|
def compute_info(self):
|
|
"""Return flavor ids for user-defined flavors
|
|
|
|
@returns {'flavor_id' id1, 'flavor_alt_id': id2}
|
|
"""
|
|
compute_info = {}
|
|
try:
|
|
nova_ep = self.ks_client.service_catalog.url_for(
|
|
service_type='compute',
|
|
endpoint_type='publicURL'
|
|
)
|
|
compute_info['nova_endpoint'] = nova_ep
|
|
url = urllib.parse.urlparse(nova_ep)
|
|
compute_info['nova_base'] = '{}://{}'.format(
|
|
url.scheme,
|
|
url.netloc.split(':')[0])
|
|
nova_client = novaclient.client.Client(
|
|
self.keystone_info['service_username'],
|
|
self.keystone_info['service_password'],
|
|
self.keystone_info['service_tenant_name'],
|
|
self.keystone_auth_url,
|
|
)
|
|
for flavor in nova_client.flavors.list():
|
|
if self.uconfig['flavor-name'] == flavor.name:
|
|
compute_info['flavor_id'] = flavor.id
|
|
if self.uconfig['flavor-alt-name'] == flavor.name:
|
|
compute_info['flavor_alt_id'] = flavor.id
|
|
except:
|
|
hookenv.log("Nova is not ready, deferring nova query")
|
|
return compute_info
|
|
|
|
def get_present_services(self):
|
|
"""Query keystone catalogue for a list for registered services
|
|
|
|
@returns [svc1, svc2, ...]: List of registered services
|
|
"""
|
|
services = [svc.name
|
|
for svc in self.ks_client.services.list()
|
|
if svc.enabled]
|
|
return services
|
|
|
|
@property
|
|
def service_info(self):
|
|
"""Assemble a list of services tempest should tests
|
|
|
|
Compare the list of keystone registered services with the services the
|
|
user has requested be tested. If in 'auto' mode test all services
|
|
registered in keystone.
|
|
|
|
@returns [svc1, svc2, ...]: List of services to test
|
|
"""
|
|
service_info = {}
|
|
tempest_candidates = ['ceilometer', 'cinder', 'glance', 'heat',
|
|
'horizon', 'ironic', 'neutron', 'nova',
|
|
'sahara', 'swift', 'trove', 'zaqar', 'neutron']
|
|
present_svcs = self.get_present_services()
|
|
# If not running in an action context asssume auto mode
|
|
try:
|
|
action_args = hookenv.action_get()
|
|
except:
|
|
action_args = {'service-whitelist': 'auto'}
|
|
if action_args['service-whitelist'] == 'auto':
|
|
white_list = []
|
|
for svc in present_svcs:
|
|
if svc in tempest_candidates:
|
|
white_list.append(svc)
|
|
else:
|
|
white_list = action_args['service-whitelist']
|
|
for svc in tempest_candidates:
|
|
if svc in white_list:
|
|
service_info[svc] = 'true'
|
|
else:
|
|
service_info[svc] = 'false'
|
|
return service_info
|
|
|
|
|
|
class TempestAdapters(adapters.OpenStackRelationAdapters):
|
|
"""
|
|
Adapters class for the Tempest charm.
|
|
"""
|
|
relation_adapters = {
|
|
'identity_admin': TempestAdminAdapter,
|
|
}
|
|
|
|
def __init__(self, relations):
|
|
super(TempestAdapters, self).__init__(
|
|
relations,
|
|
options=TempestConfigurationAdapter)
|
|
|
|
|
|
class TempestConfigurationAdapter(adapters.ConfigurationAdapter):
|
|
"""
|
|
Manipulate user supplied config as needed
|
|
"""
|
|
def __init__(self):
|
|
super(TempestConfigurationAdapter, self).__init__()
|
|
|
|
|
|
class TempestCharm(charm.OpenStackCharm):
|
|
|
|
release = 'liberty'
|
|
name = 'tempest'
|
|
|
|
required_relations = ['identity-admin']
|
|
"""Directories and files used for running tempest"""
|
|
TEMPEST_ROOT = '/var/lib/tempest'
|
|
TEMPEST_LOGDIR = TEMPEST_ROOT + '/logs'
|
|
TEMPEST_CONF = TEMPEST_ROOT + '/tempest.conf'
|
|
"""pip.conf for proxy settings etc"""
|
|
PIP_CONF = '/root/.pip/pip.conf'
|
|
|
|
"""List of packages charm should install
|
|
XXX The install hook is currently installing most packages ahead of
|
|
this because modules like keystoneclient are needed at load time
|
|
"""
|
|
packages = [
|
|
'git', 'testrepository', 'subunit', 'python-nose', 'python-lxml',
|
|
'python-boto', 'python-junitxml', 'python-subunit',
|
|
'python-testresources', 'python-oslotest', 'python-stevedore',
|
|
'python-cinderclient', 'python-glanceclient', 'python-heatclient',
|
|
'python-keystoneclient', 'python-neutronclient', 'python-novaclient',
|
|
'python-swiftclient', 'python-ceilometerclient', 'openvswitch-test',
|
|
'python3-cinderclient', 'python3-glanceclient', 'python3-heatclient',
|
|
'python3-keystoneclient', 'python3-neutronclient',
|
|
'python3-novaclient', 'python3-swiftclient',
|
|
'python3-ceilometerclient', 'openvswitch-common', 'libffi-dev',
|
|
'libssl-dev', 'python-dev', 'python-cffi'
|
|
]
|
|
|
|
"""Use the Tempest specific adapters"""
|
|
adapters_class = TempestAdapters
|
|
"""Tempest has no running services so no services need restarting on
|
|
config file change
|
|
"""
|
|
restart_map = {
|
|
TEMPEST_CONF: [],
|
|
PIP_CONF: [],
|
|
}
|
|
|
|
def setup_directories(self):
|
|
for tempest_dir in [self.TEMPEST_ROOT, self.TEMPEST_LOGDIR]:
|
|
if not os.path.exists(tempest_dir):
|
|
os.mkdir(tempest_dir)
|
|
|
|
def setup_git(self, branch, git_dir):
|
|
"""Clone tempest and symlink in rendered tempest.conf"""
|
|
conf = hookenv.config()
|
|
if not os.path.exists(git_dir):
|
|
git_url = conf['tempest-source']
|
|
fetch.install_remote(str(git_url), dest=str(git_dir),
|
|
branch=str(branch), depth=str(1))
|
|
conf_symlink = git_dir + '/tempest/etc/tempest.conf'
|
|
if not os.path.exists(conf_symlink):
|
|
os.symlink(self.TEMPEST_CONF, conf_symlink)
|
|
|
|
def execute_tox(self, run_dir, logfile, tox_target):
|
|
"""Trigger tempest run through tox setting proxies if needed"""
|
|
env = os.environ.copy()
|
|
conf = hookenv.config()
|
|
if conf.get('http-proxy'):
|
|
env['http_proxy'] = conf['http-proxy']
|
|
if conf.get('https-proxy'):
|
|
env['https_proxy'] = conf['https-proxy']
|
|
cmd = ['tox', '-e', tox_target]
|
|
f = open(logfile, "w")
|
|
subprocess.call(cmd, cwd=run_dir, stdout=f, stderr=f, env=env)
|
|
|
|
def get_tempest_files(self, branch_name):
|
|
"""Prepare tempest files and directories
|
|
|
|
@return git_dir, logfile, run_dir
|
|
"""
|
|
log_time_str = time.strftime("%Y%m%d%H%M%S", time.gmtime())
|
|
git_dir = '{}/tempest-{}'.format(self.TEMPEST_ROOT, branch_name)
|
|
logfile = '{}/run_{}.log'.format(self.TEMPEST_LOGDIR, log_time_str)
|
|
run_dir = '{}/tempest'.format(git_dir)
|
|
return git_dir, logfile, run_dir
|
|
|
|
def parse_tempest_log(self, logfile):
|
|
"""Read tempest logfile and return summary as dict
|
|
|
|
@return dict: Dictonary of summary data
|
|
"""
|
|
summary = {}
|
|
with open(logfile, 'r') as tempest_log:
|
|
summary_line = False
|
|
for line in tempest_log:
|
|
if line.strip() == "Totals":
|
|
summary_line = True
|
|
if line.strip() == "Worker Balance":
|
|
summary_line = False
|
|
if summary_line:
|
|
# Match lines like: ' - Unexpected Success: 0'
|
|
matchObj = re.match(
|
|
r'(.*)- (.*?):\s+(.*)', line, re.M | re.I)
|
|
if matchObj:
|
|
key = matchObj.group(2)
|
|
key = key.replace(' ', '-').replace(':', '').lower()
|
|
summary[key] = matchObj.group(3)
|
|
return summary
|
|
|
|
def run_test(self, tox_target):
|
|
"""Run smoke tests"""
|
|
action_args = hookenv.action_get()
|
|
branch_name = action_args['branch']
|
|
git_dir, logfile, run_dir = self.get_tempest_files(branch_name)
|
|
self.setup_directories()
|
|
self.setup_git(branch_name, git_dir)
|
|
self.execute_tox(run_dir, logfile, tox_target)
|
|
action_info = self.parse_tempest_log(logfile)
|
|
action_info['tempest-logfile'] = logfile
|
|
hookenv.action_set(action_info)
|