def add_lts_image(glance_client=None, image_name=None, release=None):
"""Add an Ubuntu LTS image to the current deployment.
:param glance: Authenticated glanceclient
:type glance: glanceclient.Client
:param image_name: Label for the image in glance
:type image_name: str
:param release: Name of ubuntu release.
:type release: str
"""
image_name = image_name or LTS_IMAGE_NAME
release = release or LTS_RELEASE
if not glance_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
glance_client = openstack_utils.get_glance_session_client(
keystone_session)
if openstack_utils.get_images_by_name(glance_client, image_name):
logging.warning('Using existing glance image')
else:
image_url = openstack_utils.find_ubuntu_image(
release=release,
arch='amd64')
openstack_utils.create_image(
glance_client,
image_url,
image_name)
def add_image(image_url, glance_client=None, image_name=None, tags=[]):
"""Retrieve image from ``image_url`` and add it to glance.
:param image_url: Retrievable URL with image data
:type image_url: str
:param glance: Authenticated glanceclient
:type glance: glanceclient.Client
:param image_name: Label for the image in glance
:type image_name: str
:param tags: List of tags to add to image
:type tags: list of str
"""
if not glance_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
glance_client = openstack_utils.get_glance_session_client(
keystone_session)
if image_name:
image = openstack_utils.get_images_by_name(glance_client, image_name)
if image:
logging.warning('Using existing glance image "{}" ({})'.format(
image_name, image[0].id))
else:
logging.info('Downloading image {}'.format(image_name or image_url))
openstack_utils.create_image(glance_client,
image_url,
image_name,
tags=tags)
def setUpClass(cls):
"""Run class setup for running tests."""
super(Cinder{{ cookiecutter.driver_name }}Test, cls).setUpClass()
cls.keystone_session = openstack_utils.get_overcloud_keystone_session()
cls.model_name = zaza.model.get_juju_model()
cls.cinder_client = openstack_utils.get_cinder_session_client(
cls.keystone_session)
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 setUpClass(cls):
"""Run setup for test class to create common resourcea."""
cls.keystone_session = openstack_utils.get_overcloud_keystone_session()
cls.model_name = model.get_juju_model()
cls.test_config = lifecycle_utils.get_charm_config()
cls.application_name = cls.test_config['charm_name']
cls.lead_unit = model.get_lead_unit_name(cls.application_name,
model_name=cls.model_name)
logging.debug('Leader unit is {}'.format(cls.lead_unit))
def _v2():
keystone_session = openstack_utils.get_overcloud_keystone_session()
keystone_client = openstack_utils.get_keystone_session_client(
keystone_session, client_api_version=2)
tenant = keystone_client.tenants.create(tenant_name=DEMO_TENANT,
description='Demo Tenant',
enabled=True)
keystone_client.users.create(name=DEMO_USER,
password=DEMO_PASSWORD,
tenant_id=tenant.id)
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 _v3():
keystone_session = openstack_utils.get_overcloud_keystone_session()
keystone_client = openstack_utils.get_keystone_session_client(
keystone_session)
domain = keystone_client.domains.create(
DEMO_DOMAIN,
description='Demo Domain',
enabled=True)
project = keystone_client.projects.create(
DEMO_PROJECT,
domain,
description='Demo Project',
enabled=True)
demo_user = keystone_client.users.create(
DEMO_USER,
domain=domain,
project=project,
password=DEMO_PASSWORD,
email='*****@*****.**',
description='Demo User',
enabled=True)
member_role = keystone_client.roles.find(name='Member')
keystone_client.roles.grant(
member_role,
user=demo_user,
project_domain=domain,
project=project)
demo_admin_user = keystone_client.users.create(
DEMO_ADMIN_USER,
domain=domain,
project=project,
password=DEMO_ADMIN_USER_PASSWORD,
email='*****@*****.**',
description='Demo Admin User',
enabled=True)
admin_role = keystone_client.roles.find(name='Admin')
keystone_client.roles.grant(
admin_role,
user=demo_admin_user,
domain=domain)
keystone_client.roles.grant(
member_role,
user=demo_admin_user,
project_domain=domain,
project=project)
keystone_client.roles.grant(
admin_role,
user=demo_admin_user,
project_domain=domain,
project=project)
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_bgp_routes(peer_application_name="quagga", keystone_session=None):
"""Test BGP routes.
:param peer_application_name: String name of BGP peer application
:type peer_application_name: string
:param keystone_session: Keystone session object for overcloud
:type keystone_session: keystoneauth1.session.Session object
:raises: AssertionError if expected BGP routes are not found
:returns: None
:rtype: None
"""
# If a session has not been provided, acquire one
if not keystone_session:
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Get authenticated clients
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Get the peer unit
peer_unit = model.get_units(peer_application_name)[0].entity_id
# Get expected advertised routes
private_cidr = neutron_client.list_subnets(
name="private_subnet")["subnets"][0]["cidr"]
floating_ip_cidr = "{}/32".format(
neutron_client.list_floatingips()["floatingips"][0]
["floating_ip_address"])
# This test may run immediately after configuration. It may take time for
# routes to propogate via BGP. Do a binary backoff.
@tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60),
reraise=True,
stop=tenacity.stop_after_attempt(8))
def _assert_cidr_in_peer_routing_table(peer_unit, cidr):
logging.debug("Checking for {} on BGP peer {}".format(cidr, peer_unit))
# Run show ip route bgp on BGP peer
routes = juju_utils.remote_run(
peer_unit, remote_cmd='vtysh -c "show ip route bgp"')
logging.debug(routes)
assert cidr in routes, (
"CIDR, {}, not found in BGP peer's routing table".format(cidr))
_assert_cidr_in_peer_routing_table(peer_unit, private_cidr)
logging.info(
"Private subnet CIDR, {}, found in routing table".format(private_cidr))
_assert_cidr_in_peer_routing_table(peer_unit, floating_ip_cidr)
logging.info("Floating IP CIDR, {}, found in routing table".format(
floating_ip_cidr))
def setUpClass(cls):
"""Run class setup for running Keystone charm operation tests."""
super(BaseKeystoneTest, cls).setUpClass()
cls.keystone_ips = zaza.model.get_app_ips('keystone')
if (openstack_utils.get_os_release() <
openstack_utils.get_os_release('xenial_queens')):
cls.default_api_version = '2'
else:
cls.default_api_version = '3'
cls.admin_keystone_session = (
openstack_utils.get_overcloud_keystone_session())
cls.admin_keystone_client = (
openstack_utils.get_keystone_session_client(
cls.admin_keystone_session,
client_api_version=cls.default_api_version))
def test_tunnel_datapath(self):
"""From ports list, connect to unit in one end, ping other end(s)."""
keystone_session = openstack_utils.get_overcloud_keystone_session()
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
resp = neutron_client.list_ports()
ports = resp['ports']
host_port = {}
for port in ports:
if (port['device_owner'].startswith('network:')
or port['device_owner'].startswith('compute:')):
continue
host_port[port['binding:host_id']] = port
for unit in zaza.model.get_units('neutron-openvswitch'):
result = zaza.model.run_on_unit(unit.entity_id, 'hostname')
hostname = result['Stdout'].rstrip()
if hostname not in host_port:
# no port bound to this host, skip
continue
# get interface name from unit OVS data
ovs_interface = json.loads(
zaza.model.run_on_unit(
unit.entity_id, 'ovs-vsctl -f json find Interface '
'external_ids:iface-id={}'.format(
host_port[hostname]['id']))['Stdout'])
for (idx, heading) in enumerate(ovs_interface['headings']):
if heading == 'name':
break
else:
raise Exception('Unable to find interface name from OVS')
interface_name = ovs_interface['data'][0][idx]
ip_unit = zaza.model.run_on_unit(
unit.entity_id, 'ip addr show dev {}'.format(interface_name))
for other_host in (set(host_port) - set([hostname])):
for ip_info in host_port[other_host]['fixed_ips']:
logging.info('Local IP info: "{}"'.format(ip_unit))
logging.info('PING "{}" --> "{}"...'.format(
hostname, other_host))
result = zaza.model.run_on_unit(
unit.entity_id,
'ping -c 3 {}'.format(ip_info['ip_address']))
logging.info(result['Stdout'])
if result['Code'] == '1':
raise Exception('FAILED')
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 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')
target_client = zaza_openstack.get_swift_session_client(
keystone_session, region_name='west-1')
zaza_model.run_action_on_leader(
'slave-ceph-radosgw',
'promote',
action_params={},
)
_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={},
)
@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 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 test_object_storage_multisite(self):
"""Verify object storage replication.
Verify that the object storage replication works as expected.
"""
if not self.multisite:
raise unittest.SkipTest('Skipping multisite replication test')
logging.info('Checking multisite replication')
keystone_session = zaza_openstack.get_overcloud_keystone_session()
source_client = zaza_openstack.get_swift_session_client(
keystone_session, region_name='east-1')
_container = 'demo-container'
_test_data = 'Test data from Zaza'
source_client.put_container(_container)
source_client.put_object(_container,
'testfile',
contents=_test_data,
content_type='text/plain')
_, source_content = source_client.get_object(_container, 'testfile')
self.assertEqual(source_content.decode('UTF-8'), _test_data)
target_client = zaza_openstack.get_swift_session_client(
keystone_session, region_name='east-1')
@tenacity.retry(wait=tenacity.wait_exponential(multiplier=1, max=60),
reraise=True,
stop=tenacity.stop_after_attempt(12))
def _target_get_object():
return target_client.get_object(_container, 'testfile')
_, target_content = _target_get_object()
self.assertEqual(target_content.decode('UTF-8'),
source_content.decode('UTF-8'))
target_client.delete_object(_container, 'testfile')
try:
source_client.head_object(_container, 'testfile')
except ClientException as e:
self.assertEqual(e.http_status, 404)
else:
self.fail('object not deleted on source radosgw')
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 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 add_cirros_image(glance_client=None, image_name=None):
"""Add a cirros image to the current deployment.
:param glance: Authenticated glanceclient
:type glance: glanceclient.Client
:param image_name: Label for the image in glance
:type image_name: str
"""
image_name = image_name or CIRROS_IMAGE_NAME
if not glance_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
glance_client = openstack_utils.get_glance_session_client(
keystone_session)
if openstack_utils.get_images_by_name(glance_client, image_name):
logging.warning('Using existing glance image')
else:
image_url = openstack_utils.find_cirros_image(arch='x86_64')
openstack_utils.create_image(
glance_client,
image_url,
image_name)
def enable_hosts(masakari_client=None):
"""Enable all hypervisors within masakari.
Enable all hosts across all segments within masakari. This does not
enable the hypervisor from a nova POV.
:param masakari_client: Authenticated masakari client
:type masakari_client: openstack.instance_ha.v1._proxy.Proxy
"""
if not masakari_client:
keystone_session = openstack_utils.get_overcloud_keystone_session()
masakari_client = openstack_utils.get_masakari_session_client(
keystone_session)
for segment in masakari_client.segments():
for host in masakari_client.hosts(segment_id=segment.uuid):
if host.on_maintenance:
logging.info("Removing maintenance mode from masakari "
"host {}".format(host.uuid))
masakari_client.update_host(host.uuid,
segment_id=segment.uuid,
**{'on_maintenance': False})
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 test_object_storage(self):
"""Verify object storage API.
Verify that the object storage API works as expected.
"""
if self.multisite:
raise unittest.SkipTest('Skipping REST API test, '
'multisite configuration')
logging.info('Checking Swift REST API')
keystone_session = zaza_openstack.get_overcloud_keystone_session()
region_name = 'RegionOne'
swift_client = zaza_openstack.get_swift_session_client(
keystone_session, region_name)
_container = 'demo-container'
_test_data = 'Test data from Zaza'
swift_client.put_container(_container)
swift_client.put_object(_container,
'testfile',
contents=_test_data,
content_type='text/plain')
_, content = swift_client.get_object(_container, 'testfile')
self.assertEqual(content.decode('UTF-8'), _test_data)
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 keystone_v3_domain_setup():
overcloud_novarc = openstack_utils.get_overcloud_auth()
if overcloud_novarc.get('API_VERSION', 2) == 3:
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)
mojo_os_utils.project_create(keystone_client, ['admin'],
'admin_domain')
admin_project_id = openstack_utils.get_project_id(
keystone_client,
'admin',
api_version=3,
domain_name='admin_domain')
role = keystone_client.roles.find(name='admin')
user = keystone_client.users.find(name='admin')
keystone_client.roles.grant(role, user=user, project=admin_project_id)
def overlay_network():
"""Create network with subnets, add OVS port per unit.
Useful for testing that the `neutron-openvswitch` charm configures the
system, LXD profiles etc in such a way that the Neutron OpenvSwitch
agent is able to perform the required OVS configuration.
"""
keystone_session = openstack_utils.get_overcloud_keystone_session()
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
resp = neutron_client.create_network(
{'network': {
'name': 'zaza-neutron-openvswitch-network'
}})
network = resp['network']
logging.info('created network {}'.format(pprint.pformat(network)))
# make rfc4193 Unique Local IPv6 Unicast Addresses from network UUID
rfc4193_addr = 'fc00'
for n in [0, 4, 8]:
rfc4193_addr += ':' + network['id'].split('-')[4][n:n + 4]
rfc4193_addr += '::/64'
resp = neutron_client.create_subnet({
'subnets': [
{
'name': 'zaza-neutron-openvswitch-subnet',
'ip_version': 4,
'cidr': '10.42.42.0/24',
'network_id': network['id'],
},
{
'name': 'zaza-neutron-openvswitch-subnetv6',
'ip_version': 6,
'ipv6_address_mode': 'slaac',
'ipv6_ra_mode': 'slaac',
'cidr': rfc4193_addr,
'network_id': network['id'],
},
],
})
logging.info('created subnets {}'.format(pprint.pformat(resp['subnets'])))
for unit in zaza.model.get_units('neutron-openvswitch'):
result = zaza.model.run_on_unit(unit.entity_id, 'hostname')
hostname = result['Stdout'].rstrip()
logging.info('hostname: "{}"'.format(hostname))
resp = neutron_client.create_port({
'port': {
'binding:host_id': hostname,
'device_owner': 'Zaza:neutron-openvswitch-test',
'name': hostname,
'network_id': network['id'],
},
})
port = resp['port']
logging.info('created port {}'.format(pprint.pformat(port)))
result = zaza.model.run_on_unit(
unit.entity_id, 'ovs-vsctl -- --may-exist add-port br-int zaza0 '
'-- set Interface zaza0 type=internal '
'-- set Interface zaza0 external-ids:iface-status=active '
'-- set Interface zaza0 external-ids:attached-mac={} '
'-- set Interface zaza0 external-ids:iface-id={} '
'-- set Interface zaza0 external-ids:skip_cleanup=true '.format(
port['mac_address'], port['id']))
logging.info('do ovs configuration {}'.format(pprint.pformat(result)))
result = zaza.model.run_on_unit(
unit.entity_id,
'ip link set dev zaza0 address {} up'.format(port['mac_address']))
logging.info('ip link {}'.format(pprint.pformat(result)))
for ip_info in port['fixed_ips']:
# NOTE(fnordahl) overly simplified but is sufficient for test
if ':' in ip_info['ip_address']:
bits = '64'
else:
bits = '24'
result = zaza.model.run_on_unit(
unit.entity_id,
'ip addr add {}/{} dev zaza0'.format(ip_info['ip_address'],
bits))
logging.info('ip addr add {}'.format(pprint.pformat(result)))
def setup_bgp_speaker(peer_application_name, keystone_session=None):
"""Perform BGP Speaker setup.
:param peer_application_name: String name of BGP peer application
:type peer_application_name: string
:param keystone_session: Keystone session object for overcloud
:type keystone_session: keystoneauth1.session.Session object
:returns: None
:rtype: None
"""
# Get ASNs from deployment
dr_relation = juju_utils.get_relation_from_unit(
'neutron-dynamic-routing',
peer_application_name,
'bgpclient')
peer_asn = dr_relation.get('asn')
logging.debug('peer ASn: "{}"'.format(peer_asn))
peer_relation = juju_utils.get_relation_from_unit(
peer_application_name,
'neutron-dynamic-routing',
'bgp-speaker')
dr_asn = peer_relation.get('asn')
logging.debug('our ASn: "{}"'.format(dr_asn))
# If a session has not been provided, acquire one
if not keystone_session:
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Get authenticated clients
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Create BGP speaker
logging.info("Setting up BGP speaker")
bgp_speaker = openstack_utils.create_bgp_speaker(
neutron_client, local_as=dr_asn)
# Add networks to bgp speaker
logging.info("Advertising BGP routes")
openstack_utils.add_network_to_bgp_speaker(
neutron_client, bgp_speaker, EXT_NET)
openstack_utils.add_network_to_bgp_speaker(
neutron_client, bgp_speaker, PRIVATE_NET)
logging.debug("Advertised routes: {}"
.format(
neutron_client.list_route_advertised_from_bgp_speaker(
bgp_speaker["id"])))
# Create peer
logging.info("Setting up BGP peer")
bgp_peer = openstack_utils.create_bgp_peer(neutron_client,
peer_application_name,
remote_as=peer_asn)
# Add peer to bgp speaker
logging.info("Adding BGP peer to BGP speaker")
openstack_utils.add_peer_to_bgp_speaker(
neutron_client, bgp_speaker, bgp_peer)
# Create Floating IP to advertise
logging.info("Creating floating IP to advertise")
port = openstack_utils.create_port(neutron_client, FIP_TEST, PRIVATE_NET)
floating_ip = openstack_utils.create_floating_ip(neutron_client, EXT_NET,
port=port)
logging.info(
"Advertised floating IP: {}".format(
floating_ip["floating_ip_address"]))
# NOTE(fnordahl): As a workaround for LP: #1784083 remove BGP speaker from
# dragent and add it back.
logging.info(
"Waiting for Neutron agent 'neutron-bgp-dragent' to appear...")
keystone_session = openstack_utils.get_overcloud_keystone_session()
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
agents = openstack_utils.neutron_agent_appears(neutron_client,
'neutron-bgp-dragent')
agent_id = None
for agent in agents.get('agents', []):
agent_id = agent.get('id', None)
if agent_id is not None:
break
logging.info(
'Waiting for BGP speaker to appear on agent "{}"...'.format(agent_id))
bgp_speakers = openstack_utils.neutron_bgp_speaker_appears_on_agent(
neutron_client, agent_id)
logging.info(
"Removing and adding back bgp-speakers to agent (LP: #1784083)...")
while True:
try:
for bgp_speaker in bgp_speakers.get('bgp_speakers', []):
bgp_speaker_id = bgp_speaker.get('id', None)
logging.info('removing "{}" from "{}"'
''.format(bgp_speaker_id, agent_id))
neutron_client.remove_bgp_speaker_from_dragent(
agent_id, bgp_speaker_id)
except neutronclient.common.exceptions.NotFound as e:
logging.info('Exception: "{}"'.format(e))
break
neutron_client.add_bgp_speaker_to_dragent(
agent_id, {'bgp_speaker_id': bgp_speaker_id})
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument('-r',
'--resolver',
help='Resolver address. '
'Usually designate-bind address.',
required=False)
parser.add_argument('-d',
'--domain_name',
help='DNS Domain Name. '
'Must end in a .',
default='mojo.serverstack.')
parser.add_argument('-e',
'--email',
help='Email address',
default='*****@*****.**')
parser.add_argument('-b',
'--bind-service',
help='Bind Service Name',
default='designate-bind')
options = parser.parse_args()
bind_service_name = cli_utils.parse_arg(options, 'bind_service')
resolver = cli_utils.parse_arg(options, 'resolver')
bind_unit = mojo_utils.get_juju_units(bind_service_name)[0]
if not resolver:
resolver = mojo_utils.get_juju_unit_ip(bind_unit)
domain_name = cli_utils.parse_arg(options, 'domain_name')
email = cli_utils.parse_arg(options, 'email')
nameserver = 'ns1.{}'.format(domain_name)
logging.info('Setting up designate {} {}'.format(nameserver, resolver))
os_version = openstack_utils.get_current_os_versions(
'keystone')['keystone']
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)
neutronc = openstack_utils.get_neutron_session_client(keystone_session)
if os_version >= 'queens':
designatec = mojo_os_utils.get_designate_session_client(
keystone_session, client_version='2')
zone = mojo_os_utils.create_or_return_zone(designatec, domain_name,
email)
mojo_os_utils.create_or_return_recordset(designatec, zone['id'], 'www',
'A', [resolver])
else:
designatec = mojo_os_utils.get_designate_session_client(
keystone_session, client_version='1')
if not mojo_os_utils.get_designate_server_id(designatec, nameserver):
logging.info('Creating server {}'.format(nameserver))
server = Server(name=nameserver)
server_id = designatec.servers.create(server)
assert (server_id is not None)
else:
logging.info('{} server already exists.'.format(nameserver))
domain_id = mojo_os_utils.get_designate_domain_id(
designatec, domain_name)
if not domain_id:
logging.info('Creating domain {}'.format(domain_name))
domain = Domain(name=domain_name, email=email)
domain_id = designatec.domains.create(domain)
assert (domain_id is not None)
else:
logging.info('{} domain already exists.'.format(domain_name))
if not mojo_os_utils.get_designate_record_id(designatec, domain_id,
nameserver):
logging.info('Creating NS record {}'.format(nameserver))
ns_record = Record(name=nameserver, type="A", data=resolver)
record_id = designatec.records.create(domain_id, ns_record)
assert (record_id is not None)
else:
logging.info('{} record already exists.'.format(nameserver))
logging.info('Update network to use domain {}'.format(domain_name))
net_uuid = openstack_utils.get_net_uuid(neutronc, 'private')
mojo_os_utils.update_network_dns(neutronc, net_uuid, domain_name)
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 get_swiftclient(self):
keystone_session = openstack_utils.get_overcloud_keystone_session()
swift_client = mojo_os_utils.get_swift_session_client(keystone_session)
return swift_client
