def setUpClass(cls):
"""Run setup for Series Upgrades."""
cli_utils.setup_logging()
cls.from_series = None
cls.to_series = None
cls.workaround_script = None
cls.files = []
def main():
"""Add a new model."""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
logging.info('model_name: {}'.format(args.model_name))
prepare(args.model_name, test_directory=args.test_directory)
run_report.output_event_report()
def main(argv):
cli_utils.setup_logging()
overcloud_novarc = openstack_utils.get_overcloud_auth()
user_file = mojo_utils.get_mojo_file('keystone_users.yaml')
user_config = generic_utils.get_yaml_config(user_file)
try:
cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem')
os.stat(cacert)
except FileNotFoundError:
cacert = None
keystone_session = openstack_utils.get_overcloud_keystone_session(
verify=cacert)
keystone_client = openstack_utils.get_keystone_session_client(
keystone_session)
if overcloud_novarc.get('API_VERSION', 2) == 2:
projects = [user['project'] for user in user_config]
mojo_os_utils.project_create(keystone_client, projects)
mojo_os_utils.user_create_v2(keystone_client, user_config)
# TODO validate this works without adding roles
# mojo_os_utils.add_users_to_roles(keystone_client, user_config)
else:
for user in user_config:
mojo_os_utils.domain_create(keystone_client, [user['domain']])
mojo_os_utils.project_create(keystone_client, [user['project']],
user['domain'])
mojo_os_utils.user_create_v3(keystone_client, user_config)
def main():
"""Execute full test run."""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
if args.dev and args.smoke:
raise ValueError('Ambiguous arguments: --smoke and '
'--dev cannot be used together')
if args.dev and args.bundle:
raise ValueError('Ambiguous arguments: --bundle and '
'--dev cannot be used together')
if args.smoke and args.bundle:
raise ValueError('Ambiguous arguments: --bundle and '
'--smoke cannot be used together')
func_test_runner(
keep_model=args.keep_model,
smoke=args.smoke,
dev=args.dev,
bundle=args.bundle)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument('-d',
'--domain_name',
help='DNS Domain Name. '
'Must end in a .',
default='mojo.serverstack.')
options = parser.parse_args()
domain_name = cli_utils.parse_arg(options, 'domain_name')
os_version = openstack_utils.get_current_os_versions(
'keystone')['keystone']
if os_version >= 'queens':
designate_api = '2'
else:
designate_api = '1'
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(keystone_session)
des_client = mojo_os_utils.get_designate_session_client(
keystone_session, all_tenants=True, client_version=designate_api)
for server in nova_client.servers.list():
for addr_info in server.addresses['private']:
if addr_info['OS-EXT-IPS:type'] == 'floating':
mojo_os_utils.check_dns_entry(
des_client, addr_info['addr'], domain_name,
'{}.{}'.format(server.name, domain_name))
def basic_overcloud_network():
"""Run setup for neutron networking.
Configure the following:
The overcloud network using subnet pools
"""
cli_utils.setup_logging()
# Get network configuration settings
network_config = {}
# Declared overcloud settings
network_config.update(OVERCLOUD_NETWORK_CONFIG)
# Default undercloud settings
network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG)
# Environment specific settings
network_config.update(generic_utils.get_undercloud_env_vars())
# Get keystone session
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Handle network for Openstack-on-Openstack scenarios
if juju_utils.get_provider_type() == "openstack":
undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session()
network.setup_gateway_ext_port(network_config,
keystone_session=undercloud_ks_sess)
# Confugre the overcloud network
network.setup_sdn(network_config, keystone_session=keystone_session)
def main():
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
#session = zaza_os.get_undercloud_keystone_session()
#neutron_client = zaza_os.get_neutron_session_client(session)
#nova_client = zaza_os.get_nova_session_client(session, version=2.56)
if args.vnic_binding_type == 'dummy':
logging.warn('Running in dummy mode')
binding_type = None
else:
binding_type = args.vnic_binding_type
if args.action == 'summary':
logging.info('Running Summary')
summary(
zaza_os.get_nova_session_client(
zaza_os.get_undercloud_keystone_session(),
version=2.56),
args.application_name)
elif args.action == 'balance':
logging.info('Running balance')
balance(
zaza_os.get_nova_session_client(
zaza_os.get_undercloud_keystone_session(),
version=2.56),
args.application_name)
elif args.action == 'advertise':
logging.info('Running advertise')
advertise(
args.application_name)
elif args.action == 'listen':
logging.info('Running listen')
listen(
args.application_name,
args.cidr,
int(args.listener_count))
def main(argv):
cli_utils.setup_logging()
try:
cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem')
os.stat(cacert)
except FileNotFoundError:
cacert = None
session = openstack_utils.get_overcloud_keystone_session(verify=cacert)
glance_client = mojo_os_utils.get_glance_session_client(session)
current_images = mojo_os_utils.get_images_list(glance_client)
image_file = mojo_utils.get_mojo_file('images.yaml')
image_config = generic_utils.get_yaml_config(image_file)
cache_dir = '/tmp/img_cache'
for image in image_config.keys():
if image_config[image]['glance_name'] in current_images:
logging.warning('Skipping %s it is already in'
'glance' % (image_config[image]['glance_name']))
continue
image_name = image_config[image]['url'].split('/')[-1]
if os.path.exists(cache_dir + '/' + image_name):
local_file = cache_dir + '/' + image_name
else:
local_file = mojo_os_utils.download_image(
image_config[image]['url'])
mojo_os_utils.upload_image(glance_client, local_file,
image_config[image]['glance_name'],
image_config[image]['is_public'],
image_config[image]['disk_format'],
image_config[image]['container_format'])
def main():
"""Execute full test run."""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
if args.dev and args.smoke:
raise ValueError('Ambiguous arguments: --smoke and '
'--dev cannot be used together')
if args.dev and args.bundle:
raise ValueError('Ambiguous arguments: --bundle and '
'--dev cannot be used together')
if args.smoke and args.bundle:
raise ValueError('Ambiguous arguments: --bundle and '
'--smoke cannot be used together')
if args.force:
logging.warn("Using the --force argument for 'juju deploy'. Note "
"that this disables juju checks for compatibility.")
func_test_runner(keep_model=args.keep_model,
smoke=args.smoke,
dev=args.dev,
bundle=args.bundle,
force=args.force,
test_directory=args.test_directory)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main(argv):
cli_utils.setup_logging()
switch_map = {
'neutron-gateway': 'local:{}/{}'.format(os.environ['MOJO_SERIES'],
'neutron-gateway')
}
mojo_utils.upgrade_all_services(switch=switch_map)
def setup():
"""Run setup for BGP networking.
Configure the following:
The overcloud network using subnet pools
The overcloud BGP speaker
The BGP peer
Advertising of the FIPs via BGP
Advertising of the project network(s) via BGP
:returns: None
:rtype: None
"""
cli_utils.setup_logging()
# Get network configuration settings
network_config = {}
# Declared overcloud settings
network_config.update(OVERCLOUD_NETWORK_CONFIG)
# Default undercloud settings
network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG)
# Environment specific settings
network_config.update(generic_utils.get_undercloud_env_vars())
# Get keystone session
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Confugre the overcloud network
network.setup_sdn(network_config, keystone_session=keystone_session)
# Configure BGP
bgp_speaker.setup_bgp_speaker(
peer_application_name=DEFAULT_PEER_APPLICATION_NAME,
keystone_session=keystone_session)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("services", nargs="*")
options = parser.parse_args()
services = cli_utils.parse_arg(options, 'services', multiargs=True)
for service in services:
mojo_utils.upgrade_service(service)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("application", nargs="*")
options = parser.parse_args()
unit_args = cli_utils.parse_arg(options, 'application', multiargs=True)
for application in unit_args:
mojo_utils.delete_application(application)
def main():
"""Deploy bundle."""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
if args.force:
logging.warn("Using the --force argument for 'juju deploy'. Note "
"that this disables juju checks for compatibility.")
deploy(args.bundle, args.model, wait=args.wait, force=args.force)
run_report.output_event_report()
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("units", nargs="*")
options = parser.parse_args()
unit_args = mojo_utils.parse_mojo_arg(options, 'units', multiargs=True)
for unitreq in unit_args:
service, count = unitreq.split(":")
mojo_utils.add_unit(service, unit_num=count)
def test_setup_logging(self):
_logger, _consolehandler, _logformatter = self.setup_logging_mocks()
cli_utils.setup_logging()
self.logging.Formatter.assert_called_with(
datefmt='%Y-%m-%d %H:%M:%S',
fmt='%(asctime)s [%(levelname)s] %(message)s')
self.logging.getLogger.assert_called_with()
_logger.setLevel.assert_called_with(20)
_consolehandler.setFormatter.assert_called_with(_logformatter)
_logger.addHandler.assert_called_with(_consolehandler)
def main():
"""Run the tests defined by the command line args.
Run the tests defined by the command line args or if none were provided
read the tests from the charms tests.yaml config file
"""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
tests = args.tests or utils.get_charm_config()['tests']
test(args.model_name, tests)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main():
"""Run the configuration defined by the command line args.
Run the configuration defined by the command line args or if none were
provided read the configuration functions from the charms tests.yaml
config file
"""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
funcs = args.configfuncs or utils.get_charm_config()['before_deploy']
before_deploy(args.model_name, funcs)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main(argv):
cli_utils.setup_logging()
# Setup client
keystone_session = openstack_utils.get_overcloud_keystone_session()
os_version = openstack_utils.get_current_os_versions(
'keystone')['keystone']
if os_version >= 'queens':
designate_api_version = '2'
else:
designate_api_version = '1'
client = mojo_os_utils.get_designate_session_client(
keystone_session, client_version=designate_api_version)
designate_api_version = 2
zone = mojo_os_utils.create_or_return_zone(
client,
TEST_DOMAIN,
TEST_DOMAIN_EMAIL)
mojo_os_utils.create_or_return_recordset(
client,
zone['id'],
'www',
'A',
[TEST_RECORD[TEST_WWW_RECORD]])
# Test record is in bind and designate
mojo_os_utils.check_dns_entry(
client,
TEST_RECORD[TEST_WWW_RECORD],
TEST_DOMAIN,
record_name=TEST_WWW_RECORD,
designate_api=designate_api_version)
mojo_utils.add_unit('designate-bind')
mojo_os_utils.check_dns_entry(
client,
TEST_RECORD[TEST_WWW_RECORD],
TEST_DOMAIN,
record_name=TEST_WWW_RECORD,
designate_api=designate_api_version)
mojo_utils.delete_oldest('designate-bind')
mojo_os_utils.check_dns_entry(
client,
TEST_RECORD[TEST_WWW_RECORD],
TEST_DOMAIN,
record_name=TEST_WWW_RECORD,
designate_api=designate_api_version)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("--service")
parser.add_argument("--resource")
options = parser.parse_args()
service = cli_utils.parse_arg(options, 'service')
resource = cli_utils.parse_arg(options, 'resource')
xenial = distro_info.UbuntuDistroInfo().all.index('xenial')
series = os.environ.get('MOJO_SERIES')
mojo_env = distro_info.UbuntuDistroInfo().all.index(series)
if mojo_env >= xenial:
resource = resource.replace('eth0', 'ens2')
mojo_os_utils.delete_crm_leader(service, resource)
def main(argv):
cli_utils.setup_logging()
keystone_session = openstack_utils.get_overcloud_keystone_session()
aodhc = mojo_os_utils.get_aodh_session_client(keystone_session)
nova_client = openstack_utils.get_nova_session_client(keystone_session)
servers = nova_client.servers.list()
assert servers, "No servers available for AODH testing"
if servers:
alarm_name = 'mojo_instance_off'
server = servers[0]
assert server.status == 'ACTIVE', "Server {} not active".format(
server.name)
logging.info('Using server {} for aodh test'.format(server.name))
server = nova_client.servers.find(name=server.name)
logging.info('Deleting alarm {} if it exists'.format(alarm_name))
mojo_os_utils.delete_alarm(aodhc, alarm_name, cache_wait=True)
logging.info('Creating alarm {}'.format(alarm_name))
alarm_def = {
'type': 'event',
'name': alarm_name,
'description': 'Instance powered OFF',
'alarm_actions': ['log://'],
'ok_actions': ['log://'],
'insufficient_data_actions': ['log://'],
'event_rule': {
'event_type':
'compute.instance.power_off.*',
'query': [{
'field': 'traits.instance_id',
'op': 'eq',
'type': 'string',
'value': server.id
}]
}
}
alarm_info = aodhc.alarm.create(alarm_def)
logging.info('Stopping server {}'.format(server.name))
server.stop()
for i in range(10):
alarm_state = mojo_os_utils.get_alarm_state(
aodhc, alarm_info['alarm_id'])
if alarm_state == 'alarm':
logging.info('Alarm triggered')
break
else:
time.sleep(5)
else:
raise Exception("Alarm failed to trigger")
def main(argv):
cli_utils.setup_logging()
logging.getLogger("urllib3").setLevel(logging.WARNING)
keystone_session_uc = openstack_utils.get_undercloud_keystone_session()
under_novac = openstack_utils.get_nova_session_client(keystone_session_uc)
keystone_session_oc = openstack_utils.get_overcloud_keystone_session()
clients = {
'neutron':
openstack_utils.get_neutron_session_client(keystone_session_oc),
'nova': openstack_utils.get_nova_session_client(keystone_session_oc),
'glance': mojo_os_utils.get_glance_session_client(keystone_session_oc),
}
image_file = mojo_utils.get_mojo_file('images.yaml')
image_config = generic_utils.get_yaml_config(image_file)
image_password = image_config['cirros']['password']
# Look for existing Cirros guest
server, ip = get_cirros_server(clients, image_password)
router = (clients['neutron'].list_routers(
name='provider-router')['routers'][0])
l3_agents = clients['neutron'].list_l3_agent_hosting_routers(
router=router['id'])['agents']
logging.info('Checking there are multiple L3 agents running tenant router')
if len(l3_agents) != 2:
raise Exception('Unexpected number of l3 agents')
for agent in l3_agents:
gateway_hostname = agent['host']
gateway_server = under_novac.servers.find(name=gateway_hostname)
logging.info('Shutting down neutron gateway {} ({})'.format(
gateway_hostname, gateway_server.id))
gateway_server.stop()
if not check_server_state(
under_novac, 'SHUTOFF', server_name=gateway_hostname):
raise Exception('Server failed to reach SHUTOFF state')
logging.info('Neutron gateway %s has shutdown' % (gateway_hostname))
logging.info('Checking connectivity to cirros guest')
if not mojo_os_utils.wait_for_ping(ip, 90):
raise Exception('Cirros guest not responding to ping')
if not mojo_os_utils.ssh_test(
'cirros', ip, server.name, password=image_password):
raise Exception('Cirros guest issh connection failed')
logging.info('Starting neutron gateway: ' + gateway_hostname)
gateway_server.start()
if not check_server_state(
under_novac, 'ACTIVE', server_name=gateway_hostname):
raise Exception('Server failed to reach SHUTOFF state')
if not check_neutron_agent_states(clients['neutron'],
gateway_hostname):
raise Exception('Server agents failed to reach active state')
def test_setup_logging(self):
self.patch_object(cli_utils, "logging")
_logformatter = mock.MagicMock()
_logger = mock.MagicMock()
_consolehandler = mock.MagicMock()
self.logging.Formatter.return_value = _logformatter
self.logging.getLogger.return_value = _logger
self.logging.StreamHandler.return_value = _consolehandler
cli_utils.setup_logging()
self.logging.Formatter.assert_called_with(
datefmt='%Y-%m-%d %H:%M:%S',
fmt='%(asctime)s [%(levelname)s] %(message)s')
self.logging.getLogger.assert_called_with()
_logger.setLevel.assert_called_with("INFO")
_consolehandler.setFormatter.assert_called_with(_logformatter)
_logger.addHandler.assert_called_with(_consolehandler)
def run_from_cli():
"""Run test for BGP routes from CLI.
:returns: None
:rtype: None
"""
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("--peer-application",
"-a",
help="BGP Peer application name. Default: quagga",
default="quagga")
options = parser.parse_args()
peer_application_name = cli_utils.parse_arg(options, "peer_application")
test_bgp_routes(peer_application_name)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument(
"--target_release",
default='auto', help="Openstack release name to upgrade to or 'auto' "
"to have script upgrade based on the lowest value"
"across all services")
options = parser.parse_args()
target_release = cli_utils.parse_arg(options, 'target_release')
principle_services = mojo_utils.get_principle_applications()
current_versions = openstack_utils.get_current_os_versions(
principle_services)
if target_release == 'auto':
# If in auto mode find the lowest value openstack release across all
# services and make sure all servcies are upgraded to one release
# higher than the lowest
lowest_release = mojo_os_utils.get_lowest_os_version(current_versions)
target_release = mojo_os_utils.next_release(lowest_release)[1]
# Get a list of services that need upgrading
needs_upgrade = get_upgrade_targets(target_release, current_versions)
for application in openstack_utils.UPGRADE_SERVICES:
if application['name'] not in principle_services:
continue
if application['name'] not in needs_upgrade:
logging.info('Not upgrading {} it is at {} or higher'.format(
application['name'],
target_release)
)
continue
logging.info('Upgrading {} to {}'.format(application['name'],
target_release))
# Update required relations
update_relations(application['name'], target_release)
ubuntu_version = mojo_utils.get_ubuntu_version(application['name'])
config = {application['type']['origin_setting']:
"cloud:{}-{}/proposed"
.format(ubuntu_version, target_release)}
model.set_application_config(application['name'], config)
# NOTE: For liberty->mitaka upgrade ceilometer-agent gets stuck at
# 'Services not running that should be: memcached' after nova-compute
# upgrade, and test would wait forever. Therefore we upgrade
# ceilometer-agent immediately after nova-compute.
if application['name'] == 'nova-compute':
model.set_application_config('ceilometer-agent', config)
mojo_utils.juju_wait_finished()
def keystone_federation_setup():
"""Configure Keystone Federation."""
cli_utils.setup_logging()
keystone_session = openstack_utils.get_overcloud_keystone_session()
keystone_client = openstack_utils.get_keystone_session_client(
keystone_session)
try:
domain = keystone_client.domains.find(name=FEDERATED_DOMAIN)
except keystoneauth1.exceptions.http.NotFound:
domain = keystone_client.domains.create(FEDERATED_DOMAIN,
description="Federated Domain",
enabled=True)
try:
group = keystone_client.groups.find(name=FEDERATED_GROUP,
domain=domain)
except keystoneauth1.exceptions.http.NotFound:
group = keystone_client.groups.create(FEDERATED_GROUP,
domain=domain,
enabled=True)
role = keystone_client.roles.find(name=MEMBER)
keystone_client.roles.grant(role, group=group, domain=domain)
try:
idp = keystone_client.federation.identity_providers.find(
name=IDP, domain_id=domain.id)
except keystoneauth1.exceptions.http.NotFound:
idp = keystone_client.federation.identity_providers.create(
IDP, remote_ids=[REMOTE_ID], domain_id=domain.id, enabled=True)
JSON_RULES = json.loads(MAP_TEMPLATE.format(domain_id=domain.id))
try:
keystone_client.federation.mappings.find(name=MAP_NAME)
except keystoneauth1.exceptions.http.NotFound:
keystone_client.federation.mappings.create(MAP_NAME, rules=JSON_RULES)
try:
keystone_client.federation.protocols.get(IDP, PROTOCOL_NAME)
except keystoneauth1.exceptions.http.NotFound:
keystone_client.federation.protocols.create(PROTOCOL_NAME,
mapping=MAP_NAME,
identity_provider=idp)
def main():
"""Run the configuration defined by the command line args.
Run the configuration defined by the command line args or if none were
provided read the configuration functions from the charms tests.yaml
config file
"""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
for model_alias, model_name in args.model.items():
if args.configfuncs:
funcs = args.configfuncs
else:
config_steps = utils.get_config_steps()
funcs = config_steps.get(model_alias, [])
configure(model_name, funcs)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main():
"""Run the tests defined by the command line args.
Run the tests defined by the command line args or if none were provided
read the tests from the charms tests.yaml config file
"""
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
zaza.model.set_juju_model_aliases(args.model)
for model_alias, model_name in args.model.items():
if args.tests:
tests = args.tests
else:
test_steps = utils.get_test_steps()
tests = test_steps.get(model_alias, [])
test(model_name, tests)
run_report.output_event_report()
asyncio.get_event_loop().close()
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("router", nargs="?")
options = parser.parse_args()
router_name = cli_utils.parse_arg(options, 'router')
try:
cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem')
os.stat(cacert)
except FileNotFoundError:
cacert = None
keystone_session = openstack_utils.get_overcloud_keystone_session(
verify=cacert)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
router = neutron_client.list_routers(name=router_name)['routers'][0]['id']
l3_agent = neutron_client.list_l3_agent_hosting_routers(router=router)
hosting_machine = l3_agent['agents'][0]['host']
mojo_utils.delete_machine(hosting_machine)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("term_method", default='juju', nargs='?')
skip_applications = ['neutron-gateway', 'mongodb',
'heat', 'rabbitmq-server']
princ_applications = mojo_utils.get_principle_applications()
applications = [item for item in princ_applications
if item not in skip_applications]
for svc in applications:
doomed_application = applications.pop(0)
mojo_utils.delete_juju_leader(doomed_application)
mojo_utils.juju_check_hooks_complete()
mojo_utils.juju_wait_finished()
check_cluster_status(doomed_application)
mojo_utils.add_unit(doomed_application, unit_num=1)
mojo_utils.juju_wait_finished()
mojo_utils.juju_check_hooks_complete()
check_crm_status(doomed_application)
