def test_nova():
LOG.tc_func_start()
ProjVar.set_var(SOURCE_OPENRC=True)
cli.openstack('server list')
cli.openstack('server list', auth_info=None)
ProjVar.set_var(SOURCE_OPENRC=None)
LOG.tc_func_end()
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 test_create_snapshot_using_boot_from_image_vm():
"""
This test creates a snapshot from a VM that is booted from image using
nova image-create. Nova image-create will create a glance image that can
be used to boot a VM.
Assumptions:
* There are so images available on the system
Test Steps:
1. Boot a vm from image
2. Run nova image-create <vm-id> <name> to save a snapshot of a vm in the
form of a glance image
3. Run glance image-download --file <snapshot-img-filename>
<snapshot-img-uuid> to download the snapshot image
4. Delete the downloaded image
5. Boot a VM using the snapshot that was created
Teardown:
1. Delete VMs
2. Delete snapshots in the form a glance image
"""
con_ssh = ControllerClient.get_active_controller()
LOG.tc_step("Boot a VM from image")
vm_id = vm_helper.boot_vm(source="image", cleanup='function')[1]
assert vm_id, "Failed to boot VM"
vm_name = vm_helper.get_vm_name_from_id(vm_id)
snapshot_name = vm_name + "_snapshot"
# nova image-create generates a glance image
LOG.tc_step("Create a snapshot based on that VM")
image_id = vm_helper.create_image_from_vm(vm_id, cleanup='function')[1]
image_filename = '{}/images/temp'.format(HostLinuxUser.get_home())
LOG.tc_step("Download the image snapshot")
glance_cmd = "image save --file {} {}".format(image_filename, image_id)
# Throw exception if glance cmd rejected
cli.openstack(glance_cmd, ssh_client=con_ssh, fail_ok=False)
# Downloading should be good enough for validation. If the file is
# zero-size, download will report failure.
LOG.tc_step("Delete the downloaded image")
con_ssh.exec_cmd("rm {}".format(image_filename), fail_ok=False)
# Second form of validation is to boot a VM from the snapshot
LOG.tc_step("Boot a VM from snapshot")
snapshot_vm = "from_" + snapshot_name
vm_helper.boot_vm(name=snapshot_vm,
source="image",
source_id=image_id,
cleanup='function',
fail_ok=False)
def test_clis():
print(CliAuth.get_var('HTTPS'))
cli.system('host-list')
cli.system('host-show controller-0')
cli.openstack('server list')
cli.openstack('stack list')
ceilometer_helper.get_alarms()
keystone_helper.get_endpoints()
cli.openstack('router list')
cli.openstack('volume list')
cli.openstack('image list')
def delete_bundle(bundle_id, con_ssh=None, auth_info=None, fail_ok=False):
"""
Delete murano bundle
Args:
bundle_id: Bundle id to delete
con_ssh (SSHClient):
auth_info (dict)
fail_ok (bool): whether return False or raise exception when some
services fail to reach enabled-active state
Returns:
code, msg: return code and msg
"""
if bundle_id is None:
raise ValueError("Murano bundle id has to be specified.")
LOG.info("Deleting Murano bundle {}".format(bundle_id))
code, output = cli.openstack('bundle delete',
bundle_id,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
table_ = table_parser.table(output)
pkg_id = table_parser.get_value_two_col_table(table_, 'id')
return 0, pkg_id
def import_package(pkg, con_ssh=None, auth_info=None, fail_ok=False):
"""
Import Murano package
Args:
pkg: package name to import (full path)
con_ssh (SSHClient):
auth_info (dict)
fail_ok (bool): whether return False or raise exception when some
services fail to reach enabled-active state
Returns:
code, msg: return code and msg
"""
if pkg is None:
raise ValueError("Package name has to be specified.")
LOG.info("Importing Murano package {}".format(pkg))
code, output = cli.openstack('package import --exists-action u',
pkg,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
table_ = table_parser.table(output)
pkg_id = table_parser.get_values(table_, 'ID')
return 0, pkg_id
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_flavors(name=None,
memory=None,
disk=None,
ephemeral=None,
swap=None,
vcpu=None,
rxtx=None,
is_public=None,
flv_id=None,
long=False,
con_ssh=None,
auth_info=None,
strict=True,
field='id'):
"""
Get a flavor id with given criteria. If no criteria given, a random flavor will be returned.
Args:
name (str): name of a flavor
memory (int): memory size in MB
disk (int): size of the disk in GB
ephemeral (int): size of ephemeral disk in GB
swap (int): size of swap disk in GB
vcpu (int): number of vcpus
rxtx (str):
is_public (bool):
flv_id (str)
long (bool)
con_ssh (SSHClient):
auth_info (dict):
strict (bool): whether or not to perform strict search on provided values
field (str|list|tuple)
Returns (list):
"""
args = '--long' if long else ''
table_ = table_parser.table(
cli.openstack('flavor list',
args,
ssh_client=con_ssh,
auth_info=auth_info)[1])
req_dict = {
'Name': name,
'RAM': memory,
'Disk': disk,
'Ephemeral': ephemeral,
'Swap': '' if str(swap) == '0' else swap,
'VCPUs': vcpu,
'RXTX Factor': rxtx,
'Is Public': is_public,
'ID': flv_id,
}
final_dict = {k: str(v) for k, v in req_dict.items() if v is not None}
return table_parser.get_multi_values(table_,
field,
strict=strict,
**final_dict)
def create_keypair(name,
public_key=None,
private_key=None,
fail_ok=False,
con_ssh=None,
auth_info=Tenant.get('admin')):
"""
Create a new keypair
Args:
name (str): keypair name to create
public_key (str|None): existing public key file path to use
private_key (str|None): file path to save private key
fail_ok (bool)
con_ssh (SSHClient):
auth_info (dict):
Returns (tuple):
"""
args_dict = {'--public-key': public_key, '--private-key': private_key}
args = '{} "{}"'.format(common.parse_args(args_dict), name)
LOG.info("Creating keypair with args: {}".format(args))
code, out = cli.openstack('keypair create',
args,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, out
LOG.info("Keypair {} created successfully".format(name))
return 0, name
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_aggregates(field='name',
name=None,
avail_zone=None,
con_ssh=None,
auth_info=Tenant.get('admin')):
"""
Get a list of aggregates
Args:
field (str|list|tuple): id or name
name (str|list): filter out the aggregates with given name if specified
avail_zone (str): filter out the aggregates with given availability zone if specified
con_ssh (SSHClient):
auth_info (dict):
Returns (list):
"""
kwargs = {}
if avail_zone:
kwargs['Availability Zone'] = avail_zone
if name:
kwargs['Name'] = name
aggregates_tab = table_parser.table(
cli.openstack('aggregate list',
ssh_client=con_ssh,
auth_info=auth_info)[1])
return table_parser.get_multi_values(aggregates_tab, field, **kwargs)
def get_image_values(image,
fields,
auth_info=Tenant.get('admin'),
con_ssh=None,
fail_ok=False):
"""
Get glance image values from openstack image show
Args:
image:
fields:
auth_info:
con_ssh:
fail_ok
Returns (list):
"""
if isinstance(fields, str):
fields = (fields, )
code, output = cli.openstack('image show',
image,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return [None] * len(fields)
table_ = table_parser.table(output)
values = table_parser.get_multi_values_two_col_table(
table_,
fields,
merge_lines=True,
evaluate=True,
dict_fields='properties')
return values
def get_stacks(name=None, field='id', con_ssh=None, auth_info=None, all_=True):
"""
Get the stacks list based on name if given for a given tenant.
Args:
con_ssh (SSHClient): If None, active controller ssh will be used.
auth_info (dict): Tenant dict. If None, primary tenant will be used.
all_ (bool): whether to display all stacks for admin user
name (str): Given name for the heat stack
field (str|list|tuple)
Returns (list): list of heat stacks.
"""
args = ''
if auth_info is not None:
if auth_info['user'] == 'admin' and all_:
args = '--a'
table_ = table_parser.table(
cli.openstack('stack list',
positional_args=args,
ssh_client=con_ssh,
auth_info=auth_info)[1])
kwargs = {'Stack Name': name} if name else {}
return table_parser.get_multi_values(table_, field, **kwargs)
def get_roles(field='ID',
con_ssh=None,
auth_info=Tenant.get('admin'),
**kwargs):
table_ = table_parser.table(
cli.openstack('role list', ssh_client=con_ssh, auth_info=auth_info)[1])
return table_parser.get_multi_values(table_, field, **kwargs)
def delete_package(package_id, con_ssh=None, auth_info=None, fail_ok=False):
"""
Delete Murano package
Args:
package_id: package id to delete
con_ssh (SSHClient):
auth_info (dict)
fail_ok (bool): whether return False or raise exception when some
services fail to reach enabled-active state
Returns:
code, msg: return code and msg
"""
if package_id is None:
raise ValueError("Murano package name has to be specified.")
LOG.info("Deleting Murano bundle {}".format(package_id))
code, output = cli.openstack('package delete',
package_id,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
return 0, "package {} deleted successfully".format(package_id)
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 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 get_events(event_type, limit=None, header='message_id', con_ssh=None,
auth_info=None, **filters):
"""
Args:
event_type:
limit
header:
con_ssh:
auth_info:
Returns:
"""
args = ''
if limit:
args = '--limit {}'.format(limit)
if event_type or filters:
if event_type:
filters['event_type'] = event_type
extra_args = ['{}={}'.format(k, v) for k, v in filters.items()]
args += ' --filter {}'.format(';'.join(extra_args))
table_ = table_parser.table(cli.openstack('event list', args,
ssh_client=con_ssh,
auth_info=auth_info)[1])
return table_parser.get_values(table_, header)
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_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 delete_env(env_id, con_ssh=None, auth_info=None, fail_ok=False):
"""
Delete Murano Environment
Args:
env_id: Id of the env to create
con_ssh (SSHClient):
auth_info (dict)
fail_ok (bool): whether return False or raise exception when some
services fail to reach enabled-active 12state
Returns:
code, msg: return code and msg
"""
if not env_id:
raise ValueError("Murano env id has to be specified.")
LOG.info("Deleting Murano Environment {}".format(env_id))
code, output = cli.openstack('environment delete',
env_id,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
return 0, "Env {} Deleted Successfully".format(env_id)
def deploy_env(env_id,
session_id,
con_ssh=None,
auth_info=None,
fail_ok=False):
code, output = cli.openstack(
'environment deploy --session-id {} {}'.format(session_id, env_id),
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code == 1:
return 1, output
table_ = table_parser.table(output)
deploy_id = table_parser.get_value_two_col_table(table_, 'id')
if not deploy_id:
msg = "Fail to get the deploy id; session-id {}; environment " \
"id {}".format(session_id, env_id)
if fail_ok:
return 2, msg
else:
raise exceptions.MuranoError(msg)
return 0, deploy_id
def delete_stack(stack,
fail_ok=False,
check_first=False,
con_ssh=None,
auth_info=None):
"""
Delete the given heat stack for a given tenant.
Args:
con_ssh (SSHClient): If None, active controller ssh will be used.
fail_ok (bool):
check_first (bool): whether or not to check the stack existence
before attempt to delete
auth_info (dict): Tenant dict. If None, primary tenant will be used.
stack (str): Given name for the heat stack
Returns (tuple): Status and msg of the heat deletion.
"""
if not stack:
raise ValueError("stack_name is not provided.")
if check_first:
if not get_stack_status(
stack, con_ssh=con_ssh, auth_info=auth_info, fail_ok=True):
msg = "Heat stack {} doesn't exist on the system. Do " \
"nothing.".format(stack)
LOG.info(msg)
return -1, msg
LOG.info("Deleting Heat Stack %s", stack)
exitcode, output = cli.openstack('stack delete -y',
stack,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if exitcode > 1:
LOG.warning("Delete heat stack request rejected.")
return 1, output
if not _wait_for_heat_stack_deleted(stack_name=stack, auth_info=auth_info):
stack_id = get_stack_values(stack=stack,
fields='id',
auth_info=auth_info,
con_ssh=con_ssh)[0]
get_stack_resources(stack=stack_id,
auth_info=auth_info,
con_ssh=con_ssh)
msg = "heat stack {} is not removed after stack-delete.".format(stack)
if fail_ok:
LOG.warning(msg)
return 2, msg
raise exceptions.HeatError(msg)
succ_msg = "Heat stack {} is successfully deleted.".format(stack)
LOG.info(succ_msg)
return 0, succ_msg
def get_role_assignments(field='Role', names=True, role=None, user=None,
project=None, user_domain=None, group=None,
group_domain=None, domain=None, project_domain=None,
inherited=None, effective_only=None,
con_ssh=None, auth_info=Tenant.get('admin')):
"""
Get values from 'openstack role assignment list' table
Args:
field (str|list|tuple): role assignment table header to determine
which values to return
names (bool): whether to display role assignment with name
(default is ID)
role (str): an existing role from openstack role list
project (str): tenant name. When unset, the primary tenant name
will be used
user (str): an existing user that belongs to given tenant
domain (str): Include <domain> (name or ID)
group (str): Include <group> (name or ID)
group_domain (str): Domain the group belongs to (name or ID). This can
be used in case collisions between group names exist.
project_domain (str): Domain the project belongs to (name or ID). This
can be used in case collisions between project names exist.
user_domain (str): Domain the user belongs to (name or ID). This can
be used in case collisions between user names exist.
inherited (bool): Specifies if the role grant is inheritable to the
sub projects
effective_only (bool): Whether to show effective roles only
con_ssh (SSHClient): active controller ssh session
auth_info (dict): auth info to use to executing the add role cli
Returns (list): list of values
"""
optional_args = {
'role': role,
'user': user,
'project': project,
'domain': domain,
'group': group,
'group-domain': group_domain,
'project-domain': project_domain,
'user-domain': user_domain,
'names': True if names else None,
'effective': True if effective_only else None,
'inherited': True if inherited else None
}
args = common.parse_args(optional_args)
role_assignment_tab = table_parser.table(
cli.openstack('role assignment list', args, ssh_client=con_ssh,
auth_info=auth_info)[1])
if not role_assignment_tab['headers']:
LOG.info("No role assignment is found with criteria: {}".format(args))
return []
return table_parser.get_multi_values(role_assignment_tab, field)
def get_cli_timestamps(vol_id):
table_ = table_parser.table(cli.system('show')[1])
sysinv_timestamp = table_parser.get_value_two_col_table(table_, 'created_at')
table_ = table_parser.table(cli.openstack('volume show', vol_id, auth_info=Tenant.get('admin'))[1])
openstack_timestamp = table_parser.get_value_two_col_table(table_, 'created_at')
return sysinv_timestamp, openstack_timestamp
def get_package_list(header='ID',
pkgid=None,
name=None,
fqn=None,
author=None,
active=None,
is_public=None,
pkg_type=None,
version=None,
auth_info=Tenant.get('admin'),
con_ssh=None,
strict=True,
regex=None,
**kwargs):
"""
Args:
header:
pkgid
name:
fqn:
author:
active:
is_public:
pkg_type:
version:
auth_info:
con_ssh:
strict:
regex:
**kwargs:
Returns: list
"""
table_ = table_parser.table(
cli.openstack('package list', ssh_client=con_ssh,
auth_info=auth_info)[1])
args_temp = {
'ID': pkgid,
'Name': name,
'FQN': fqn,
'Author': author,
'Active': active,
'Is Public': is_public,
'Type': pkg_type,
'Version': version
}
for key, value in args_temp.items():
if value is not None:
kwargs[key] = value
return table_parser.get_values(table_,
header,
strict=strict,
regex=regex,
**kwargs)
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 delete_flavors(flavors,
check_first=True,
fail_ok=False,
con_ssh=None,
auth_info=Tenant.get('admin')):
"""
Delete given flavor(s)
Args:
flavors (list|str): id(s) of flavor(s) to delete
check_first (bool)
fail_ok (bool): whether to raise exception if any flavor fails to delete
con_ssh (SSHClient):
auth_info (dict):
Returns (tuple):
(-1, 'None of the flavor(s) exists. Do nothing.')
(0, 'Flavor is successfully deleted')
(1, <std_out>)
(2, "Flavor <flavor_id> still exists on system after deleted.")
"""
if isinstance(flavors, str):
flavors = [flavors]
if check_first:
existing_favors = get_flavors(con_ssh=con_ssh, auth_info=auth_info)
flavors = list(set(flavors) & set(existing_favors))
if not flavors:
msg = "None of the given flavors exist. Do nothing."
LOG.info(msg)
return -1, msg
LOG.info("Flavor(s) to delete: {}".format(flavors))
code, output = cli.openstack('flavor delete',
' '.join(flavors),
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
existing_favors = get_flavors(con_ssh=con_ssh, auth_info=auth_info)
flavors_still_exist = list(set(flavors) & set(existing_favors))
if flavors_still_exist:
err_msg = "Flavor(s) still exist after deletion: {}".format(
flavors_still_exist)
LOG.warning(err_msg)
if fail_ok:
return 2, err_msg
else:
raise exceptions.FlavorError(err_msg)
success_msg = "Flavor(s) deleted successfully."
LOG.info(success_msg)
return 0, success_msg
def traffic_with_preset_configs(ixncfg, ixia_session=None):
with ExitStack() as stack:
if ixia_session is None:
LOG.info("ixia_session not supplied, creating")
from keywords import ixia_helper
ixia_session = ixia_helper.IxiaSession()
ixia_session.connect()
stack.callback(ixia_session.disconnect)
ixia_session.load_config(ixncfg)
subnet_table = table_parser.table(
cli.openstack('subnet list', auth_info=Tenant.get('admin'))[1])
cidrs = list(
map(ipaddress.ip_network,
table_parser.get_column(subnet_table, 'Subnet')))
for vport in ixia_session.getList(ixia_session.getRoot(), 'vport'):
for interface in ixia_session.getList(vport, 'interface'):
if ixia_session.testAttributes(interface, enabled='true'):
ipv4_interface = ixia_session.getList(interface, 'ipv4')[0]
gw = ipaddress.ip_address(
ixia_session.getAttribute(ipv4_interface, 'gateway'))
vlan_interface = ixia_session.getList(interface, 'vlan')[0]
for cidr in cidrs:
if gw in cidr:
net_id = table_parser.get_values(subnet_table,
'Network',
cidr=cidr)[0]
table = table_parser.table(
cli.openstack(
'network show',
net_id,
auth_info=Tenant.get('admin'))[1])
seg_id = table_parser.get_value_two_col_table(
table, "provider:segmentation_id")
ixia_session.configure(vlan_interface,
vlanEnable=True,
vlanId=str(seg_id))
LOG.info(
"vport {} interface {} gw {} vlan updated to {}"
.format(vport, interface, gw, seg_id))
def create_env(name,
mgmt_net_id=None,
mgmt_subnet_id=None,
con_ssh=None,
auth_info=None,
fail_ok=False):
"""
Create Murano Environment
Args:
name: Name of the env to create
mgmt_subnet_id (str): The ID of tenant1 management subnet
mgmt_net_id (str): The ID of tenant1 management net
con_ssh (SSHClient):
auth_info (dict)
fail_ok (bool): whether return False or raise exception when some
services fail to reach enabled-active state
Returns:
code, msg: return code and msg
"""
if name is None:
raise ValueError("Murano environment name has to be specified.")
LOG.info("Creating Murano Environment {}".format(name))
args = ''
if mgmt_subnet_id:
args = " --join-subnet-id {}".format(mgmt_subnet_id)
elif mgmt_net_id:
args = " --join-net-id {}".format(mgmt_net_id)
args = '{} {}'.format(args, name)
code, output = cli.openstack("environment create",
args,
ssh_client=con_ssh,
fail_ok=fail_ok,
auth_info=auth_info)
if code > 0:
return 1, output
table_ = table_parser.table(output)
env_id = table_parser.get_values(table_, 'ID')
if len(env_id) > 0:
return 0, env_id[0]
else:
msg = "Fail to get the murano environment id"
LOG.info(msg)
if fail_ok:
return 2, msg
else:
raise exceptions.MuranoError(msg)
