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