def _verify_credentials(self, credentials_class, filled=True,
identity_version=None):
for ctype in common_creds.CREDENTIAL_TYPES:
if identity_version is None:
creds = common_creds.get_configured_credentials(
credential_type=ctype, fill_in=filled)
else:
creds = common_creds.get_configured_credentials(
credential_type=ctype, fill_in=filled,
identity_version=identity_version)
self._check(creds, credentials_class, filled)
def get_credentials(self, name=None, type_of_creds="default"):
if name is None:
# Get name of test method
name = inspect.stack()[1][3]
if len(name) > 32:
name = name[0:32]
# Choose type of isolated creds
self.ic = dynamic_creds.DynamicCredentialProvider(
identity_version=config.Config.auth_version,
name=name,
admin_role=config.Config.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
creds = None
if "admin" == type_of_creds:
creds = self.ic.get_admin_creds()
elif "alt" == type_of_creds:
creds = self.ic.get_alt_creds()
elif "default" == type_of_creds:
creds = self.ic.get_primary_creds()
else:
creds = self.ic.self.get_credentials(type_of_creds)
return creds
def get_credentials(self, name=None, type_of_creds="default"):
if name is None:
# Get name of test method
name = inspect.stack()[1][3]
if len(name) > 32:
name = name[0:32]
# Choose type of isolated creds
self.ic = dynamic_creds.DynamicCredentialProvider(
identity_version=config.Config.auth_version,
name=name,
admin_role=config.Config.admin_role,
admin_creds=common_creds.get_configured_credentials("identity_admin"),
)
creds = None
if "admin" == type_of_creds:
creds = self.ic.get_admin_creds()
elif "alt" == type_of_creds:
creds = self.ic.get_alt_creds()
elif "default" == type_of_creds:
creds = self.ic.get_primary_creds()
else:
creds = self.ic.self.get_credentials(type_of_creds)
return creds
def __init__(
self,
credentials=common_creds.get_configured_credentials('user'),
service=None):
super(Manager, self).__init__(credentials, service)
self.shares_client = shares_client.SharesClient(self.auth_provider)
self.shares_v2_client = shares_v2_client.SharesV2Client(
self.auth_provider)
def setUpClass(cls):
super(ScenarioPolicyBase, cls).setUpClass()
# auth provider for admin credentials
creds = credentials.get_configured_credentials('identity_admin')
auth_prov = tempestmanager.get_auth_provider(creds)
cls.admin_manager.congress_client = policy_client.PolicyClient(
auth_prov, "policy", CONF.identity.region)
def __init__(self,
credentials=common_creds.get_configured_credentials(
'identity_admin'),
service=None):
super(Manager, self).__init__(credentials, service)
self.service_broker_client = service_broker_client.ServiceBrokerClient(
self.auth_provider)
self.application_catalog_client = \
application_catalog_client.ApplicationCatalogClient(
self.auth_provider)
def __init__(
self,
credentials=common_creds.get_configured_credentials(
'identity_admin'),
request_type=None):
super(Manager, self).__init__(credentials, 'container')
if request_type == 'baymodel':
self.client = baymodel_client.BayModelClient(self.auth_provider)
elif request_type == 'bay':
self.client = bay_client.BayClient(self.auth_provider)
elif request_type == 'service':
self.client = magnum_service_client.MagnumServiceClient(
self.auth_provider)
else:
self.client = client.MagnumClient(self.auth_provider)
def __init__(self, credentials=None, request_type=None):
if not credentials:
credentials = common_creds.get_configured_credentials(
'identity_admin')
super(Manager, self).__init__(credentials, 'container-infra')
self.auth_provider.orig_base_url = self.auth_provider.base_url
self.auth_provider.base_url = self.bypassed_base_url
if request_type == 'baymodel':
self.client = baymodel_client.BayModelClient(self.auth_provider)
elif request_type == 'bay':
self.client = bay_client.BayClient(self.auth_provider)
elif request_type == 'cert':
self.client = cert_client.CertClient(self.auth_provider)
elif request_type == 'service':
self.client = magnum_service_client.MagnumServiceClient(
self.auth_provider)
else:
self.client = client.MagnumClient(self.auth_provider)
def __init__(self, credentials=None, request_type=None):
if not credentials:
credentials = common_creds.get_configured_credentials(
'identity_admin')
super(Manager, self).__init__(credentials, 'container')
self.auth_provider.orig_base_url = self.auth_provider.base_url
self.auth_provider.base_url = self.bypassed_base_url
if request_type == 'baymodel':
self.client = baymodel_client.BayModelClient(self.auth_provider)
elif request_type == 'bay':
self.client = bay_client.BayClient(self.auth_provider)
elif request_type == 'cert':
self.client = cert_client.CertClient(self.auth_provider)
elif request_type == 'service':
self.client = magnum_service_client.MagnumServiceClient(
self.auth_provider)
else:
self.client = client.MagnumClient(self.auth_provider)
def get_clients_with_isolated_creds(self,
name=None,
type_of_creds="default",
request_type=None):
"""Creates isolated creds.
:param name: name, will be used for dynamic creds
:param type_of_creds: admin, alt or default
:param request_type: baymodel or service
:returns: MagnumClient -- client with isolated creds.
:returns: KeypairClient -- allows for creating of keypairs
"""
if name is None:
# Get name of test method
name = inspect.stack()[1][3]
if len(name) > 32:
name = name[0:32]
# Choose type of isolated creds
self.ic = dynamic_creds.DynamicCredentialProvider(
identity_version=config.Config.auth_version,
name=name,
admin_role=config.Config.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
if "admin" == type_of_creds:
creds = self.ic.get_admin_creds()
manager_inst = manager.AdminManager(credentials=creds,
request_type=request_type)
elif "alt" == type_of_creds:
creds = self.ic.get_alt_creds()
manager_inst = manager.AltManager(credentials=creds,
request_type=request_type)
elif "default" == type_of_creds:
creds = self.ic.get_primary_creds()
manager_inst = manager.DefaultManager(credentials=creds,
request_type=request_type)
else:
creds = self.ic.self.get_credentials(type_of_creds)
manager_inst = manager.DefaultManager(credentials=creds,
request_type=request_type)
# create client with isolated creds
return (manager_inst.client, manager_inst.keypairs_client)
def get_configured_isolated_creds(cls, type_of_creds='admin'):
identity_version = cls.get_identity_version()
if identity_version == 'v3':
cls.admin_role = CONF.identity.admin_role
else:
cls.admin_role = 'admin'
cls.dynamic_cred = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.identity.auth_version,
name=cls.__name__, admin_role=cls.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
if type_of_creds == 'primary':
creds = cls.dynamic_cred.get_primary_creds()
elif type_of_creds == 'admin':
creds = cls.dynamic_cred.get_admin_creds()
elif type_of_creds == 'alt':
creds = cls.dynamic_cred.get_alt_creds()
else:
creds = cls.dynamic_cred.get_credentials(type_of_creds)
cls.dynamic_cred.type_of_creds = type_of_creds
return creds
def get_configured_isolated_creds(cls, type_of_creds="admin"):
identity_version = cls.get_identity_version()
if identity_version == "v3":
cls.admin_role = CONF.identity.admin_role
else:
cls.admin_role = "admin"
cls.dynamic_cred = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.application_catalog.identity_version,
name=cls.__name__,
admin_role=cls.admin_role,
admin_creds=common_creds.get_configured_credentials("identity_admin"),
)
if type_of_creds == "primary":
creds = cls.dynamic_cred.get_primary_creds()
elif type_of_creds == "admin":
creds = cls.dynamic_cred.get_admin_creds()
elif type_of_creds == "alt":
creds = cls.dynamic_cred.get_alt_creds()
else:
creds = cls.dynamic_cred.get_credentials(type_of_creds)
cls.dynamic_cred.type_of_creds = type_of_creds
return creds
def __init__(self, service=None):
super(AdminManager, self).__init__(
common_creds.get_configured_credentials('identity_admin'),
service)
def provide_share_network(cls,
shares_client,
networks_client,
isolated_creds_client=None):
"""Used for finding/creating share network for multitenant driver.
This method creates/gets entity share-network for one tenant. This
share-network will be used for creation of service vm.
:param shares_client: shares client, which requires share-network
:param networks_client: network client from same tenant as shares
:param isolated_creds_client: DynamicCredentialProvider instance
If provided, then its networking will be used if needed.
If not provided, then common network will be used if needed.
:returns: str -- share network id for shares_client tenant
:returns: None -- if single-tenant driver used
"""
sc = shares_client
if not CONF.share.multitenancy_enabled:
# Assumed usage of a single-tenant driver
share_network_id = None
elif sc.share_network_id:
# Share-network already exists, use it
share_network_id = sc.share_network_id
else:
net_id = subnet_id = share_network_id = None
if not isolated_creds_client:
# Search for networks, created in previous runs
search_word = "reusable"
sn_name = "autogenerated_by_tempest_%s" % search_word
service_net_name = "share-service"
networks = networks_client.list_networks()
if "networks" in networks.keys():
networks = networks["networks"]
for network in networks:
if (service_net_name in network["name"]
and sc.tenant_id == network['tenant_id']):
net_id = network["id"]
if len(network["subnets"]) > 0:
subnet_id = network["subnets"][0]
break
# Create suitable network
if (net_id is None or subnet_id is None):
ic = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.identity.auth_version,
name=service_net_name,
admin_role=CONF.identity.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
net_data = ic._create_network_resources(sc.tenant_id)
network, subnet, router = net_data
net_id = network["id"]
subnet_id = subnet["id"]
# Try get suitable share-network
share_networks = sc.list_share_networks_with_detail()
for sn in share_networks:
if (net_id == sn["neutron_net_id"]
and subnet_id == sn["neutron_subnet_id"]
and sn["name"] and search_word in sn["name"]):
share_network_id = sn["id"]
break
else:
sn_name = "autogenerated_by_tempest_for_isolated_creds"
# Use precreated network and subnet from isolated creds
net_id = isolated_creds_client.get_credentials(
isolated_creds_client.type_of_creds).network['id']
subnet_id = isolated_creds_client.get_credentials(
isolated_creds_client.type_of_creds).subnet['id']
# Create suitable share-network
if share_network_id is None:
sn_desc = "This share-network was created by tempest"
sn = sc.create_share_network(name=sn_name,
description=sn_desc,
neutron_net_id=net_id,
neutron_subnet_id=subnet_id)
share_network_id = sn["id"]
return share_network_id
def get_client_with_isolated_creds(cls,
name=None,
type_of_creds="admin",
cleanup_in_class=False,
client_version='1'):
"""Creates isolated creds.
:param name: name, will be used for naming ic and related stuff
:param type_of_creds: admin, alt or primary
:param cleanup_in_class: defines place where to delete
:returns: SharesClient -- shares client with isolated creds.
:returns: To client added dict attr 'creds' with
:returns: key elements 'tenant' and 'user'.
"""
if name is None:
# Get name of test method
name = inspect.stack()[1][3]
if len(name) > 32:
name = name[0:32]
# Choose type of isolated creds
ic = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.identity.auth_version,
name=name,
admin_role=CONF.identity.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
if "admin" in type_of_creds:
creds = ic.get_admin_creds()
elif "alt" in type_of_creds:
creds = ic.get_alt_creds()
else:
creds = ic.self.get_credentials(type_of_creds)
ic.type_of_creds = type_of_creds
# create client with isolated creds
os = clients.Manager(credentials=creds)
if client_version == '1':
client = os.shares_client
elif client_version == '2':
client = os.shares_v2_client
# Set place where will be deleted isolated creds
ic_res = {
"method": ic.clear_creds,
"deleted": False,
}
if cleanup_in_class:
cls.class_isolated_creds.insert(0, ic_res)
else:
cls.method_isolated_creds.insert(0, ic_res)
# Provide share network
if CONF.share.multitenancy_enabled:
if not CONF.service_available.neutron:
raise cls.skipException("Neutron support is required")
nc = os.networks_client
share_network_id = cls.provide_share_network(client, nc, ic)
client.share_network_id = share_network_id
resource = {
"type": "share_network",
"id": client.share_network_id,
"client": client,
}
if cleanup_in_class:
cls.class_resources.insert(0, resource)
else:
cls.method_resources.insert(0, resource)
return client
def __init__(self, service=None, api_microversions=None):
super(AdminManager, self).__init__(
creds_factory.get_configured_credentials('identity_admin'),
service,
api_microversions
)
def __init__(self, service=None, api_microversions=None):
super(AdminManager, self).__init__(
creds_factory.get_configured_credentials('identity_admin'),
service, api_microversions)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from tempest import clients
from tempest.common import credentials_factory as common_creds
from tempest import config
from ironic_tempest_plugin.services.baremetal.v1.json.baremetal_client import \
BaremetalClient
CONF = config.CONF
ADMIN_CREDS = common_creds.get_configured_credentials('identity_admin')
class Manager(clients.Manager):
def __init__(self,
credentials=ADMIN_CREDS,
service=None,
api_microversions=None):
super(Manager, self).__init__(credentials, service)
self.baremetal_client = BaremetalClient(
self.auth_provider,
CONF.baremetal.catalog_type,
CONF.identity.region,
endpoint_type=CONF.baremetal.endpoint_type,
**self.default_params_with_timeout_values)
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from tempest import clients
from tempest.common import credentials_factory as common_creds
from tempest import config
from ironic_tempest_plugin.services.baremetal.v1.json.baremetal_client import \
BaremetalClient
CONF = config.CONF
ADMIN_CREDS = common_creds.get_configured_credentials('identity_admin')
class Manager(clients.Manager):
def __init__(self,
credentials=ADMIN_CREDS,
service=None):
"""Initialization of Manager class.
Setup service client and make it available for test cases.
:param credentials: type Credentials or TestResources
:param service: service name
"""
super(Manager, self).__init__(credentials, service)
self.baremetal_client = BaremetalClient(
self.auth_provider,
def get_client_with_isolated_creds(cls,
name=None,
type_of_creds="admin",
cleanup_in_class=False,
client_version='1'):
"""Creates isolated creds.
:param name: name, will be used for naming ic and related stuff
:param type_of_creds: admin, alt or primary
:param cleanup_in_class: defines place where to delete
:returns: SharesClient -- shares client with isolated creds.
:returns: To client added dict attr 'creds' with
:returns: key elements 'tenant' and 'user'.
"""
if name is None:
# Get name of test method
name = inspect.stack()[1][3]
if len(name) > 32:
name = name[0:32]
# Choose type of isolated creds
ic = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.identity.auth_version,
name=name,
admin_role=CONF.identity.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
if "admin" in type_of_creds:
creds = ic.get_admin_creds()
elif "alt" in type_of_creds:
creds = ic.get_alt_creds()
else:
creds = ic.self.get_credentials(type_of_creds)
ic.type_of_creds = type_of_creds
# create client with isolated creds
os = clients.Manager(credentials=creds)
if client_version == '1':
client = os.shares_client
elif client_version == '2':
client = os.shares_v2_client
# Set place where will be deleted isolated creds
ic_res = {
"method": ic.clear_creds,
"deleted": False,
}
if cleanup_in_class:
cls.class_isolated_creds.insert(0, ic_res)
else:
cls.method_isolated_creds.insert(0, ic_res)
# Provide share network
if CONF.share.multitenancy_enabled:
if not CONF.service_available.neutron:
raise cls.skipException("Neutron support is required")
nc = os.networks_client
share_network_id = cls.provide_share_network(client, nc, ic)
client.share_network_id = share_network_id
resource = {
"type": "share_network",
"id": client.share_network_id,
"client": client,
}
if cleanup_in_class:
cls.class_resources.insert(0, resource)
else:
cls.method_resources.insert(0, resource)
return client
def __init__(self):
super(AdminManager, self).__init__(
creds_factory.get_configured_credentials('identity_admin'),
)
def __init__(self, service=None):
super(AltManager, self).__init__(
common_creds.get_configured_credentials('alt_user'), service)
def provide_share_network(cls, shares_client, networks_client,
isolated_creds_client=None):
"""Used for finding/creating share network for multitenant driver.
This method creates/gets entity share-network for one tenant. This
share-network will be used for creation of service vm.
:param shares_client: shares client, which requires share-network
:param networks_client: network client from same tenant as shares
:param isolated_creds_client: DynamicCredentialProvider instance
If provided, then its networking will be used if needed.
If not provided, then common network will be used if needed.
:returns: str -- share network id for shares_client tenant
:returns: None -- if single-tenant driver used
"""
sc = shares_client
if not CONF.share.multitenancy_enabled:
# Assumed usage of a single-tenant driver
share_network_id = None
elif sc.share_network_id:
# Share-network already exists, use it
share_network_id = sc.share_network_id
else:
net_id = subnet_id = share_network_id = None
if not isolated_creds_client:
# Search for networks, created in previous runs
search_word = "reusable"
sn_name = "autogenerated_by_tempest_%s" % search_word
service_net_name = "share-service"
networks = networks_client.list_networks()
if "networks" in networks.keys():
networks = networks["networks"]
for network in networks:
if (service_net_name in network["name"] and
sc.tenant_id == network['tenant_id']):
net_id = network["id"]
if len(network["subnets"]) > 0:
subnet_id = network["subnets"][0]
break
# Create suitable network
if (net_id is None or subnet_id is None):
ic = dynamic_creds.DynamicCredentialProvider(
identity_version=CONF.identity.auth_version,
name=service_net_name,
admin_role=CONF.identity.admin_role,
admin_creds=common_creds.get_configured_credentials(
'identity_admin'))
net_data = ic._create_network_resources(sc.tenant_id)
network, subnet, router = net_data
net_id = network["id"]
subnet_id = subnet["id"]
# Try get suitable share-network
share_networks = sc.list_share_networks_with_detail()
for sn in share_networks:
if (net_id == sn["neutron_net_id"] and
subnet_id == sn["neutron_subnet_id"] and
sn["name"] and search_word in sn["name"]):
share_network_id = sn["id"]
break
else:
sn_name = "autogenerated_by_tempest_for_isolated_creds"
# Use precreated network and subnet from isolated creds
net_id = isolated_creds_client.get_credentials(
isolated_creds_client.type_of_creds).network['id']
subnet_id = isolated_creds_client.get_credentials(
isolated_creds_client.type_of_creds).subnet['id']
# Create suitable share-network
if share_network_id is None:
sn_desc = "This share-network was created by tempest"
sn = sc.create_share_network(name=sn_name,
description=sn_desc,
neutron_net_id=net_id,
neutron_subnet_id=subnet_id)
share_network_id = sn["id"]
return share_network_id
def setup_credentials(cls):
super(TestHugepages, cls).setup_credentials()
cls.manager = clients.Manager(
credentials=common_creds.get_configured_credentials(
'identity_admin', fill_in=False))
