def set_user(user, name=None, project=None, password=None, project_doamin=None,
email=None, description=None,
enable=None, fail_ok=False, auth_info=Tenant.get('admin'),
con_ssh=None):
LOG.info("Updating {}...".format(user))
arg = ''
optional_args = {
'name': name,
'project': project,
'password': password,
'project-domain': project_doamin,
'email': email,
'description': description,
}
for key, val in optional_args.items():
if val is not None:
arg += "--{} '{}' ".format(key, val)
if enable is not None:
arg += '--{} '.format('enable' if enable else 'disable')
if not arg.strip():
raise ValueError(
"Please specify the param(s) and value(s) to change to")
arg += user
code, output = cli.openstack('user set', arg, ssh_client=con_ssh, timeout=120,
fail_ok=fail_ok, auth_info=auth_info)
if code > 0:
return 1, output
if name or project or password:
tenant_dictname = user
if auth_info and auth_info.get('platform'):
tenant_dictname += '_platform'
Tenant.update(tenant_dictname, username=name, password=password,
tenant=project)
if password and user == 'admin':
from consts.proj_vars import ProjVar
if ProjVar.get_var('REGION') != 'RegionOne':
LOG.info(
"Run openstack_update_admin_password on secondary region "
"after admin password change")
if not con_ssh:
con_ssh = ControllerClient.get_active_controller()
with con_ssh.login_as_root(timeout=30) as con_ssh:
con_ssh.exec_cmd(
"echo 'y' | openstack_update_admin_password '{}'".format(
password))
msg = 'User {} updated successfully'.format(user)
LOG.info(msg)
return 0, output
def set_current_user_password(original_password, new_password, fail_ok=False,
auth_info=None, con_ssh=None):
"""
Set password for current user
Args:
original_password:
new_password:
fail_ok:
auth_info:
con_ssh:
Returns (tuple):
"""
args = "--password '{}' --original-password '{}'".format(new_password, original_password)
code, output = cli.openstack('user password set', args, ssh_client=con_ssh,
auth_info=auth_info, fail_ok=fail_ok)
if code > 0:
return 1, output
if not auth_info:
auth_info = Tenant.get_primary()
user = auth_info['user']
tenant_dictname = user
if auth_info.get('platform'):
tenant_dictname += '_platform'
Tenant.update(tenant_dictname, password=new_password)
if user == 'admin':
from consts.proj_vars import ProjVar
if ProjVar.get_var('REGION') != 'RegionOne':
LOG.info(
"Run openstack_update_admin_password on secondary region "
"after admin password change")
if not con_ssh:
con_ssh = ControllerClient.get_active_controller()
with con_ssh.login_as_root(timeout=30) as con_ssh:
con_ssh.exec_cmd(
"echo 'y' | openstack_update_admin_password '{}'".format(new_password))
msg = 'User {} password successfully updated from {} to {}'.format(user, original_password,
new_password)
LOG.info(msg)
return 0, output
def setup_testcase_config(testcase_config, lab=None, natbox=None):
fip_error = 'A valid IPv4 OAM floating IP has to be specified via ' \
'cmdline option --lab=<oam_floating_ip>, ' \
'or testcase config file has to be provided via ' \
'--testcase-config with oam_floating_ip ' \
'specified under auth_platform section.'
if not testcase_config:
if not lab:
raise ValueError(fip_error)
return lab, natbox
testcase_config = os.path.expanduser(testcase_config)
auth_section = 'auth'
guest_image_section = 'guest_image'
guest_networks_section = 'guest_networks'
guest_keypair_section = 'guest_keypair'
natbox_section = 'natbox'
config = configparser.ConfigParser()
config.read(testcase_config)
#
# Update global variables for auth section
#
# Update OAM floating IP
if lab:
fip = lab.get('floating ip')
config.set(auth_section, 'oam_floating_ip', fip)
else:
fip = config.get(auth_section, 'oam_floating_ip', fallback='').strip()
lab = get_lab_dict(fip)
if __get_ip_version(fip) != 4:
raise ValueError(fip_error)
# controller-0 oam ip is updated with best effort if a valid IPv4 IP is
# provided
if not lab.get('controller-0 ip') and config.get(
auth_section, 'controller0_oam_ip', fallback='').strip():
con0_ip = config.get(auth_section, 'controller0_oam_ip').strip()
if __get_ip_version(con0_ip) == 4:
lab['controller-0 ip'] = con0_ip
else:
LOG.info(
"controller0_oam_ip specified in testcase config file is not "
"a valid IPv4 address. Ignore.")
# Update linux user credentials
if config.get(auth_section, 'linux_username', fallback='').strip():
HostLinuxUser.set_user(
config.get(auth_section, 'linux_username').strip())
if config.get(auth_section, 'linux_user_password', fallback='').strip():
HostLinuxUser.set_password(
config.get(auth_section, 'linux_user_password').strip())
# Update openstack keystone user credentials
auth_dict_map = {
'platform_admin': 'admin_platform',
'admin': 'admin',
'test1': 'tenant1',
'test2': 'tenant2',
}
for conf_prefix, dict_name in auth_dict_map.items():
kwargs = {}
default_auth = Tenant.get(dict_name)
conf_user = config.get(auth_section,
'{}_username'.format(conf_prefix),
fallback='').strip()
conf_password = config.get(auth_section,
'{}_password'.format(conf_prefix),
fallback='').strip()
conf_project = config.get(auth_section,
'{}_project_name'.format(conf_prefix),
fallback='').strip()
conf_domain = config.get(auth_section,
'{}_domain_name'.format(conf_prefix),
fallback='').strip()
conf_keypair = config.get(auth_section,
'{}_nova_keypair'.format(conf_prefix),
fallback='').strip()
if conf_user and conf_user != default_auth.get('user'):
kwargs['username'] = conf_user
if conf_password and conf_password != default_auth.get('password'):
kwargs['password'] = conf_password
if conf_project and conf_project != default_auth.get('tenant'):
kwargs['tenant'] = conf_project
if conf_domain and conf_domain != default_auth.get('domain'):
kwargs['domain'] = conf_domain
if conf_keypair and conf_keypair != default_auth.get('nova_keypair'):
kwargs['nova_keypair'] = conf_keypair
if kwargs:
Tenant.update(dict_name, **kwargs)
#
# Update global variables for natbox section
#
natbox_host = config.get(natbox_section, 'natbox_host',
fallback='').strip()
natbox_user = config.get(natbox_section, 'natbox_user',
fallback='').strip()
natbox_password = config.get(natbox_section,
'natbox_password',
fallback='').strip()
natbox_prompt = config.get(natbox_section, 'natbox_prompt',
fallback='').strip()
if natbox_host and (not natbox or natbox_host != natbox['ip']):
natbox = get_natbox_dict(natbox_host,
user=natbox_user,
password=natbox_password,
prompt=natbox_prompt)
#
# Update global variables for guest_image section
#
img_file_dir = config.get(guest_image_section, 'img_file_dir',
fallback='').strip()
glance_image_name = config.get(guest_image_section,
'glance_image_name',
fallback='').strip()
img_file_name = config.get(guest_image_section,
'img_file_name',
fallback='').strip()
img_disk_format = config.get(guest_image_section,
'img_disk_format',
fallback='').strip()
min_disk_size = config.get(guest_image_section,
'min_disk_size',
fallback='').strip()
img_container_format = config.get(guest_image_section,
'img_container_format',
fallback='').strip()
image_ssh_user = config.get(guest_image_section,
'image_ssh_user',
fallback='').strip()
image_ssh_password = config.get(guest_image_section,
'image_ssh_password',
fallback='').strip()
if img_file_dir and img_file_dir != GuestImages.DEFAULT['image_dir']:
# Update default image file directory
img_file_dir = os.path.expanduser(img_file_dir)
if not os.path.isabs(img_file_dir):
raise ValueError(
"Please provide a valid absolute path for img_file_dir "
"under guest_image section in testcase config file")
GuestImages.DEFAULT['image_dir'] = img_file_dir
if glance_image_name and glance_image_name != GuestImages.DEFAULT['guest']:
# Update default glance image name
GuestImages.DEFAULT['guest'] = glance_image_name
if glance_image_name not in GuestImages.IMAGE_FILES:
# Add guest image info to consts.stx.GuestImages
if not (img_file_name and img_disk_format and min_disk_size):
raise ValueError(
"img_file_name and img_disk_format under guest_image "
"section have to be "
"specified in testcase config file")
img_container_format = img_container_format if \
img_container_format else 'bare'
GuestImages.IMAGE_FILES[glance_image_name] = \
(None, min_disk_size, img_file_name, img_disk_format,
img_container_format)
# Add guest login credentials
Guest.CREDS[glance_image_name] = {
'user': image_ssh_user if image_ssh_user else 'root',
'password': image_ssh_password if image_ssh_password else None,
}
#
# Update global variables for guest_keypair section
#
natbox_keypair_dir = config.get(guest_keypair_section,
'natbox_keypair_dir',
fallback='').strip()
private_key_path = config.get(guest_keypair_section,
'private_key_path',
fallback='').strip()
if natbox_keypair_dir:
natbox_keypair_path = os.path.join(
natbox_keypair_dir, 'keyfile_{}.pem'.format(lab['short_name']))
ProjVar.set_var(NATBOX_KEYFILE_PATH=natbox_keypair_path)
if private_key_path:
ProjVar.set_var(STX_KEYFILE_PATH=private_key_path)
#
# Update global variables for guest_networks section
#
net_name_patterns = {
'mgmt':
config.get(guest_networks_section,
'mgmt_net_name_pattern',
fallback='').strip(),
'data':
config.get(guest_networks_section,
'data_net_name_pattern',
fallback='').strip(),
'internal':
config.get(guest_networks_section,
'internal_net_name_pattern',
fallback='').strip(),
'external':
config.get(guest_networks_section,
'external_net_name_pattern',
fallback='').strip()
}
for net_type, net_name_pattern in net_name_patterns.items():
if net_name_pattern:
Networks.set_neutron_net_patterns(
net_type=net_type, net_name_pattern=net_name_pattern)
return lab, natbox
def create_user(name=None, field='name', domain=None, project=None,
project_domain=None, rtn_exist=None,
password=None, email=None,
description=None, enable=None,
auth_info=Tenant.get('admin'), fail_ok=False, con_ssh=None):
"""
Create an openstack user
Args:
name (str|None):
field: name or id
domain:
project (str|None): default project
project_domain:
rtn_exist (bool)
password:
email:
description:
enable:
auth_info:
fail_ok:
con_ssh:
Returns (tuple):
(0, <user>)
(1, <std_err>)
"""
if not password:
password = HostLinuxUser.get_password()
if not name:
name = 'user'
common.get_unique_name(name_str=name)
LOG.info("Create/Show openstack user {}".format(name))
arg_dict = {
'domain': domain,
'project': project,
'project-domain': project_domain,
'password': password,
'email': email,
'description': description,
'enable': True if enable is True else None,
'disable': True if enable is False else None,
'or-show': rtn_exist,
}
arg_str = '{} {}'.format(common.parse_args(args_dict=arg_dict), name)
code, output = cli.openstack('user create', arg_str, ssh_client=con_ssh,
fail_ok=fail_ok, auth_info=auth_info)
if code > 0:
return 1, output
table_ = table_parser.table(output)
username = table_parser.get_value_two_col_table(table_, field='name')
user = username if field == 'name' else table_parser.get_value_two_col_table(table_,
field=field)
is_platform = auth_info and auth_info.get('platform')
keystone = 'platform' if is_platform else 'containerized'
dictname = user + '_platform' if is_platform else user
existing_auth = Tenant.get(dictname)
if existing_auth:
if existing_auth['user'] != username:
raise ValueError('Tenant.{} already exists for a different user {}'.format(
dictname, existing_auth['user']))
Tenant.update(dictname, username=username, password=password, tenant=project,
platform=is_platform)
else:
Tenant.add(username=username, tenantname=project, dictname=dictname, password=password,
platform=is_platform)
LOG.info('Tenant.{} for {} keystone user {} is added'.format(dictname, keystone, user))
LOG.info("{} keystone user {} successfully created/showed".format(keystone, user))
return 0, user
