def set_temp_url_secret():
"""Run the set-temp-url-secret on the ironic-conductor leader.
This is needed if direct boot method is enabled.
"""
zaza_model.run_action_on_leader('ironic-conductor',
'set-temp-url-secret',
action_params={})
def basic_setup():
"""Run setup for testing Trilio.
Setup for testing Trilio is currently part of functional
tests.
"""
logging.info("Configuring NFS Server")
nfs_server_ip = zaza_model.get_app_ips("nfs-server-test-fixture")[0]
trilio_wlm_unit = zaza_model.get_first_unit_name("trilio-wlm")
nfs_shares_conf = {"nfs-shares": "{}:/srv/testing".format(nfs_server_ip)}
_trilio_services = ["trilio-wlm", "trilio-data-mover"]
conf_changed = False
for juju_service in _trilio_services:
app_config = zaza_model.get_application_config(juju_service)
if app_config["nfs-shares"] != nfs_shares_conf["nfs-shares"]:
zaza_model.set_application_config(juju_service, nfs_shares_conf)
conf_changed = True
if conf_changed:
zaza_model.wait_for_agent_status()
# NOTE(jamespage): wlm-api service must be running in order
# to execute the setup actions
zaza_model.block_until_service_status(
unit_name=trilio_wlm_unit,
services=["wlm-api"],
target_status="active",
)
logging.info("Executing create-cloud-admin-trust")
password = juju_utils.leader_get("keystone", "admin_passwd")
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader(
"trilio-wlm",
"create-cloud-admin-trust",
raise_on_failure=True,
action_params={"password": password},
)
)
logging.info("Executing create-license")
test_license = os.environ.get("TEST_TRILIO_LICENSE")
if test_license and os.path.exists(test_license):
zaza_model.attach_resource("trilio-wlm",
resource_name='license',
resource_path=test_license)
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader(
"trilio-wlm", "create-license",
raise_on_failure=True
)
)
else:
logging.error("Unable to find Trilio License file")
def test_run_action_on_leader(self):
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
model.run_action_on_leader('modelname', 'app', 'backup',
{'backup_dir': '/dev/null'})
self.assertFalse(self.unit1.called)
self.unit2.run_action.assert_called_once_with(
'backup',
backup_dir='/dev/null')
def test_multisite_failover(self):
"""Verify object storage failover/failback.
Verify that the slave radosgw can be promoted to master status
"""
if not self.multisite:
raise unittest.SkipTest('Skipping multisite failover test')
logging.info('Checking multisite failover/failback')
keystone_session = zaza_openstack.get_overcloud_keystone_session()
source_client = zaza_openstack.get_swift_session_client(
keystone_session,
region_name='east-1',
cacert=self.cacert,
)
target_client = zaza_openstack.get_swift_session_client(
keystone_session,
region_name='west-1',
cacert=self.cacert,
)
zaza_model.run_action_on_leader(
'slave-ceph-radosgw',
'promote',
action_params={},
)
self.wait_for_sync('ceph-radosgw')
_container = 'demo-container-for-failover'
_test_data = 'Test data from Zaza on Slave'
target_client.put_container(_container)
target_client.put_object(_container,
'testfile',
contents=_test_data,
content_type='text/plain')
_, target_content = target_client.get_object(_container, 'testfile')
zaza_model.run_action_on_leader(
'ceph-radosgw',
'promote',
action_params={},
)
self.wait_for_sync('slave-ceph-radosgw')
@tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60),
reraise=True,
stop=tenacity.stop_after_attempt(12))
def _source_get_object():
return source_client.get_object(_container, 'testfile')
_, source_content = _source_get_object()
self.assertEqual(target_content.decode('UTF-8'),
source_content.decode('UTF-8'))
def test_200_run_series_upgrade(self):
"""Run series upgrade."""
# Set Feature Flag
os.environ["JUJU_DEV_FEATURE_FLAGS"] = "upgrade-series"
applications = model.get_status().applications
completed_machines = []
for application, app_details in applications.items():
# Skip subordinates
if app_details["subordinate-to"]:
continue
if "easyrsa" in app_details["charm"]:
logging.warn(
"Skipping series upgrade of easyrsa Bug #1850121")
continue
if "etcd" in app_details["charm"]:
logging.warn(
"Skipping series upgrade of etcd Bug #1850124")
continue
charm_name = upgrade_utils.extract_charm_name_from_url(
app_details['charm'])
upgrade_config = series_upgrade_utils.app_config(
charm_name,
is_async=False)
upgrade_function = upgrade_config.pop('upgrade_function')
logging.warn("About to upgrade {}".format(application))
upgrade_function(
application,
**upgrade_config,
from_series=self.from_series,
to_series=self.to_series,
completed_machines=completed_machines,
workaround_script=self.workaround_script,
files=self.files,
)
if "rabbitmq-server" in app_details["charm"]:
logging.info(
"Running complete-cluster-series-upgrade action on leader")
model.run_action_on_leader(
application,
'complete-cluster-series-upgrade',
action_params={})
model.block_until_all_units_idle()
if "percona-cluster" in app_details["charm"]:
logging.info(
"Running complete-cluster-series-upgrade action on leader")
model.run_action_on_leader(
application,
'complete-cluster-series-upgrade',
action_params={})
model.block_until_all_units_idle()
def test_200_run_series_upgrade(self):
"""Run series upgrade."""
# Set Feature Flag
os.environ["JUJU_DEV_FEATURE_FLAGS"] = "upgrade-series"
upgrade_groups = upgrade_utils.get_series_upgrade_groups(
extra_filters=[
upgrade_utils._filter_etcd, upgrade_utils._filter_easyrsa
],
target_series=self.to_series)
applications = model.get_status().applications
completed_machines = []
for group_name, group in upgrade_groups:
logging.warn("About to upgrade {} ({})".format(group_name, group))
upgrade_group = []
for application, app_details in applications.items():
if application not in group:
continue
charm_name = upgrade_utils.extract_charm_name_from_url(
app_details['charm'])
upgrade_config = series_upgrade_utils.app_config(charm_name)
upgrade_function = upgrade_config.pop('upgrade_function')
logging.warn("About to upgrade {}".format(application))
upgrade_group.append(
upgrade_function(
application,
**upgrade_config,
from_series=self.from_series,
to_series=self.to_series,
completed_machines=completed_machines,
workaround_script=self.workaround_script,
files=self.files,
))
asyncio.get_event_loop().run_until_complete(
asyncio.gather(*upgrade_group))
if "rabbitmq-server" in group:
logging.info(
"Running complete-cluster-series-upgrade action on leader")
model.run_action_on_leader('rabbitmq-server',
'complete-cluster-series-upgrade',
action_params={})
model.block_until_all_units_idle()
if "percona-cluster" in group:
logging.info(
"Running complete-cluster-series-upgrade action on leader")
model.run_action_on_leader('mysql',
'complete-cluster-series-upgrade',
action_params={})
model.block_until_all_units_idle()
def test_security_checklist(self):
"""Verify expected state with security checklist."""
logging.info("Testing security checklist.")
expected_failures = [
'csrf_cookie_set',
'disable_password_reveal',
'disallow-iframe-embed',
'password-validator-is-not-default',
'securie_proxy_ssl_header_is_set',
'session_cookie-httponly',
'session-cookie-store',
]
expected_passes = [
'disable_password_autocomplete', 'enforce-password-check',
'validate-file-ownership', 'validate-file-permissions'
]
logging.info('Running `security-checklist` action'
' on {} leader'.format(self.application_name))
test_utils.audit_assertions(zaza_model.run_action_on_leader(
self.application_name,
'security-checklist',
model_name=self.model_name,
action_params={}),
expected_passes,
expected_failures,
expected_to_pass=False)
def sync_images():
"""Run image sync using an action.
Execute an initial image sync using an action to ensure that the
cloud is populated with images at the right point in time during
deployment.
"""
logging.info("Synchronising images using glance-simplestreams-sync")
catalog = None
try:
for attempt in tenacity.Retrying(stop=tenacity.stop_after_attempt(3),
wait=tenacity.wait_exponential(
multiplier=1, min=2, max=10),
reraise=True):
with attempt:
# Proactively retrieve the Keystone service catalog so that we
# can log it in the event of a failure.
catalog = _get_catalog()
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader(
"glance-simplestreams-sync",
"sync-images",
raise_on_failure=True,
action_params={},
))
except Exception:
logging.info('Contents of Keystone service catalog: "{}"'.format(
pprint.pformat(catalog)))
raise
def trust_setup():
"""Run setup Trilio trust setup."""
logging.info("Executing create-cloud-admin-trust")
password = juju_utils.leader_get("keystone", "admin_passwd")
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader(
"trilio-wlm",
"create-cloud-admin-trust",
raise_on_failure=True,
action_params={"password": password},
))
def test_ceph_auth(self):
"""Test creating and deleting user."""
logging.info('Creating user and exported keyring...')
action_obj = zaza_model.run_action_on_leader('ceph-mon',
'get-or-create-user',
action_params={
'username': '******',
'mon-caps': 'allow r',
'osd-caps': 'allow r'
})
logging.debug('Result of action: {}'.format(action_obj))
create_results = json.loads(action_obj.data['results']['message'])
logging.info('Getting existing user and exported keyring...')
action_obj = zaza_model.run_action_on_leader(
'ceph-mon',
'get-or-create-user',
action_params={'username': '******'})
logging.debug('Result of action: {}'.format(action_obj))
get_results = json.loads(action_obj.data['results']['message'])
self.assertEqual(get_results, create_results)
logging.info('Deleting existing user...')
action_obj = zaza_model.run_action_on_leader(
'ceph-mon', 'delete-user', action_params={'username': '******'})
logging.debug('Result of action: {}'.format(action_obj))
delete_results = action_obj.data['results']['message']
self.assertEqual(delete_results, "updated\n")
logging.info('Deleting non-existing user...')
action_obj = zaza_model.run_action_on_leader(
'ceph-mon', 'delete-user', action_params={'username': '******'})
logging.debug('Result of action: {}'.format(action_obj))
delete_results = action_obj.data['results']['message']
self.assertEqual(delete_results,
"entity client.sandbox does not exist\n")
def sync_images():
"""Run image sync using an action.
Execute an initial image sync using an action to ensure that the
cloud is populated with images at the right point in time during
deployment.
"""
logging.info("Synchronising images using glance-simplestreams-sync")
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader(
"glance-simplestreams-sync",
"sync-images",
raise_on_failure=True,
action_params={},
))
def license_setup():
"""Run setup Trilio license setup."""
logging.info("Executing create-license")
test_license = os.environ.get("TEST_TRILIO_LICENSE")
if test_license and os.path.exists(test_license):
zaza_model.attach_resource("trilio-wlm",
resource_name='license',
resource_path=test_license)
generic_utils.assertActionRanOK(
zaza_model.run_action_on_leader("trilio-wlm",
"create-license",
raise_on_failure=True))
else:
logging.error("Unable to find Trilio License file")
def test_osd_security_checklist(self):
"""Verify expected state with security-checklist."""
expected_failures = []
expected_passes = [
'validate-file-ownership',
'validate-file-permissions',
]
logging.info('Running `security-checklist` action'
' on Ceph OSD leader unit')
test_utils.audit_assertions(zaza_model.run_action_on_leader(
'ceph-osd', 'security-checklist', action_params={}),
expected_passes,
expected_failures,
expected_to_pass=True)
def main(argv):
# Tempest expects an admin project in the admin domain that the admin user
# has admin role on so make sure that exists (pre-17.02)
keystone_v3_domain_setup()
results_file = mojo_utils.get_mojo_file('tempest_expected_results.yaml')
expected_results = generic_utils.get_yaml_config(results_file)['smoke']
action = model.run_action_on_leader('tempest',
'run-tempest',
action_params={})
logging.debug(action.message)
actual_results = action.data['results']
result_matrix = {
'failed': {
'on_more': raise_tempest_fail,
'on_less': report_success
},
'skipped': {
'on_more': warn,
'on_less': report_success
},
'expected-fail': {
'on_more': raise_tempest_fail,
'on_less': report_success
},
'unexpected-success': {
'on_more': report_success,
'on_less': warn
},
'passed': {
'on_more': report_success,
'on_less': raise_tempest_fail
}
}
for result_type, expected in expected_results.items():
actual = actual_results[result_type]
msg = "Number of tests {} was {} expected {}".format(
result_type, actual, expected)
if int(actual) > expected:
result_matrix[result_type]['on_more'](msg)
elif int(actual) == expected:
report_success(msg)
else:
result_matrix[result_type]['on_less'](msg)
def basic_setup():
"""Run setup for testing Ceilometer.
Setup for testing Ceilometer is currently part of functional
tests.
"""
current_release = openstack_utils.get_os_release()
xenial_pike = openstack_utils.get_os_release('xenial_pike')
if current_release < xenial_pike:
logging.info(
'Skipping ceilometer-upgrade as it is not supported before Pike')
return
logging.debug('Checking ceilometer-upgrade')
action = zaza_model.run_action_on_leader('ceilometer',
'ceilometer-upgrade',
raise_on_failure=True)
return action
def test_200_run_series_upgrade(self):
"""Run series upgrade."""
# Set Feature Flag
os.environ["JUJU_DEV_FEATURE_FLAGS"] = "upgrade-series"
applications = model.get_status().applications
completed_machines = []
for application in applications:
# Defaults
origin = "openstack-origin"
pause_non_leader_subordinate = True
pause_non_leader_primary = True
post_upgrade_functions = []
# Skip subordinates
if applications[application]["subordinate-to"]:
continue
if "percona-cluster" in applications[application]["charm"]:
origin = "source"
pause_non_leader_primary = True
pause_non_leader_subordinate = True
if "rabbitmq-server" in applications[application]["charm"]:
origin = "source"
pause_non_leader_primary = True
pause_non_leader_subordinate = False
if "nova-compute" in applications[application]["charm"]:
pause_non_leader_primary = False
pause_non_leader_subordinate = False
if "ceph" in applications[application]["charm"]:
origin = "source"
pause_non_leader_primary = False
pause_non_leader_subordinate = False
if "designate-bind" in applications[application]["charm"]:
origin = None
if "tempest" in applications[application]["charm"]:
origin = None
if "memcached" in applications[application]["charm"]:
origin = None
pause_non_leader_primary = False
pause_non_leader_subordinate = False
if "vault" in applications[application]["charm"]:
post_upgrade_functions = [
('zaza.openstack.charm_tests.vault.setup.'
'basic_setup_and_unseal')]
if ("mongodb" in applications[application]["charm"] or
"vault" in applications[application]["charm"]):
# Mongodb and vault need to run series upgrade
# on its secondaries first.
generic_utils.series_upgrade_non_leaders_first(
application,
from_series=self.from_series,
to_series=self.to_series,
completed_machines=completed_machines,
post_upgrade_functions=post_upgrade_functions)
continue
# The rest are likley APIs use defaults
generic_utils.series_upgrade_application(
application,
pause_non_leader_primary=pause_non_leader_primary,
pause_non_leader_subordinate=pause_non_leader_subordinate,
from_series=self.from_series,
to_series=self.to_series,
origin=origin,
completed_machines=completed_machines,
workaround_script=self.workaround_script,
files=self.files,
post_upgrade_functions=post_upgrade_functions)
if "rabbitmq-server" in applications[application]["charm"]:
logging.info(
"Running complete-cluster-series-upgrade action on leader")
model.run_action_on_leader(
'rabbitmq-server',
'complete-cluster-series-upgrade',
action_params={})
model.block_until_all_units_idle()
