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 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 setUpClass(cls):
"""Run class setup for running tests."""
super(MasakariTest, cls).setUpClass()
cls.keystone_session = openstack_utils.get_overcloud_keystone_session()
cls.model_name = zaza.model.get_juju_model()
cls.nova_client = openstack_utils.get_nova_session_client(
cls.keystone_session)
def setup_gateway_ext_port(network_config, keystone_session=None):
"""Perform setup external port on Neutron Gateway.
For OpenStack on OpenStack scenarios.
:param network_config: Network configuration dictionary
:type network_config: dict
:param keystone_session: Keystone session object for undercloud
:type keystone_session: keystoneauth1.session.Session object
:returns: None
:rtype: None
"""
# If a session has not been provided, acquire one
if not keystone_session:
keystone_session = openstack_utils.get_undercloud_keystone_session()
# Get authenticated clients
nova_client = openstack_utils.get_nova_session_client(keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Add an interface to the neutron-gateway units and tell juju to use it
# as the external port.
if "net_id" in network_config.keys():
net_id = network_config["net_id"]
else:
net_id = None
logging.info("Configuring network for OpenStack undercloud/provider")
openstack_utils.configure_gateway_ext_port(nova_client,
neutron_client,
dvr_mode=network_config.get(
"dvr_enabled", False),
net_id=net_id)
def setUpClass(cls):
"""Run class setup for running glance tests."""
cls.keystone_session = openstack_utils.get_overcloud_keystone_session()
cls.model_name = model.get_juju_model()
cls.nova_client = openstack_utils.get_nova_session_client(
cls.keystone_session)
cls.neutron_client = openstack_utils.get_neutron_session_client(
cls.keystone_session)
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 manage_ssh_key(nova_client=None):
"""Create basic flavors.
:param nova_client: Authenticated nova client
:type nova_client: novaclient.v2.client.Client
"""
if not nova_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(
keystone_session)
cli_utils.setup_logging()
if not openstack_utils.valid_key_exists(nova_client,
nova_utils.KEYPAIR_NAME):
key = openstack_utils.create_ssh_key(
nova_client,
nova_utils.KEYPAIR_NAME,
replace=True)
openstack_utils.write_private_key(
nova_utils.KEYPAIR_NAME,
key.private_key)
def create_flavors(nova_client=None):
"""Create basic flavors.
:param nova_client: Authenticated nova client
:type nova_client: novaclient.v2.client.Client
"""
if not nova_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(
keystone_session)
cli_utils.setup_logging()
names = [flavor.name for flavor in nova_client.flavors.list()]
for flavor in nova_utils.FLAVORS.keys():
if flavor not in names:
nova_client.flavors.create(
name=flavor,
ram=nova_utils.FLAVORS[flavor]['ram'],
vcpus=nova_utils.FLAVORS[flavor]['vcpus'],
disk=nova_utils.FLAVORS[flavor]['disk'],
flavorid=nova_utils.FLAVORS[flavor]['flavorid'])
def create_segments(segment_number=1, host_assignment_method=None):
"""Create a masakari segment and populate it with hypervisors.
:param segment_number: Number of segments to create
:type segment_number: int
:param host_assignment_method: Method to use to assign hypervisors to
segments
:type host_assignment_method: f()
"""
host_assignment_method = host_assignment_method or ROUND_ROBIN
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(keystone_session)
masakari_client = openstack_utils.get_masakari_session_client(
keystone_session)
for segment_number in range(0, segment_number):
segment_name = 'seg{}'.format(segment_number)
logging.info('Creating segment {}'.format(segment_name))
masakari_client.create_segment(name=segment_name,
recovery_method='auto',
service_type='COMPUTE')
HOST_ASSIGNMENT_METHODS[host_assignment_method](nova_client,
masakari_client)
def main():
"""Cleanup after test run."""
args = parse_args(sys.argv[1:])
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
instance = nova_client.servers.find(name=args.vm_name)
logger.debug("Found vm {} with instance is {}".format(
args.vm_name, instance.id))
wait(nova_client, instance.id, args.vm_name)
ip = assign_ip(neutron_client, instance.id)
logger.debug("Checking ping to {}".format(ip))
openstack_utils.ping_response(ip)
logger.debug("Checking ssh to {}".format(ip))
openstack_utils.ssh_test(username='******',
ip=ip,
vm_name=args.vm_name,
password=None,
privkey=get_priv_key(args.key_file))
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
default_machines = ["cirros:m1.tiny:1"]
parser.add_argument("machines", default=default_machines, nargs="*")
parser.add_argument("--active_wait", default=180)
parser.add_argument("--cloudinit_wait", default=180)
parser.add_argument("--ping_wait", default=180)
options = parser.parse_args()
machines = cli_utils.parse_arg(options, 'machines', multiargs=True)
active_wait = int(cli_utils.parse_arg(options, 'active_wait'))
cloudinit_wait = int(cli_utils.parse_arg(options, 'cloudinit_wait'))
ping_wait = int(cli_utils.parse_arg(options, 'ping_wait'))
overcloud_novarc = openstack_utils.get_overcloud_auth()
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)
keystonec = openstack_utils.get_keystone_session_client(keystone_session)
domain = overcloud_novarc.get('OS_PROJECT_DOMAIN_NAME')
project_id = openstack_utils.get_project_id(
keystonec,
'admin',
api_version=overcloud_novarc['API_VERSION'],
domain_name=domain)
novac = openstack_utils.get_nova_session_client(keystone_session)
neutronc = openstack_utils.get_neutron_session_client(keystone_session)
init_flavors(novac)
priv_key = mojo_os_utils.create_keypair(novac, 'mojo')
openstack_utils.add_neutron_secgroup_rules(neutronc, project_id)
for server in novac.servers.list():
novac.servers.delete(server.id)
for instanceset in machines:
image_name, flavor_name, count = instanceset.split(":")
# when instance count allows boot instances off both regular instance
# storage and volume storage
#
# account for count=1 and odd numbers
# NOTE(fnordahl) temporarilly disable test while tests settle
# regular_boot_count = int(int(count) / 2) + (int(count) % 2)
# volume_boot_count = int(int(count) / 2)
regular_boot_count = int(count)
volume_boot_count = 0
mojo_os_utils.boot_and_test(
novac,
neutronc,
image_name=image_name,
flavor_name=flavor_name,
number=regular_boot_count,
privkey=priv_key,
active_wait=active_wait,
cloudinit_wait=cloudinit_wait,
ping_wait=ping_wait,
)
mojo_os_utils.boot_and_test(
novac,
neutronc,
image_name=image_name,
flavor_name=flavor_name,
number=volume_boot_count,
privkey=priv_key,
active_wait=active_wait,
cloudinit_wait=cloudinit_wait,
ping_wait=ping_wait,
boot_from_volume=True,
)
def launch_instance(instance_key, use_boot_volume=False, vm_name=None,
private_network_name=None, image_name=None,
flavor_name=None, external_network_name=None, meta=None):
"""Launch an instance.
:param instance_key: Key to collect associated config data with.
:type instance_key: str
:param use_boot_volume: Whether to boot guest from a shared volume.
:type use_boot_volume: boolean
:param vm_name: Name to give guest.
:type vm_name: str
:param private_network_name: Name of private network to attach guest to.
:type private_network_name: str
:param image_name: Image name to use with guest.
:type image_name: str
:param flavor_name: Flavor name to use with guest.
:type flavor_name: str
:param external_network_name: External network to create floating ip from
for guest.
:type external_network_name: str
:param meta: A dict of arbitrary key/value metadata to store for this
server. Both keys and values must be <=255 characters.
:type meta: dict
"""
keystone_session = openstack_utils.get_overcloud_keystone_session()
nova_client = openstack_utils.get_nova_session_client(keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Collect resource information.
vm_name = vm_name or time.strftime("%Y%m%d%H%M%S")
image_name = image_name or boot_tests[instance_key]['image_name']
image = nova_client.glance.find_image(image_name)
flavor_name = flavor_name or boot_tests[instance_key]['flavor_name']
flavor = nova_client.flavors.find(name=flavor_name)
private_network_name = private_network_name or "private"
net = neutron_client.find_resource("network", private_network_name)
nics = [{'net-id': net.get('id')}]
meta = meta or {}
external_network_name = external_network_name or "ext_net"
if use_boot_volume:
bdmv2 = [{
'boot_index': '0',
'uuid': image.id,
'source_type': 'image',
'volume_size': flavor.disk,
'destination_type': 'volume',
'delete_on_termination': True}]
image = None
else:
bdmv2 = None
# Launch instance.
logging.info('Launching instance {}'.format(vm_name))
instance = nova_client.servers.create(
name=vm_name,
image=image,
block_device_mapping_v2=bdmv2,
flavor=flavor,
key_name=nova_utils.KEYPAIR_NAME,
meta=meta,
nics=nics)
# Test Instance is ready.
logging.info('Checking instance is active')
openstack_utils.resource_reaches_status(
nova_client.servers,
instance.id,
expected_status='ACTIVE',
stop_after_attempt=16)
logging.info('Checking cloud init is complete')
openstack_utils.cloud_init_complete(
nova_client,
instance.id,
boot_tests[instance_key]['bootstring'])
port = openstack_utils.get_ports_from_device_id(
neutron_client,
instance.id)[0]
logging.info('Assigning floating ip.')
ip = openstack_utils.create_floating_ip(
neutron_client,
external_network_name,
port=port)['floating_ip_address']
logging.info('Assigned floating IP {} to {}'.format(ip, vm_name))
openstack_utils.ping_response(ip)
# Check ssh'ing to instance.
logging.info('Testing ssh access.')
openstack_utils.ssh_test(
username=boot_tests[instance_key]['username'],
ip=ip,
vm_name=vm_name,
password=boot_tests[instance_key].get('password'),
privkey=openstack_utils.get_private_key(nova_utils.KEYPAIR_NAME))
def main(argv):
cli_utils.setup_logging()
keystone_session = openstack_utils.get_overcloud_keystone_session()
novac = openstack_utils.get_nova_session_client(keystone_session)
mojo_os_utils.check_guest_connectivity(novac)
def delete_unit_openstack(unit):
keystone_session = openstack_utils.get_undercloud_keystone_session()
nc = openstack_utils.get_nova_session_client(keystone_session)
server_id = convert_unit_to_machineno(unit)
server = nc.servers.find(id=server_id)
server.delete()