def verify_dns_on_central_and_subcloud(primary_subcloud,
fail_ok=False,
sc_dns=None):
res = []
for region in ('RegionOne', primary_subcloud):
# take snapshot
orig_dns_servers = system_helper.get_dns_servers(
auth_info=Tenant.get('admin_platform', dc_region=region))
if not sc_dns or set(sc_dns) <= set(orig_dns_servers):
LOG.info("Modify dns server to public dns")
system_helper.set_dns_servers(nameservers=['8.8.8.8'],
auth_info=Tenant.get(
'admin_platform',
dc_region=region))
LOG.info("Check dns on {}".format(region))
con_ssh = ControllerClient.get_active_controller(name=region)
code, out = con_ssh.exec_cmd('nslookup -timeout=1 www.google.com',
fail_ok=fail_ok,
expect_timeout=30)
res.append(code)
# revert
system_helper.set_dns_servers(nameservers=orig_dns_servers,
auth_info=Tenant.get('admin_platform',
dc_region=region))
return res
def download_openrc_files(quit_driver=True):
"""
Download openrc files from Horizon to <LOG_DIR>/horizon/.
"""
LOG.info("Download openrc files from horizon")
local_dir = os.path.join(ProjVar.get_var('LOG_DIR'), 'horizon')
from utils.horizon.pages import loginpage
rc_files = []
login_pg = loginpage.LoginPage()
login_pg.go_to_target_page()
try:
for auth_info in (Tenant.get('admin'), Tenant.get('tenant1'), Tenant.get('tenant2')):
user = auth_info['user']
password = auth_info['password']
openrc_file = '{}-openrc.sh'.format(user)
home_pg = login_pg.login(user, password=password)
home_pg.download_rc_v3()
home_pg.log_out()
openrc_path = os.path.join(local_dir, openrc_file)
assert os.path.exists(openrc_path), "{} not found after download".format(openrc_file)
rc_files.append(openrc_path)
finally:
if quit_driver:
HorizonDriver.quit_driver()
LOG.info("openrc files are successfully downloaded to: {}".format(local_dir))
return rc_files
def test_launch_vms_for_traffic():
stack1 = "/home/sysadmin/lab_setup-tenant1-resources.yaml"
stack1_name = "lab_setup-tenant1-resources"
stack2 = "/home/sysadmin/lab_setup-tenant2-resources.yaml"
stack2_name = "lab_setup-tenant2-resources"
script_name = "/home/sysadmin/create_resource_stacks.sh"
con_ssh = ControllerClient.get_active_controller()
if con_ssh.file_exists(file_path=script_name):
cmd1 = 'chmod 755 ' + script_name
con_ssh.exec_cmd(cmd1)
con_ssh.exec_cmd(script_name, fail_ok=False)
# may be better to delete all tenant stacks if any
heat_helper.create_stack(stack_name=stack1_name,
template=stack1,
auth_info=Tenant.get('tenant1'),
timeout=1000,
cleanup=None)
heat_helper.create_stack(stack_name=stack2_name,
template=stack2,
auth_info=Tenant.get('tenant2'),
timeout=1000,
cleanup=None)
LOG.info("Checking all VMs are in active state")
vms = system_test_helper.get_all_vms()
vm_helper.wait_for_vms_values(vms=vms, fail_ok=False)
def revert_https(request):
central_auth = Tenant.get('admin_platform', dc_region='RegionOne')
sub_auth = Tenant.get('admin_platform')
origin_https_sub = keystone_helper.is_https_enabled(auth_info=sub_auth)
origin_https_central = keystone_helper.is_https_enabled(
auth_info=central_auth)
def _revert():
LOG.fixture_step(
"Revert central https config to {}.".format(origin_https_central))
security_helper.modify_https(enable_https=origin_https_central,
auth_info=central_auth)
LOG.fixture_step(
"Revert subcloud https config to {}.".format(origin_https_sub))
security_helper.modify_https(enable_https=origin_https_central,
auth_info=sub_auth)
LOG.fixture_step("Verify cli's on subcloud and central region.".format(
origin_https_sub))
verify_cli(sub_auth, central_auth)
request.addfinalizer(_revert)
return origin_https_sub, origin_https_central, central_auth, sub_auth
def revert_https(request):
"""
Fixture for get the current http mode of the system, and if the test fails,
leave the system in the same mode than before
"""
central_auth = Tenant.get('admin_platform', dc_region='RegionOne')
sub_auth = Tenant.get('admin_platform')
use_dnsname = (bool(common.get_dnsname()) and
bool(common.get_dnsname(region=ProjVar.get_var('PRIMARY_SUBCLOUD'))))
origin_https_sub = keystone_helper.is_https_enabled(auth_info=sub_auth)
origin_https_central = keystone_helper.is_https_enabled(auth_info=central_auth)
def _revert():
LOG.fixture_step("Revert central https config to {}.".format(origin_https_central))
security_helper.modify_https(enable_https=origin_https_central, auth_info=central_auth)
LOG.fixture_step("Revert subcloud https config to {}.".format(origin_https_sub))
security_helper.modify_https(enable_https=origin_https_central, auth_info=sub_auth)
LOG.fixture_step("Verify cli's on subcloud and central region.".format(origin_https_sub))
verify_cli(sub_auth, central_auth)
request.addfinalizer(_revert)
return origin_https_sub, origin_https_central, central_auth, sub_auth, use_dnsname
def _modify_firewall_rules(firewall_rules_path):
"""
:param firewall_rules_path: Path to the firewalls rules file (including the file name)
"""
dc_region = 'RegionOne' if ProjVar.get_var('IS_DC') else None
ssh_client = ControllerClient.get_active_controller(name=dc_region)
LOG.info("Install firewall rules: {}".format(firewall_rules_path))
auth_info = Tenant.get('admin_platform', dc_region=dc_region)
start_time = common.get_date_in_format(ssh_client=ssh_client)
time.sleep(1)
cli.system('firewall-rules-install',
firewall_rules_path,
ssh_client=ssh_client,
auth_info=auth_info)
def _wait_for_config_apply(auth_info_, con_ssh_=None):
controllers = system_helper.get_controllers(auth_info=auth_info_,
con_ssh=con_ssh_)
for controller in controllers:
system_helper.wait_for_events(
start=start_time,
fail_ok=False,
timeout=60,
entity_instance_id='host=controller',
event_log_id=EventLogID.CONFIG_OUT_OF_DATE,
auth_info=auth_info_,
con_ssh=con_ssh_,
**{
'Entity Instance ID': 'host={}'.format(controller),
'State': 'set'
})
# Extend timeout for controller-1 config-out-date clear to 5min due to CGTS-8497
system_helper.wait_for_events(
start=start_time,
fail_ok=False,
timeout=300,
entity_instance_id='host=controller',
event_log_id=EventLogID.CONFIG_OUT_OF_DATE,
auth_info=auth_info_,
con_ssh=con_ssh_,
**{
'Entity Instance ID': 'host={}'.format(controller),
'State': 'clear'
})
LOG.info("Wait for config to apply on both controllers")
_wait_for_config_apply(auth_info_=auth_info, con_ssh_=ssh_client)
if ProjVar.get_var('IS_DC'):
subcloud = ProjVar.get_var('PRIMARY_SUBCLOUD')
LOG.info(
"Wait for sync audit for {} in dcmanager.log".format(subcloud))
dc_helper.wait_for_sync_audit(subclouds=subcloud)
LOG.info("Wait for config apply on {}".format(subcloud))
_wait_for_config_apply(auth_info_=Tenant.get('admin_platform'))
# Ensures iptables has enough time to populate the list with new ports
time.sleep(10)
def launch_lab_setup_tenants_vms():
home_dir = HostLinuxUser.get_home()
stack1 = "{}/lab_setup-tenant1-resources.yaml".format(home_dir)
stack1_name = "lab_setup-tenant1-resources"
stack2 = "{}/lab_setup-tenant2-resources.yaml".format(home_dir)
stack2_name = "lab_setup-tenant2-resources"
script_name = "{}/create_resource_stacks.sh".format(home_dir)
con_ssh = ControllerClient.get_active_controller()
if con_ssh.file_exists(file_path=script_name):
cmd1 = 'chmod 755 ' + script_name
con_ssh.exec_cmd(cmd1)
con_ssh.exec_cmd(script_name, fail_ok=False)
stack_id_t1 = heat_helper.get_stacks(name=stack1_name,
auth_info=Tenant.get('tenant1'))
# may be better to delete all tenant stacks if any
if not stack_id_t1:
heat_helper.create_stack(stack_name=stack1_name,
template=stack1,
auth_info=Tenant.get('tenant1'),
timeout=1000,
cleanup=None)
stack_id_t2 = heat_helper.get_stacks(name=stack2_name,
auth_info=Tenant.get('tenant2'))
if not stack_id_t2:
heat_helper.create_stack(stack_name=stack2_name,
template=stack2,
auth_info=Tenant.get('tenant2'),
timeout=1000,
cleanup=None)
LOG.info("Checking all VMs are in active state")
vms = get_all_vms()
vm_helper.wait_for_vms_values(vms=vms, fail_ok=False)
def list_status():
LOG.fixture_step("Listing heat resources and nova migrations")
stacks = heat_helper.get_stacks(auth_info=Tenant.get('admin'))
for stack in stacks:
heat_helper.get_stack_resources(stack=stack, auth_info=Tenant.get('admin'))
nova_helper.get_migration_list_table()
def test_non_primary_tenant():
vm_1 = vm_helper.boot_vm(cleanup='function',
auth_info=Tenant.get('tenant1'))[1]
vm_2 = vm_helper.launch_vms(vm_type='dpdk',
auth_info=Tenant.get('tenant1'))[0][0]
vm_helper.wait_for_vm_pingable_from_natbox(vm_id=vm_1)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id=vm_2)
vm_helper.ping_vms_from_natbox(vm_ids=vm_2)
vm_helper.ping_vms_from_vm(vm_2, vm_1, net_types='mgmt')
def list_status():
LOG.fixture_step("Listing heat resources and nova migrations")
stacks = heat_helper.get_stacks(auth_info=Tenant.get('admin'))
for stack in stacks:
heat_helper.get_stack_resources(stack=stack,
auth_info=Tenant.get('admin'))
# stack_id = heat_helper.get_stacks(name=HeatTemplate.SYSTEM_TEST_HEAT_NAME)
#
# # if stack_id:
# # code, msg = heat_helper.delete_stack(stack_name=HeatTemplate.SYSTEM_TEST_HEAT_NAME)
nova_helper.get_migration_list_table()
def pcipt_prep(self, request, pci_prep):
primary_tenant, primary_tenant_name, other_tenant = pci_prep
vif_model = 'pci-passthrough'
net_type, pci_net_name, pci_net_id, pnet_id, pnet_name, other_pcipt_net_name, other_pcipt_net_id = \
get_pci_net(request, vif_model, primary_tenant, primary_tenant_name, other_tenant)
pci_hosts = get_pci_hosts(vif_model, pnet_name)
if len(pci_hosts) < 2:
skip('Less than 2 hosts with {} interface configured'.format(
vif_model))
# TODO: feature unavailable atm. Update required
# pfs_conf, pfs_use_init = nova_helper.get_pci_interface_stats_for_providernet(
# pnet_id, fields=('pci_pfs_configured', 'pci_pfs_used'))
# if pfs_conf < 2:
# skip('Less than 2 {} interfaces configured on system'.format(vif_model))
pfs_use_init = None
# Get initial host with least vcpus
LOG.fixture_step(
"Calculate number of vms and number of vcpus for each vm")
vm_num = 2
min_vcpu_host, min_cores_per_proc = get_host_with_min_vm_cores_per_proc(
pci_hosts)
vm_vcpus = int(min_cores_per_proc / (vm_num / 2))
LOG.fixture_step(
"Get seg_id for {} for vlan tagging on pci-passthough device later"
.format(pci_net_id))
seg_id = network_helper.get_network_values(
network=pci_net_id,
fields='segmentation_id',
strict=False,
auth_info=Tenant.get('admin'))[0]
assert seg_id, 'Segmentation id of pci net {} is not found'.format(
pci_net_id)
if other_pcipt_net_name:
extra_pcipt_seg_id = network_helper.get_network_values(
network=other_pcipt_net_name,
fields='segmentation_id',
strict=False,
auth_info=Tenant.get('admin'))[0]
seg_id = {
pci_net_name: seg_id,
other_pcipt_net_name: extra_pcipt_seg_id
}
nics = get_pci_vm_nics(vif_model, pci_net_id, other_pcipt_net_id)
return net_type, pci_net_name, pci_hosts, pnet_id, nics, min_vcpu_host, seg_id, vm_num, vm_vcpus, pfs_use_init
def test_admin_password(scenario, less_than_two_cons, _revert_admin_pw):
"""
Test the admin password change
Test Steps:
- lock standby controller change password and unlock
- change passowrd and swact
- check alarams
"""
if 'swact' in scenario and less_than_two_cons:
skip(SkipSysType.LESS_THAN_TWO_CONTROLLERS)
host = system_helper.get_standby_controller_name()
assert host, "No standby controller on system"
if scenario == "lock_standby_change_pswd":
# lock the standby
LOG.tc_step("Attempting to lock {}".format(host))
res, out = host_helper.lock_host(host=host)
LOG.tc_step("Result of the lock was: {}".format(res))
# change password
prev_pswd = Tenant.get('admin')['password']
post_pswd = '!{}9'.format(prev_pswd)
LOG.tc_step('Changing admin password to {}'.format(post_pswd))
code, output = keystone_helper.set_user('admin', password=post_pswd, auth_info=Tenant.get(
'admin_platform'))
# assert "Warning: 'admin' password changed. Please wait 5 minutes before Locking/Unlocking
# the controllers" in output
LOG.tc_step("Sleep for 180 seconds after admin password change")
time.sleep(180) # CGTS-6928
LOG.tc_step("Check admin password is updated in keyring")
assert post_pswd == security_helper.get_admin_password_in_keyring()
if scenario == "change_pswd_swact":
LOG.tc_step("Swact active controller")
host_helper.swact_host()
else:
LOG.tc_step("Unlock host {}".format(host))
res = host_helper.unlock_host(host)
LOG.info("Unlock hosts result: {}".format(res))
LOG.tc_step("Check admin password is updated in keyring")
assert post_pswd == security_helper.get_admin_password_in_keyring()
def app_upload_apply(con_ssh=None, auth_info=Tenant.get('admin_platform')):
"""
Upload stx-monitor
Apply stx-monitor
"""
# Do application upload stx-monitor.
app_dir = HostLinuxUser.get_home()
tar_file = os.path.join(app_dir, STX_MONITOR_TAR)
LOG.info("Upload %s" % tar_file)
container_helper.upload_app(
tar_file=tar_file,
app_name=STX_MONITOR_APP_NAME,
con_ssh=con_ssh,
auth_info=auth_info,
uploaded_timeout=3600,
)
# Do application apply stx-monitor.
LOG.info("Apply %s" % STX_MONITOR_APP_NAME)
container_helper.apply_app(app_name=STX_MONITOR_APP_NAME,
applied_timeout=3600,
check_interval=60,
con_ssh=con_ssh,
auth_info=auth_info)
def get_flavor_values(flavor,
fields,
strict=True,
con_ssh=None,
auth_info=Tenant.get('admin')):
"""
Get flavor values for given fields via openstack flavor show
Args:
flavor (str):
fields (str|list|tuple):
strict (bool): strict search for field name or not
con_ssh:
auth_info:
Returns (list):
"""
table_ = table_parser.table(
cli.openstack('flavor show',
flavor,
ssh_client=con_ssh,
auth_info=auth_info)[1])
return table_parser.get_multi_values_two_col_table(
table_,
fields,
merge_lines=True,
evaluate=True,
strict=strict,
dict_fields=('properties', ))
def get_aggregate_values(aggregate,
fields,
con_ssh=None,
auth_info=Tenant.get('admin'),
fail_ok=False):
"""
Get values of a nova aggregate for given fields
Args:
aggregate (str):
fields (str|list|tuple):
con_ssh:
auth_info (dict):
fail_ok (bool)
Returns (list):
"""
code, out = cli.openstack('aggregate show',
aggregate,
ssh_client=con_ssh,
auth_info=auth_info,
fail_ok=fail_ok)
if code > 0:
return []
table_ = table_parser.table(out)
return table_parser.get_multi_values_two_col_table(
table_, fields, evaluate=True, dict_fields=('properties', ))
def get_provider_net_info(providernet_id,
field='pci_pfs_configured',
strict=True,
auth_info=Tenant.get('admin'),
con_ssh=None,
rtn_int=True):
"""
Get provider net info from "nova providernet-show"
Args:
providernet_id (str): id of a providernet
field (str): Field name such as pci_vfs_configured, pci_pfs_used, etc
strict (bool): whether to perform a strict search on field name
auth_info (dict):
con_ssh (SSHClient):
rtn_int (bool): whether to return integer or string
Returns (int|str): value of specified field. Convert to integer by default unless rnt_int=False.
"""
if not providernet_id:
raise ValueError("Providernet id is not provided.")
table_ = table_parser.table(
cli.nova('providernet-show',
providernet_id,
ssh_client=con_ssh,
auth_info=auth_info)[1])
info_str = table_parser.get_value_two_col_table(table_,
field,
strict=strict)
return int(info_str) if rtn_int else info_str
def revert():
reverted = False
try:
LOG.fixture_step("Manage primary subcloud {} if unmanaged".format(primary_subcloud))
dc_helper.manage_subcloud(primary_subcloud)
LOG.fixture_step("Revert NTP config if changed")
res = system_helper.modify_ntp(ntp_servers=central_ntp, auth_info=central_auth, check_first=True,
clear_alarm=False)[0]
if res != -1:
LOG.fixture_step("Lock unlock config out-of-date hosts in central region")
system_helper.wait_and_clear_config_out_of_date_alarms(auth_info=central_auth,
wait_with_best_effort=True)
LOG.fixture_step("Lock unlock config out-of-date hosts in {}".format(primary_subcloud))
dc_helper.wait_for_subcloud_ntp_config(subcloud=primary_subcloud, expected_ntp=central_ntp,
clear_alarm=True)
if managed_subcloud:
LOG.fixture_step("Lock unlock config out-of-date hosts in {}".format(managed_subcloud))
dc_helper.wait_for_subcloud_ntp_config(subcloud=managed_subcloud, expected_ntp=central_ntp,
clear_alarm=True)
if subclouds_to_revert:
LOG.fixture_step("Manage unmanaged subclouds and check they are unaffected")
for subcloud in subclouds_to_revert:
dc_helper.manage_subcloud(subcloud)
assert not system_helper.get_alarms(alarm_id=EventLogID.CONFIG_OUT_OF_DATE,
auth_info=Tenant.get('admin_platform', dc_region=subcloud))
reverted = True
finally:
if not reverted:
for subcloud in subclouds_to_revert:
dc_helper.manage_subcloud(subcloud)
def get_helm_overrides(field='overrides namespaces',
app_name='stx-openstack',
charts=None,
auth_info=Tenant.get('admin_platform'),
con_ssh=None):
"""
Get helm overrides values via system helm-override-list
Args:
field (str):
app_name
charts (None|str|list|tuple):
auth_info:
con_ssh:
Returns (list):
"""
table_ = table_parser.table(
cli.system('helm-override-list',
app_name,
ssh_client=con_ssh,
auth_info=auth_info)[1])
if charts:
table_ = table_parser.filter_table(table_, **{'chart name': charts})
vals = table_parser.get_multi_values(table_, fields=field, evaluate=True)
return vals
def get_alarms(header='alarm_id',
name=None,
strict=False,
auth_info=Tenant.get('admin'),
con_ssh=None):
"""
Args:
header
name:
strict:
auth_info:
con_ssh:
Returns:
"""
table_ = table_parser.table(cli.openstack('alarm list',
ssh_client=con_ssh,
auth_info=auth_info)[1],
combine_multiline_entry=True)
if name is None:
return table_parser.get_column(table_, header)
return table_parser.get_values(table_, header, Name=name, strict=strict)
def get_pci_interface_stats_for_providernet(
providernet_id,
fields=('pci_pfs_configured', 'pci_pfs_used', 'pci_vfs_configured',
'pci_vfs_used'),
auth_info=Tenant.get('admin'),
con_ssh=None):
"""
get pci interface usage
Args:
providernet_id (str): id of a providernet
fields: fields such as ('pci_vfs_configured', 'pci_pfs_used')
auth_info (dict):
con_ssh (SSHClient):
Returns (tuple): tuple of integers
"""
if not providernet_id:
raise ValueError("Providernet id is not provided.")
table_ = table_parser.table(
cli.nova('providernet-show',
providernet_id,
ssh_client=con_ssh,
auth_info=auth_info)[1])
rtn_vals = []
for field in fields:
pci_stat = int(
table_parser.get_value_two_col_table(table_, field, strict=True))
rtn_vals.append(pci_stat)
return tuple(rtn_vals)
def is_https_enabled(con_ssh=None, source_openrc=True, interface='public',
auth_info=Tenant.get('admin_platform')):
"""
Check whether interface is https
Args:
con_ssh:
source_openrc:
interface: default is public
auth_info:
Returns True or False
"""
if not con_ssh:
con_name = auth_info.get('region') if (
auth_info and ProjVar.get_var('IS_DC')) else None
con_ssh = ControllerClient.get_active_controller(name=con_name)
table_ = table_parser.table(
cli.openstack('endpoint list', ssh_client=con_ssh, auth_info=auth_info,
source_openrc=source_openrc)[1])
con_ssh.exec_cmd('unset OS_REGION_NAME') # Workaround
filters = {'Service Name': 'keystone', 'Service Type': 'identity',
'Interface': interface}
keystone_values = table_parser.get_values(table_=table_, target_header='URL',
**filters)
LOG.info('keystone {} URLs: {}'.format(interface, keystone_values))
return all('https' in i for i in keystone_values)
def subclouds_to_test(request):
LOG.info("Gather DNS config and subcloud management info")
sc_auth = Tenant.get('admin_platform', dc_region='SystemController')
dns_servers = system_helper.get_dns_servers(auth_info=sc_auth)
subcloud = ProjVar.get_var('PRIMARY_SUBCLOUD')
def revert():
LOG.fixture_step("Manage {} if unmanaged".format(subcloud))
dc_helper.manage_subcloud(subcloud)
LOG.fixture_step("Revert DNS config if changed")
system_helper.set_dns_servers(nameservers=dns_servers,
auth_info=sc_auth)
request.addfinalizer(revert)
managed_subclouds = dc_helper.get_subclouds(mgmt='managed', avail='online')
if subcloud in managed_subclouds:
managed_subclouds.remove(subcloud)
ssh_map = ControllerClient.get_active_controllers_map()
managed_subclouds = [
subcloud for subcloud in managed_subclouds if subcloud in ssh_map
]
return subcloud, managed_subclouds
def get_apps(field='status',
application=None,
con_ssh=None,
auth_info=Tenant.get('admin_platform'),
rtn_dict=False,
**kwargs):
"""
Get applications values for give apps and fields via system application-list
Args:
application (str|list|tuple):
field (str|list|tuple):
con_ssh:
auth_info:
rtn_dict:
**kwargs: extra filters other than application
Returns (list|dict):
list of list, or
dict with app name(str) as key and values(list) for given fields for
each app as value
"""
table_ = table_parser.table(
cli.system('application-list', ssh_client=con_ssh,
auth_info=auth_info)[1])
if application:
kwargs['application'] = application
return table_parser.get_multi_values(table_,
fields=field,
rtn_dict=rtn_dict,
zip_values=True,
**kwargs)
def verify_user(user_name,
password,
is_admin=True,
expect_fail=False,
keystone=None):
scenario = ' and expect failure' if expect_fail else ''
LOG.info('Run {} OpenStack command with {} role {}'.format(
keystone, 'admin' if is_admin else 'member', scenario))
dict_name = '{}_platform'.format(
user_name) if keystone == 'platform' else user_name
auth_info = Tenant.get(dict_name)
auth_info = copy.deepcopy(auth_info)
auth_info['password'] = password
if is_admin:
command = 'endpoint list'
code, output = cli.openstack(command,
fail_ok=expect_fail,
auth_info=auth_info)
else:
command = 'user show {}'.format(user_name)
code, output = cli.openstack(command,
fail_ok=expect_fail,
auth_info=auth_info)
message = 'command:{}\nauth_info:{}\noutput:{}'.format(
command, auth_info, output)
if expect_fail:
assert 1 == code, "OpenStack command ran successfully while rejection is " \
"expected: {}".format(message)
def get_app_values(app_name,
fields,
con_ssh=None,
auth_info=Tenant.get('admin_platform')):
"""
Get values from system application-show
Args:
app_name:
fields (str|list|tuple):
con_ssh:
auth_info:
Returns:
"""
if isinstance(fields, str):
fields = [fields]
table_ = table_parser.table(cli.system('application-show',
app_name,
ssh_client=con_ssh,
auth_info=auth_info)[1],
combine_multiline_entry=True)
values = table_parser.get_multi_values_two_col_table(table_, fields=fields)
return values
def test_dc_dns_modify(ensure_synced, scenario):
"""
Update DNS servers on central region and check it is propagated to subclouds
Args:
ensure_synced: test fixture
scenario: DNS change scenario
Setups:
- Ensure primary subcloud is managed and DNS config is valid and synced
Test Steps:
- Un-manage primary subcloud
- Configure DNS servers on central region to new value based on given scenario
- Wait for new DNS config to sync over to managed online subclouds
- Ensure DNS config is not updated on unmanaged primary subcloud
- Re-manage primary subcloud and ensure DNS config syncs over
- Verify nslookup works in Central Region and primary subcloud
Teardown:
- Reset DNS servers to original value (module)
"""
primary_subcloud, managed_subclouds, prev_dns_servers = ensure_synced
new_dns_servers = compose_new_dns_servers(
scenario=scenario, prev_dns_servers=prev_dns_servers)
LOG.tc_step("Unmanage {}".format(primary_subcloud))
dc_helper.unmanage_subcloud(subcloud=primary_subcloud, check_first=True)
LOG.tc_step(
"Reconfigure DNS servers on central region from {} to {}".format(
prev_dns_servers, new_dns_servers))
system_helper.set_dns_servers(new_dns_servers,
auth_info=Tenant.get('admin_platform',
dc_region='RegionOne'))
LOG.tc_step(
"Wait for new DNS config to sync over to managed online subclouds")
for managed_sub in managed_subclouds:
dc_helper.wait_for_subcloud_dns_config(subcloud=managed_sub,
expected_dns=new_dns_servers)
LOG.tc_step(
"Ensure DNS config is not updated on unmanaged subcloud: {}".format(
primary_subcloud))
code = dc_helper.wait_for_subcloud_dns_config(subcloud=primary_subcloud,
expected_dns=new_dns_servers,
timeout=60,
fail_ok=True)[0]
assert 1 == code, "Actual return code: {}".format(code)
LOG.tc_step('Re-manage {} and ensure DNS config syncs over'.format(
primary_subcloud))
dc_helper.manage_subcloud(subcloud=primary_subcloud, check_first=False)
dc_helper.wait_for_subcloud_dns_config(subcloud=primary_subcloud,
expected_dns=new_dns_servers)
LOG.tc_step('Verify nslookup works in Central Region and {}'.format(
primary_subcloud))
verify_dns_on_central_and_subcloud(primary_subcloud)
def get_aggregated_measures(field='value', resource_type=None, metrics=None,
start=None, stop=None, overlap=None,
refresh=None, resource_ids=None, extra_query=None,
fail_ok=False, auth_info=Tenant.get('admin'),
con_ssh=None):
"""
Get measurements via 'openstack metric measures aggregation'
Args:
field (str): header of a column
resource_type (str|None): used in --resource-type <resource_type>
metrics (str|list|tuple|None): used in --metric <metric1> [metric2 ...]
start (str|None): used in --start <start>
stop (str|None): used in --stop <stop>
refresh (bool): used in --refresh
overlap (str|None): overlap percentage. used in
--needed-overlap <overlap>
resource_ids (str|list|tuple|None): used in --query "id=<resource_id1>[
or id=<resource_id2> ...]"
extra_query (str|None): used in --query <extra_query>
fail_ok:
auth_info:
con_ssh:
Returns (list): list of strings
"""
LOG.info("Getting aggregated measurements...")
args_dict = {
'resource-type': resource_type,
'metric': metrics,
'start': start,
'stop': stop,
'needed-overlap': overlap,
'refresh': refresh,
}
args = common.parse_args(args_dict, vals_sep=' ')
query_str = ''
if resource_ids:
if isinstance(resource_ids, str):
resource_ids = [resource_ids]
resource_ids = ['id={}'.format(val) for val in resource_ids]
query_str = ' or '.join(resource_ids)
if extra_query:
if resource_ids:
query_str += ' and '
query_str += '{}'.format(extra_query)
if query_str:
args += ' --query "{}"'.format(query_str)
code, out = cli.openstack('metric measures aggregation', args,
ssh_client=con_ssh, fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, out
table_ = table_parser.table(out)
return 0, table_parser.get_values(table_, field)
def get_subcloud_status(subcloud,
field='availability',
auth_info=Tenant.get('admin_platform', 'RegionOne'),
con_ssh=None,
source_openrc=None):
"""
Args:
subcloud:
field:
auth_info:
con_ssh:
source_openrc:
Returns:
"""
LOG.info("Auth_info: {}".format(auth_info))
table_ = table_parser.table(
cli.dcmanager('subcloud list',
ssh_client=con_ssh,
auth_info=auth_info,
source_openrc=source_openrc)[1])
arg_dict = {'name': subcloud}
kwargs = {key: val for key, val in arg_dict.items() if val is not None}
status = table_parser.get_values(table_, target_header=field, **kwargs)
return status[0]
def get_metric_values(metric_id=None, metric_name=None, resource_id=None, fields='id', fail_ok=False,
auth_info=Tenant.get('admin'), con_ssh=None):
"""
Get metric info via 'openstack metric show'
Args:
metric_id (str|None):
metric_name (str|None): Only used if metric_id is not provided
resource_id (str|None): Only used if metric_id is not provided
fields (str|list|tuple): field name
fail_ok (bool):
auth_info:
con_ssh:
Returns (list):
"""
if metric_id is None and metric_name is None:
raise ValueError("metric_id or metric_name has to be provided.")
if metric_id:
arg = metric_id
else:
if resource_id:
arg = '--resource-id {} "{}"'.format(resource_id, metric_name)
else:
if not fail_ok:
raise ValueError("resource_id needs to be provided when using metric_name")
arg = '"{}"'.format(metric_name)
code, output = cli.openstack('openstack metric show', arg, ssh_client=con_ssh, fail_ok=fail_ok, auth_info=auth_info)
if code > 0:
return output
table_ = table_parser.table(output)
return table_parser.get_multi_values_two_col_table(table_, fields)
def is_stx_openstack_deployed(applied_only=False,
con_ssh=None,
auth_info=Tenant.get('admin_platform'),
force_check=False):
"""
Whether stx-openstack application is deployed.
Args:
applied_only (bool): if True, then only return True when application
is in applied state
con_ssh:
auth_info:
force_check:
Returns (bool):
"""
openstack_deployed = ProjVar.get_var('OPENSTACK_DEPLOYED')
if not applied_only and not force_check and openstack_deployed is not None:
return openstack_deployed
openstack_status = get_apps(application='stx-openstack',
field='status',
con_ssh=con_ssh,
auth_info=auth_info)
LOG.info("{}".format(openstack_status))
res = False
if openstack_status and 'appl' in openstack_status[0].lower():
res = True
if applied_only and openstack_status[0] != AppStatus.APPLIED:
res = False
return res
