def config_compute(config_parser, private_vip, user_name, password,
tenant_name, endpoint_type='internalURL',
min_compute_nodes=1):
auth_url = get_auth_url(private_vip)
nova = nova_client.Client('2', user_name, password, tenant_name, auth_url,
insecure=True, endpoint_type=endpoint_type)
# Get the default image.
images = nova.images.list()
if len(images) == 0:
raise NotSupportedError('At least 1 image in glance is required.')
default_image = images[0]
for image in images:
if image.name == IMAGE_NAME:
default_image = image
images.remove(image)
LOG.info('Use image %s as default image in tempest', default_image.name)
alt_image = images[0] if len(images) > 0 else default_image
LOG.info('Use image %s as alter image in tempest', alt_image.name)
config_parser.set('compute', 'image_ref', default_image.id)
config_parser.set('compute', 'image_ref_alt', alt_image.id)
# Create the flavors
m1 = create_if_not_exist(nova.flavors, 'flavor', FLAVOR1_NAME, ram=512,
vcpus=1, disk=10, is_public=True)
config_parser.set('compute', 'flavor_ref', m1.id)
config_parser.set('orchestration', 'instance_type', FLAVOR1_NAME)
m2 = create_if_not_exist(nova.flavors, 'flavor', FLAVOR2_NAME, ram=1024,
vcpus=2, disk=10, is_public=True)
config_parser.set('compute', 'flavor_ref_alt', m2.id)
config_parser.set('compute', 'min_compute_nodes', min_compute_nodes)
config_parser.set('compute-feature-enabled', 'pause', 'false')
def config_volume(config_parser, private_vip, user_name, password, tenant_name,
endpoint_type='internalURL'):
auth_url = get_auth_url(private_vip)
nova = nova_client.Client('2', user_name, password, tenant_name, auth_url,
insecure=True, endpoint_type=endpoint_type)
# Get Nova API versions
versions = nova.versions.list()
if (len(versions) == 1 and
versions[0].to_dict().get('status') == 'SUPPORTED'):
config_parser.set('volume', 'storage_protocol', 'LSI Logic SCSI')
def config_identity(config_parser,
p_vip,
admin_user_name,
admin_pwd,
admin_tenant_name,
creds_provider,
default_user_name=None,
default_pwd=None,
alt_user_name=None,
alt_pwd=None):
uri_v3 = get_auth_url(p_vip, 'v3')
uri_v2 = get_auth_url(p_vip)
keystone = get_keystone_client(p_vip=p_vip,
username=admin_user_name,
password=admin_pwd,
project_name=admin_tenant_name,
domain_name=DEFAULT_DOMAIN_ID)
config_parser.set('identity', 'uri_v3', uri_v3)
config_parser.set('identity', 'uri', uri_v2)
config_parser.set('identity', 'auth_version', 'v3')
config_parser.set('auth', 'admin_project_name', admin_tenant_name)
config_parser.set('auth', 'admin_password', admin_pwd)
config_parser.set('auth', 'admin_username', admin_user_name)
# config heat_plugin
auth_url = get_auth_url2(p_vip, 'v3')
config_parser.set('heat_plugin', 'auth_url', auth_url)
config_parser.set('heat_plugin', 'auth_version', '3')
config_parser.set('heat_plugin', 'admin_username', admin_user_name)
config_parser.set('heat_plugin', 'admin_password', admin_pwd)
# Create tempest test role
test_role = create_if_not_exist(keystone.roles, 'role', ROLE_NAME)
config_parser.set('auth', 'tempest_roles', ROLE_NAME)
# Both SQL backend and LDAP backend is Default
config_parser.set('auth', 'admin_domain_name', 'Default')
default_domain = keystone.domains.get(DEFAULT_DOMAIN_ID)
default_tenant = create_if_not_exist(keystone.projects,
'project',
TENANT_NAME,
domain=default_domain)
# config_parser.set('heat_plugin', 'username', 'admin')
# config_parser.set('heat_plugin', 'password', 'vmware')
# config_parser.set('heat_plugin', 'project_name', 'admin')
# config_parser.set('heat_plugin', 'user_domain_name', 'Default')
# config_parser.set('heat_plugin', 'project_domain_name', 'Default')
try:
heat_user = create_if_not_exist(keystone.users,
'user',
'demo',
password='******',
default_project=default_tenant)
grant_role_on_project(keystone, default_tenant, heat_user, test_role)
config_parser.set('heat_plugin', 'username', 'admin')
config_parser.set('heat_plugin', 'password', 'vmware')
config_parser.set('heat_plugin', 'project_name', 'admin')
config_parser.set('heat_plugin', 'user_domain_name', 'Default')
config_parser.set('heat_plugin', 'project_domain_name', 'Default')
except Exception:
config_parser.set('heat_plugin', 'username', 'admin')
config_parser.set('heat_plugin', 'password', 'vmware')
config_parser.set('heat_plugin', 'project_name', 'admin')
config_parser.set('heat_plugin', 'user_domain_name', 'local')
config_parser.set('heat_plugin', 'project_domain_name', 'local')
if creds_provider in [LEGACY_PROVIDER, PRE_PROVISIONED_PROVIDER]:
# Create default tenant and user
default_domain = keystone.domains.get(DEFAULT_DOMAIN_ID)
default_tenant = create_if_not_exist(keystone.projects,
'project',
TENANT_NAME,
domain=default_domain)
default_user = create_if_not_exist(keystone.users,
'user',
default_user_name,
password=default_pwd,
tenant_id=default_tenant.id)
grant_role_on_project(keystone, default_tenant, default_user,
test_role)
# Create alter tenant and user
alt_tenant = create_if_not_exist(keystone.projects,
'project',
ALT_TENANT_NAME,
domain=default_domain)
alt_user = create_if_not_exist(keystone.users,
'user',
alt_user_name,
password=alt_pwd,
tenant_id=alt_tenant.id)
grant_role_on_project(keystone, alt_tenant, alt_user, test_role)
if LEGACY_PROVIDER == creds_provider:
# Legacy provider can only be used before Newton release.
config_parser.set('identity', 'tenant_name', TENANT_NAME)
config_parser.set('identity', 'username', default_user_name)
config_parser.set('identity', 'password', default_pwd)
config_parser.set('identity', 'alt_tenant_name', ALT_TENANT_NAME)
config_parser.set('identity', 'alt_username', alt_user_name)
config_parser.set('identity', 'alt_password', alt_pwd)
elif PRE_PROVISIONED_PROVIDER == creds_provider:
accounts = list()
accounts.append(
add_account(default_user_name,
default_pwd,
TENANT_NAME,
default_tenant.id,
roles=[ROLE_NAME]))
accounts.append(
add_account(alt_user_name,
alt_pwd,
ALT_TENANT_NAME,
alt_tenant.id,
roles=[ROLE_NAME]))
project_id = None
for project in keystone.projects.list():
if project.name == admin_tenant_name \
and project.domain_id == DEFAULT_DOMAIN_ID:
project_id = project.id
break
if not project_id:
raise NotFoundError('Project %s not found' % admin_tenant_name)
accounts.append(
add_account(admin_user_name,
admin_pwd,
admin_tenant_name,
project_id,
roles=['admin']))
test_accounts_file = os.path.join(os.getcwd(), TEMPEST_DIR,
'etc/accounts.yaml')
with open(test_accounts_file, 'w') as fh:
yaml.dump(accounts,
fh,
default_flow_style=False,
default_style=False,
indent=2,
encoding='utf-8',
allow_unicode=True)
config_parser.set('auth', 'test_accounts_file', test_accounts_file)
config_parser.set('auth', 'use_dynamic_credentials', 'false')
config_parser.set('auth', 'create_isolated_networks', 'false')
elif creds_provider == DYNAMIC_PROVIDER:
config_parser.set('auth', 'use_dynamic_credentials', 'true')
config_parser.set('auth', 'create_isolated_networks', 'false')
else:
raise NotSupportedError('Not support %s' % creds_provider)
# Create role for object storage
create_if_not_exist(keystone.roles, 'role', STORAGE_ROLE_NAME)
config_parser.set('object-storage', 'operator_role', STORAGE_ROLE_NAME)
def config_network(config_parser, private_vip, user_name, password,
neutron_backend, tenant_name, ext_net_cidr=None,
ext_net_start_ip=None, ext_net_end_ip=None,
ext_net_gateway=None, endpoint_type='internalURL'):
auth_url = get_auth_url(private_vip)
neutron = neutron_client.Client('2.0', username=user_name,
password=password,
tenant_name=tenant_name,
auth_url=auth_url,
insecure=True,
endpoint_type=endpoint_type)
data_network = get_network(neutron, DATA_NET_NAME)
if not data_network:
# Create fixed network
if NSXV_BACKEND == neutron_backend:
net_spec = {
"network":
{
"name": DATA_NET_NAME,
"admin_state_up": True,
"shared": True
}
}
else:
net_spec = {
"network":
{
"provider:network_type": "flat",
"name": DATA_NET_NAME,
"provider:physical_network": "dvs",
"admin_state_up": True,
"shared": True
}
}
LOG.info("Create data network %s.", DATA_NET_NAME)
data_network = neutron.create_network(net_spec)['network']
# Create data subnet
# TODO: Create a static subnet as fixed network while using dynamic
# credentials.
subnet_spec = {
'subnet':
{
"name": DATA_NET_NAME,
'network_id': data_network['id'],
'cidr': DATA_NET_CIDR,
'ip_version': 4,
'enable_dhcp': True
}
}
LOG.info("Create %s subnet.", DATA_NET_NAME)
data_subnet = neutron.create_subnet(subnet_spec)['subnet']
data_network['subnets'] = [data_subnet['id']]
else:
LOG.info("Found data network %s", DATA_NET_NAME)
config_parser.set('compute', 'fixed_network_name', DATA_NET_NAME)
if NSXV_BACKEND == neutron_backend:
ext_network = get_network(neutron, EXT_NET_NAME)
if not ext_network:
# Create external network
net_spec = {
"network":
{
"router:external": "True",
"name": EXT_NET_NAME,
"admin_state_up": True
}
}
LOG.info("Create external network %s.", EXT_NET_NAME)
ext_network = neutron.create_network(net_spec)['network']
# Create external subnet
subnet_spec = {
'subnet':
{
"name": EXT_NET_NAME,
'network_id': ext_network['id'],
'cidr': ext_net_cidr,
'ip_version': 4,
'enable_dhcp': False,
'gateway_ip': ext_net_gateway,
'allocation_pools': [{"start": ext_net_start_ip,
"end": ext_net_end_ip}]
}
}
LOG.info("Create %s subnet.", EXT_NET_NAME)
neutron.create_subnet(subnet_spec)
LOG.info("Create router %s.", ROUTER_NAME)
router_spec = {
'router':
{
'name': ROUTER_NAME,
'external_gateway_info':
{
'network_id': ext_network['id']
}
}
}
router = neutron.create_router(router_spec)['router']
LOG.info("Add %s to router %s", DATA_NET_NAME, ROUTER_NAME)
add_router_interface_spec = {
'subnet_id': data_network['subnets'][0]
}
neutron.add_interface_router(router['id'],
add_router_interface_spec)
else:
LOG.info("Found external network %s", EXT_NET_NAME)
config_parser.set('network', 'public_network_id', ext_network['id'])
config_parser.set('network-feature-enabled', 'api_extensions',
'binding, dist-router, multi-provider, provider, '
'quotas,external-net, extraroute, router, '
'security-group')
config_parser.set('network-feature-enabled',
'port_admin_state_change', 'False')
config_parser.set('network-feature-enabled', 'ipv6', 'False')
config_parser.set('validation', 'connect_method', 'floating')
config_parser.set('network', 'floating_network_name', EXT_NET_NAME)
config_parser.set('validation', 'run_validation', 'true')
else:
config_parser.set('network', 'tenant_network_cidr', DATA_NET_CIDR)
config_parser.set('network', 'tenant_network_mask_bits', '24')
config_parser.set('validation', 'run_validation', 'false')
def config_identity(config_parser, private_vip, admin_user_name, admin_pwd,
admin_tenant_name, creds_provider, default_user_name=None,
default_pwd=None, alt_user_name=None, alt_pwd=None):
uri_v3 = get_auth_url(private_vip, 'v3')
uri_v2 = get_auth_url(private_vip)
keystone = get_keystone_client(private_vip=private_vip,
username=admin_user_name,
password=admin_pwd,
project_name=admin_tenant_name,
domain_name=DEFAULT_DOMAIN_ID)
admin_tenant = get_entity(keystone.projects, 'project', admin_tenant_name)
config_parser.set('identity', 'uri_v3', uri_v3)
config_parser.set('identity', 'uri', uri_v2)
config_parser.set('identity', 'auth_version', 'v2')
config_parser.set('auth', 'admin_tenant_name', admin_tenant_name)
config_parser.set('auth', 'admin_password', admin_pwd)
config_parser.set('auth', 'admin_username', admin_user_name)
# Create tempest test role
test_role = create_if_not_exist(keystone.roles, 'role', ROLE_NAME)
config_parser.set('auth', 'tempest_roles', ROLE_NAME)
# Both SQL backend and LDAP backend is Default
config_parser.set('auth', 'admin_domain_name', 'Default')
if creds_provider in [LEGACY_PROVIDER, PRE_PROVISIONED_PROVIDER]:
# Create default tenant and user
default_domain = keystone.domains.get(DEFAULT_DOMAIN_ID)
default_tenant = create_if_not_exist(keystone.projects, 'project',
TENANT_NAME,
domain=default_domain)
default_user = create_if_not_exist(keystone.users, 'user',
default_user_name,
password=default_pwd,
tenant_id=default_tenant.id)
grant_role_on_project(keystone, default_tenant, default_user,
test_role)
# Create alter tenant and user
alt_tenant = create_if_not_exist(keystone.projects, 'project',
ALT_TENANT_NAME,
domain=default_domain)
alt_user = create_if_not_exist(keystone.users, 'user', alt_user_name,
password=alt_pwd,
tenant_id=alt_tenant.id)
grant_role_on_project(keystone, alt_tenant, alt_user, test_role)
if LEGACY_PROVIDER == creds_provider:
# Legacy provider can only be used before Newton release.
config_parser.set('identity', 'tenant_name', TENANT_NAME)
config_parser.set('identity', 'username', default_user_name)
config_parser.set('identity', 'password', default_pwd)
config_parser.set('identity', 'alt_tenant_name', ALT_TENANT_NAME)
config_parser.set('identity', 'alt_username', alt_user_name)
config_parser.set('identity', 'alt_password', alt_pwd)
elif PRE_PROVISIONED_PROVIDER == creds_provider:
accounts = list()
accounts.append(add_account(default_user_name, default_pwd,
TENANT_NAME, roles=[ROLE_NAME]))
accounts.append(add_account(alt_user_name, alt_pwd,
ALT_TENANT_NAME, roles=[ROLE_NAME]))
accounts.append(add_account(admin_user_name, admin_pwd,
admin_tenant_name, roles=['admin']))
test_accounts_file = os.path.join(os.getcwd(), TEMPEST_DIR,
'etc/accounts.yaml')
with open(test_accounts_file, 'w') as fh:
yaml.dump(accounts, fh, default_flow_style=False,
default_style=False, indent=2, encoding='utf-8',
allow_unicode=True)
config_parser.set('auth', 'test_accounts_file', test_accounts_file)
config_parser.set('auth', 'use_dynamic_credentials', 'false')
config_parser.set('auth', 'create_isolated_networks', 'false')
elif creds_provider == DYNAMIC_PROVIDER:
config_parser.set('auth', 'use_dynamic_credentials', 'true')
config_parser.set('auth', 'create_isolated_networks', 'false')
else:
raise NotSupportedError('Not support %s' % creds_provider)
# Create role for object storage
create_if_not_exist(keystone.roles, 'role', STORAGE_ROLE_NAME)
config_parser.set('object-storage', 'operator_role', STORAGE_ROLE_NAME)
# Create role and add it to admin user for heat tempest tests.
heat_role = get_entity(keystone.roles, 'role', 'heat_stack_owner')
if not heat_role:
LOG.info("Create role heat_stack_owner")
heat_role = keystone.roles.create('heat_stack_owner')
admin_user = get_entity(keystone.users, 'user', admin_user_name)
grant_role_on_project(keystone, admin_tenant, admin_user, heat_role)
