def test_get_configured_admin_credentials_not_fill_not_valid( self, mock_get_credentials): cfg.CONF.set_default('auth_version', 'v2', 'identity') expected_result = mock.Mock() expected_result.is_valid.return_value = False mock_get_credentials.return_value = expected_result with testtools.ExpectedException(exceptions.InvalidConfiguration, value_re='.*\n.*identity version v2'): cf.get_configured_admin_credentials(fill_in=False)
def test_get_configured_admin_credentials_not_fill_not_valid( self, mock_get_credentials): cfg.CONF.set_default('auth_version', 'v2', 'identity') expected_result = mock.Mock() expected_result.is_valid.return_value = False mock_get_credentials.return_value = expected_result with testtools.ExpectedException(exceptions.InvalidConfiguration, value_re='.*\n.*identity version v2'): cf.get_configured_admin_credentials(fill_in=False)
def _get_dynamic_creds(cls, name, network_resources=None): identity_version = CONF.identity.auth_version if identity_version == 'v3': identity_uri = CONF.identity.uri_v3 identity_admin_endpoint_type = CONF.identity.v3_endpoint_type elif identity_version == 'v2': identity_uri = CONF.identity.uri identity_admin_endpoint_type = CONF.identity.v2_admin_endpoint_type return dynamic_creds.DynamicCredentialProvider( identity_version=identity_version, name=name, network_resources=network_resources, credentials_domain=CONF.auth.default_credentials_domain_name, admin_role=CONF.identity.admin_role, admin_creds=common_creds.get_configured_admin_credentials(), identity_admin_domain_scope=CONF.identity.admin_domain_scope, identity_admin_role=CONF.identity.admin_role, extra_roles=None, neutron_available=CONF.service_available.neutron, create_networks=( CONF.share.create_networks_when_multitenancy_enabled), project_network_cidr=CONF.network.project_network_cidr, project_network_mask_bits=CONF.network.project_network_mask_bits, public_network_id=CONF.network.public_network_id, resource_prefix='tempest', identity_admin_endpoint_type=identity_admin_endpoint_type, identity_uri=identity_uri)
def setup_clients(cls): super(ScenarioTest, cls).setup_clients() # Clients cls.admin_flavors_client = cls.admin_manager.flavors_client if CONF.service_available.glance: # Check if glance v1 is available to determine which client to use. if CONF.image_feature_enabled.api_v1: cls.image_client = cls.os_primary.image_client elif CONF.image_feature_enabled.api_v2: cls.image_client = cls.os_primary.image_client_v2 else: raise lib_exc.InvalidConfiguration( 'Either api_v1 or api_v2 must be True in ' '[image-feature-enabled].') # Compute image client cls.compute_images_client = cls.os_primary.compute_images_client cls.keypairs_client = cls.os_primary.keypairs_client # Nova security groups client cls.compute_security_groups_client = ( cls.os_primary.compute_security_groups_client) cls.compute_security_group_rules_client = ( cls.os_primary.compute_security_group_rules_client) cls.servers_client = cls.os_primary.servers_client # Neutron network client cls.networks_client = cls.os_primary.networks_client cls.ports_client = cls.os_primary.ports_client credentials = common_creds.get_configured_admin_credentials( 'identity_admin') auth_prov = get_auth_provider(credentials) cls.os_admin.cyborg_client = ( clients.CyborgRestClient(auth_prov, 'accelerator', CONF.identity.region))
def get_configured_isolated_creds(cls, type_of_creds='admin'): identity_version = CONF.identity.auth_version if identity_version == 'v3': cls.admin_role = CONF.identity.admin_role cls.identity_uri = CONF.identity.uri_v3 else: cls.admin_role = 'admin' cls.identity_uri = CONF.identity.uri cls.dynamic_cred = dynamic_creds.DynamicCredentialProvider( identity_version=CONF.identity.auth_version, identity_uri=cls.identity_uri, name=cls.__name__, admin_role=cls.admin_role, admin_creds=common_creds.get_configured_admin_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.credentials
def test_get_configured_admin_credentials_not_fill_valid( self, mock_get_credentials): cfg.CONF.set_default('auth_version', 'v2', 'identity') all_params = [ ('admin_username', 'username', 'my_name'), ('admin_user_domain_name', 'user_domain_name', 'my_dname'), ('admin_password', 'password', 'secret'), ('admin_project_domain_name', 'project_domain_name', 'my_dname'), ('admin_project_name', 'project_name', 'my_pname'), ('admin_domain_name', 'domain_name', 'my_dname'), ('admin_system', 'system', None), ] expected_result = mock.Mock() expected_result.is_valid.return_value = True mock_get_credentials.return_value = expected_result for config_item, _, value in all_params: cfg.CONF.set_default(config_item, value, 'auth') # Build the expected params expected_params = dict([(field, value) for _, field, value in all_params]) expected_params.update(config.service_client_config()) admin_creds = cf.get_configured_admin_credentials( fill_in=False, identity_version='v3') mock_get_credentials.assert_called_once_with(fill_in=False, identity_version='v3', **expected_params) self.assertEqual(expected_result, admin_creds) expected_result.is_valid.assert_called_once()
def init(self, parsed_args): cleanup_service.init_conf() self.options = parsed_args self.admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) self.dry_run_data = {} self.json_data = {} self.admin_id = "" self.admin_role_id = "" self.admin_project_id = "" self._init_admin_ids() # available services self.project_associated_services = ( cleanup_service.get_project_associated_cleanup_services()) self.resource_cleanup_services = ( cleanup_service.get_resource_cleanup_services()) self.global_services = cleanup_service.get_global_cleanup_services() if parsed_args.init_saved_state: self._init_state() return self._load_json()
def setup_clients(cls): super(BaseAPITest, cls).setup_clients() credentials = common_creds.get_configured_admin_credentials( 'identity_admin') auth_prov = get_auth_provider(credentials=credentials) cls.os_admin.cyborg_client = (client.CyborgRestClient( auth_prov, 'accelerator', CONF.identity.region))
def __init__(self, credentials=None): """Initialization of Manager class. Setup service client and make it available for test cases. :param credentials: type Credentials or TestResources """ if credentials is None: global ADMIN_CREDS if ADMIN_CREDS is None: ADMIN_CREDS = common_creds.get_configured_admin_credentials() credentials = ADMIN_CREDS super(Manager, self).__init__(credentials) default_params_with_timeout_values = { 'build_interval': CONF.compute.build_interval, 'build_timeout': CONF.compute.build_timeout } default_params_with_timeout_values.update(self.default_params) self.baremetal_client = BaremetalClient( self.auth_provider, CONF.baremetal.catalog_type, CONF.identity.region, endpoint_type=CONF.baremetal.endpoint_type, **default_params_with_timeout_values)
def create_client(self, client_type): creds = credentials.get_configured_admin_credentials('identity_admin') auth_prov = tempestmanager.get_auth_provider(creds) return policy_client.PolicyClient( auth_prov, client_type, CONF.identity.region)
def setup_clients(cls): super(BaseIdentityTest, cls).setup_clients() credentials = common_creds.get_configured_admin_credentials( cls.credential_type, identity_version=cls.identity_version) cls.keystone_manager = clients.Manager(credentials=credentials) cls.idps_client = cls.keystone_manager.identity_providers_client cls.mappings_client = cls.keystone_manager.mapping_rules_client cls.sps_client = cls.keystone_manager.service_providers_client
def setUp(self): super(TestCase, self).setUp() credentials = common_creds.get_configured_admin_credentials( 'identity_admin') auth_provider = get_auth_provider(credentials) self.client = SolumClient(auth_provider) self.builderclient = SolumClient(auth_provider, 'image_builder')
def __init__(self, credentials=None, api_microversions=None): if not credentials: credentials = common_creds.get_configured_admin_credentials() super(Manager, self).__init__(credentials) self.introspection_client = BaremetalIntrospectionClient( self.auth_provider, CONF.baremetal_introspection.catalog_type, CONF.identity.region, endpoint_type=CONF.baremetal_introspection.endpoint_type)
def setup_credentials(cls): """Do not create network resources for these tests Using public network for ssh """ cls.set_network_resources() super(BaseTest, cls).setup_credentials() cls.manager = clients.Manager( credentials=common_creds.get_configured_admin_credentials())
def __init__(self, credentials=common_creds.get_configured_admin_credentials( 'identity_admin')): self.auth_provider = get_auth_provider(credentials) self.service_broker_client = service_broker_client.ServiceBrokerClient( self.auth_provider) self.application_catalog_client = \ application_catalog_client.ApplicationCatalogClient( self.auth_provider)
def setup_credentials(cls): """Do not create network resources for these tests Using public network for ssh """ cls.set_network_resources() super(BaseTest, cls).setup_credentials() cls.manager = clients.Manager( credentials=common_creds.get_configured_admin_credentials())
def __init__(self, credentials=common_creds.get_configured_admin_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=None): if credentials is None: global ADMIN_CREDS if ADMIN_CREDS is None: ADMIN_CREDS = common_creds.get_configured_admin_credentials() credentials = ADMIN_CREDS super(Manager, self).__init__(credentials) self.artifacts_client = artifacts_client.ArtifactsClient( self.auth_provider)
def _get_session_for_admin(cls): admin_creds = common_creds.get_configured_admin_credentials() password = admin_creds.password username = admin_creds.username user_domain_id = admin_creds.user_domain_id project_name = admin_creds.project_name project_domain_id = admin_creds.project_domain_id return cls._get_session(username, password, user_domain_id, project_name, project_domain_id)
def _remove_admin_role(self, project_id): LOG.debug("Remove admin user role for projectt: %s", project_id) # Must initialize Admin Manager for each user role # Otherwise authentication exception is thrown, weird id_cl = clients.Manager( credentials.get_configured_admin_credentials()).identity_client if (self._project_exists(project_id)): try: id_cl.delete_role_from_user_on_project(project_id, self.admin_id, self.admin_role_id) except Exception as ex: LOG.exception("Failed removing role from project which still " "exists, exception: %s", ex)
def __init__(self, credentials=common_creds.get_configured_admin_credentials( 'identity_admin')): self.auth_provider = get_auth_provider(credentials) self.service_broker_client = service_broker_client.ServiceBrokerClient( self.auth_provider) if CONF.application_catalog.glare_backend: self.artifacts_client = artifacts_client.ArtifactsClient( self.auth_provider) else: self.artifacts_client = None self.application_catalog_client = \ application_catalog_client.ApplicationCatalogClient( self.auth_provider)
def _remove_admin_role(self, project_id): LOG.debug("Remove admin user role for projectt: %s", project_id) # Must initialize Admin Manager for each user role # Otherwise authentication exception is thrown, weird id_cl = clients.Manager( credentials.get_configured_admin_credentials()).identity_client if (self._project_exists(project_id)): try: id_cl.delete_role_from_user_on_project(project_id, self.admin_id, self.admin_role_id) except Exception as ex: LOG.exception("Failed removing role from project which still" "exists, exception: %s", ex)
def _get_network_id(net_name, project_name): am = clients.Manager(credentials.get_configured_admin_credentials()) net_cl = am.networks_client tn_cl = am.tenants_client networks = net_cl.list_networks() tenant = identity.get_tenant_by_name(tn_cl, project_name) t_id = tenant['id'] n_id = None for net in networks['networks']: if (net['tenant_id'] == t_id and net['name'] == net_name): n_id = net['id'] break return n_id
def __init__(self, credentials=common_creds.get_configured_admin_credentials( 'identity_admin')): self.auth_provider = get_auth_provider(credentials) self.service_broker_client = service_broker_client.ServiceBrokerClient( self.auth_provider) if CONF.application_catalog.glare_backend: self.artifacts_client = artifacts_client.ArtifactsClient( self.auth_provider) else: self.artifacts_client = None self.application_catalog_client = \ application_catalog_client.ApplicationCatalogClient( self.auth_provider)
def _get_network_id(net_name, project_name): am = clients.Manager(credentials.get_configured_admin_credentials()) net_cl = am.networks_client pr_cl = am.projects_client networks = net_cl.list_networks() project = identity.get_project_by_name(pr_cl, project_name) p_id = project['id'] n_id = None for net in networks['networks']: if (net['project_id'] == p_id and net['name'] == net_name): n_id = net['id'] break return n_id
def _get_network_id(net_name, project_name): am = clients.Manager( credentials.get_configured_admin_credentials()) net_cl = am.networks_client pr_cl = am.projects_client networks = net_cl.list_networks() project = identity.get_project_by_name(pr_cl, project_name) p_id = project['id'] n_id = None for net in networks['networks']: if (net['project_id'] == p_id and net['name'] == net_name): n_id = net['id'] break return n_id
def __init__(self, test_obj): """Constructor for ``RbacUtils``. :param test_obj: An instance of `tempest.test.BaseTestCase`. """ # Intialize the admin roles_client to perform role switching. admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) if test_obj.get_identity_version() == 'v3': admin_roles_client = admin_mgr.roles_v3_client else: admin_roles_client = admin_mgr.roles_client self.admin_roles_client = admin_roles_client self._override_role(test_obj, False)
def setUpClass(cls): super(ScenarioPolicyBase, cls).setUpClass() # auth provider for admin credentials creds = credentials.get_configured_admin_credentials('identity_admin') auth_prov = tempestmanager.get_auth_provider(creds) cls.admin_manager.congress_client = policy_client.PolicyClient( auth_prov, "policy", CONF.identity.region) if getattr(CONF.service_available, 'ceilometer', False): import ceilometer.tests.tempest.service.client as telemetry_client cls.admin_manager.telemetry_client = ( telemetry_client.TelemetryClient( auth_prov, CONF.telemetry.catalog_type, CONF.identity.region, endpoint_type=CONF.telemetry.endpoint_type))
def setup_clients(cls): super(BaseIdentityTest, cls).setup_clients() credentials = common_creds.get_configured_admin_credentials( cls.credential_type, identity_version=cls.identity_version) cls.keystone_manager = clients.Manager(credentials) cls.auth_client = cls.keystone_manager.auth_client cls.idps_client = cls.keystone_manager.identity_providers_client cls.mappings_client = cls.keystone_manager.mapping_rules_client cls.roles_client = cls.keystone_manager.roles_v3_client cls.saml2_client = cls.keystone_manager.saml2_client cls.sps_client = cls.keystone_manager.service_providers_client cls.tokens_client = cls.keystone_manager.token_v3_client cls.consumers_client = cls.keystone_manager.oauth_consumers_client cls.oauth_token_client = cls.keystone_manager.oauth_token_client cls.registered_limits_client = ( cls.keystone_manager.registered_limits_client) cls.limits_client = cls.keystone_manager.limits_client
def _get_dynamic_creds(cls, name, network_resources=None): return dynamic_creds.DynamicCredentialProvider( identity_version=CONF.identity.auth_version, name=name, network_resources=network_resources, credentials_domain=CONF.auth.default_credentials_domain_name, admin_role=CONF.identity.admin_role, admin_creds=common_creds.get_configured_admin_credentials(), identity_admin_domain_scope=CONF.identity.admin_domain_scope, identity_admin_role=CONF.identity.admin_role, extra_roles=None, neutron_available=CONF.service_available.neutron, create_networks=( CONF.share.create_networks_when_multitenancy_enabled), project_network_cidr=CONF.network.project_network_cidr, project_network_mask_bits=CONF.network.project_network_mask_bits, public_network_id=CONF.network.public_network_id, resource_prefix=CONF.resources_prefix)
def test_get_configured_admin_credentials(self, mock_get_credentials): cfg.CONF.set_default('auth_version', 'v3', 'identity') all_params = [('admin_username', 'username', 'my_name'), ('admin_password', 'password', 'secret'), ('admin_project_name', 'project_name', 'my_pname'), ('admin_domain_name', 'domain_name', 'my_dname')] expected_result = 'my_admin_credentials' mock_get_credentials.return_value = expected_result for config_item, _, value in all_params: cfg.CONF.set_default(config_item, value, 'auth') # Build the expected params expected_params = dict( [(field, value) for _, field, value in all_params]) expected_params.update(config.service_client_config()) admin_creds = cf.get_configured_admin_credentials() mock_get_credentials.assert_called_once_with( fill_in=True, identity_version='v3', **expected_params) self.assertEqual(expected_result, admin_creds)
def _init_state(self): print("Initializing saved state.") data = {} self.global_services = cleanup_service.get_global_cleanup_services() self.admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) admin_mgr = self.admin_mgr kwargs = {'data': data, 'is_dry_run': False, 'saved_state_json': data, 'is_preserve': False, 'is_save_state': True} for service in self.global_services: svc = service(admin_mgr, **kwargs) svc.run() with open(SAVED_STATE_JSON, 'w+') as f: f.write(json.dumps(data, sort_keys=True, indent=2, separators=(',', ': ')))
def _init_state(self): print("Initializing saved state.") data = {} self.global_services = cleanup_service.get_global_cleanup_services() self.admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) admin_mgr = self.admin_mgr kwargs = {'data': data, 'is_dry_run': False, 'saved_state_json': data, 'is_preserve': False, 'is_save_state': True} for service in self.global_services: svc = service(admin_mgr, **kwargs) svc.run() with open(SAVED_STATE_JSON, 'w+') as f: f.write(json.dumps(data, sort_keys=True, indent=2, separators=(',', ': ')))
def test_get_configured_admin_credentials(self, mock_get_credentials): cfg.CONF.set_default('auth_version', 'v3', 'identity') all_params = [('admin_username', 'username', 'my_name'), ('admin_password', 'password', 'secret'), ('admin_project_name', 'project_name', 'my_pname'), ('admin_domain_name', 'domain_name', 'my_dname')] expected_result = 'my_admin_credentials' mock_get_credentials.return_value = expected_result for config_item, _, value in all_params: cfg.CONF.set_default(config_item, value, 'auth') # Build the expected params expected_params = dict([(field, value) for _, field, value in all_params]) expected_params.update(cf.DEFAULT_PARAMS) admin_creds = cf.get_configured_admin_credentials() mock_get_credentials.assert_called_once_with(fill_in=True, identity_version='v3', **expected_params) self.assertEqual(expected_result, admin_creds)
def validate_service(cls, service): """Validate whether the service passed to ``__init__`` exists.""" service = service.lower().strip() if service else None # Cache the list of available services in memory to avoid needlessly # doing an API call every time. if not hasattr(cls, 'available_services'): admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) services_client = (admin_mgr.identity_services_v3_client if CONF.identity_feature_enabled.api_v3 else admin_mgr.identity_services_client) services = services_client.list_services()['services'] cls.available_services = [s['name'] for s in services] if not service or service not in cls.available_services: LOG.debug("%s is NOT a valid service.", service) raise rbac_exceptions.RbacInvalidService( "%s is NOT a valid service." % service)
def setup_clients(cls): # Intialize the admin roles_client to perform role switching. admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) if CONF.identity_feature_enabled.api_v3: admin_roles_client = admin_mgr.roles_v3_client else: raise lib_exc.InvalidConfiguration( "Patrole role overriding only supports v3 identity API.") cls.admin_roles_client = admin_roles_client cls._project_id = cls.os_primary.credentials.tenant_id cls._user_id = cls.os_primary.credentials.user_id cls._role_inferences_mapping = cls._prepare_role_inferences_mapping() cls._init_roles() # Change default role to admin cls._override_role(False) super(RbacUtilsMixin, cls).setup_clients()
def credentials(): # You can get credentials either from tempest.conf file or # from OS environment. tempest_creds = clients.get_auth_provider( creds_factory.get_configured_admin_credentials()) creds = tempest_creds.credentials creds_dict = { '--os-username': os.environ.get('OS_USERNAME', creds.username), '--os-password': os.environ.get('OS_PASSWORD', creds.password), '--os-project-name': os.environ.get('OS_PROJECT_NAME', creds.project_name), '--os-auth-url': os.environ.get('OS_AUTH_URL', tempest_creds.auth_url), '--os-project-domain-name': os.environ.get('OS_PROJECT_DOMAIN_ID', creds.project_domain_name), '--os-user-domain-name': os.environ.get('OS_USER_DOMAIN_ID', creds.user_domain_name), } return [x for sub in creds_dict.items() for x in sub]
def get_configured_isolated_creds(cls, type_of_creds='admin'): identity_version = CONF.identity.auth_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_admin_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.credentials
def init(self, parsed_args): cleanup_service.init_conf() self.options = parsed_args self.admin_mgr = clients.Manager( credentials.get_configured_admin_credentials()) self.dry_run_data = {} self.json_data = {} self.admin_id = "" self.admin_role_id = "" self.admin_project_id = "" self._init_admin_ids() self.admin_role_added = [] # available services self.project_services = cleanup_service.get_project_cleanup_services() self.global_services = cleanup_service.get_global_cleanup_services() if parsed_args.init_saved_state: self._init_state() return self._load_json()
def setUp(self): super(BaseTestCase, self).setUp() self.servers_keypairs = {} self.servers = {} self.members = [] self.floating_ips = {} self.servers_floating_ips = {} self.server_ips = {} self.start_port = 80 self.num = 50 self.server_fixed_ips = {} mgr = self.get_client_manager() auth_provider = mgr.auth_provider region = config.network.region or config.identity.region self.client_args = [auth_provider, 'load-balancer', region] self.load_balancers_client = ( load_balancers_client.LoadBalancersClient(*self.client_args)) self.listeners_client = (listeners_client.ListenersClient( *self.client_args)) self.pools_client = pools_client.PoolsClient(*self.client_args) self.members_client = members_client.MembersClient(*self.client_args) self.health_monitors_client = ( health_monitors_client.HealthMonitorsClient(*self.client_args)) self.quotas_client = quotas_client.QuotasClient(*self.client_args) self._create_security_group_for_test() self._set_net_and_subnet() # admin network client needed for assigning octavia port to flip os_admin = clients.Manager( credentials_factory.get_configured_admin_credentials()) os_admin.auth_provider.fill_credentials() self.floating_ips_client_admin = os_admin.floating_ips_client self.ports_client_admin = os_admin.ports_client
def __init__(self, credentials=None): """Initialization of Manager class. Setup service client and make it available for test cases. :param credentials: type Credentials or TestResources """ if credentials is None: global ADMIN_CREDS if ADMIN_CREDS is None: ADMIN_CREDS = common_creds.get_configured_admin_credentials() credentials = ADMIN_CREDS super(Manager, self).__init__(credentials) default_params_with_timeout_values = { 'build_interval': CONF.compute.build_interval, 'build_timeout': CONF.compute.build_timeout } default_params_with_timeout_values.update(self.default_params) self.baremetal_client = BaremetalClient( self.auth_provider, CONF.baremetal.catalog_type, CONF.identity.region, endpoint_type=CONF.baremetal.endpoint_type, **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_admin_credentials() 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 setUpClass(cls): super(ScenarioPolicyBase, cls).setUpClass() # auth provider for admin credentials creds = credentials.get_configured_admin_credentials('identity_admin') auth_prov = tempestmanager.get_auth_provider(creds) cls.setup_required_clients(auth_prov)
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 search_word = "reusable" sn_name = "autogenerated_by_tempest_%s" % search_word 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 elif not CONF.share.create_networks_when_multitenancy_enabled: share_network_id = None # Try get suitable share-network share_networks = sc.list_share_networks_with_detail() for sn in share_networks: if (sn["neutron_net_id"] is None and sn["neutron_subnet_id"] is None and sn["name"] and search_word in sn["name"]): share_network_id = sn["id"] break # Create new share-network if one was not found 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) share_network_id = sn["id"] else: net_id = subnet_id = share_network_id = None if not isolated_creds_client: # Search for networks, created in previous runs 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_admin_credentials())) 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_admin_credentials( fill_in=False))
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 search_word = "reusable" sn_name = "autogenerated_by_tempest_%s" % search_word 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 elif not CONF.share.create_networks_when_multitenancy_enabled: share_network_id = None # Try get suitable share-network share_networks = sc.list_share_networks_with_detail() for sn in share_networks: if (sn["neutron_net_id"] is None and sn["neutron_subnet_id"] is None and sn["name"] and search_word in sn["name"]): share_network_id = sn["id"] break # Create new share-network if one was not found 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) share_network_id = sn["id"] else: net_id = subnet_id = share_network_id = None if not isolated_creds_client: # Search for networks, created in previous runs 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_admin_credentials())) 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 __init__(self, service=None): super(AltManager, self).__init__( common_creds.get_configured_admin_credentials('alt_user'), service)
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_admin_credentials()) if "admin" in type_of_creds: creds = ic.get_admin_creds().credentials elif "alt" in type_of_creds: creds = ic.get_alt_creds().credentials else: creds = ic.get_credentials(type_of_creds).credentials ic.type_of_creds = type_of_creds # create client with isolated creds os = clients.Manager(credentials=creds) if client_version == '1': client = shares_client.SharesClient(os.auth_provider) elif client_version == '2': client = shares_v2_client.SharesV2Client(os.auth_provider) # 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 and CONF.share.create_networks_when_multitenancy_enabled): 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