def _verify_credentials(self, credentials_class, filled=True,
                         identity_version=None):
     for ctype in cred_provider.CREDENTIAL_TYPES:
         if identity_version is None:
             creds = cred_provider.get_configured_credentials(
                 credential_type=ctype, fill_in=filled)
         else:
             creds = cred_provider.get_configured_credentials(
                 credential_type=ctype, fill_in=filled,
                 identity_version=identity_version)
         self._check(creds, credentials_class, filled)

def is_admin_available():
    is_admin = True
    # In the case of a pre-provisioned account, if even if creds were
    # configured, the admin credentials won't be available
    if (CONF.auth.locking_credentials_provider and
        not CONF.auth.allow_tenant_isolation):
        is_admin = False
    else:
        try:
            cred_provider.get_configured_credentials('identity_admin')
        except NotImplementedError:
            is_admin = False

    return is_admin

    def __init__(self, credentials=None):
        """
        We allow overriding of the credentials used within the various
        client classes managed by the Manager object. Left as None, the
        standard username/password/tenant_name[/domain_name] is used.

        :param credentials: Override of the credentials
        """
        self.auth_version = CONF.identity.auth_version
        if credentials is None:
            self.credentials = cred_provider.get_configured_credentials('user')
        else:
            self.credentials = credentials
        # Check if passed or default credentials are valid
        if not self.credentials.is_valid():
            raise exceptions.InvalidCredentials()
        # Tenant isolation creates TestResources, but Accounts and some tests
        # creates Credentials
        if isinstance(credentials, cred_provider.TestResources):
            creds = self.credentials.credentials
        else:
            creds = self.credentials
        # Creates an auth provider for the credentials
        self.auth_provider = get_auth_provider(creds)
        # FIXME(andreaf) unused
        self.client_attr_names = []

    def create_client(self, client_type):
        creds = cred_provider.get_configured_credentials('identity_admin')
        auth_prov = tempestmanager.get_auth_provider(creds)

        return policy_client.PolicyClient(
            auth_prov, client_type,
            CONF.identity.region)

 def __init__(self):
     os = clients.Manager(
         cred_provider.get_configured_credentials('user', fill_in=False))
     self.images_client = os.images_client
     self.flavors_client = os.flavors_client
     self.image_pattern = CONF.input_scenario.image_regex
     self.flavor_pattern = CONF.input_scenario.flavor_regex

    def setUpClass(cls):
        super(ScenarioPolicyBase, cls).setUpClass()
        # auth provider for admin credentials
        creds = cred_provider.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 get_primary_creds(self):
     if self.isolated_creds.get('primary'):
         return self.isolated_creds.get('primary')
     primary_credential = cred_provider.get_configured_credentials(
         credential_type='user', identity_version=self.identity_version)
     self.isolated_creds['primary'] = cred_provider.TestResources(
         primary_credential)
     return self.isolated_creds['primary']

 def get_alt_creds(self):
     if self._creds.get("alt"):
         return self._creds.get("alt")
     alt_credential = cred_provider.get_configured_credentials(
         credential_type="alt_user", identity_version=self.identity_version
     )
     self._creds["alt"] = cred_provider.TestResources(alt_credential)
     return self._creds["alt"]

 def get_primary_creds(self):
     if self._creds.get("primary"):
         return self._creds.get("primary")
     primary_credential = cred_provider.get_configured_credentials(
         credential_type="user", identity_version=self.identity_version
     )
     self._creds["primary"] = cred_provider.TestResources(primary_credential)
     return self._creds["primary"]

 def get_alt_creds(self):
     if self.isolated_creds.get('alt'):
         return self.isolated_creds.get('alt')
     alt_credential = cred_provider.get_configured_credentials(
         credential_type='alt_user',
         identity_version=self.identity_version)
     self.isolated_creds['alt'] = cred_provider.TestResources(
         alt_credential)
     return self.isolated_creds['alt']

def is_admin_available():
    is_admin = True
    # If dynamic credentials is enabled admin will be available
    if CONF.auth.use_dynamic_credentials:
        return is_admin
    # Check whether test accounts file has the admin specified or not
    elif (CONF.auth.test_accounts_file and
            os.path.isfile(CONF.auth.test_accounts_file)):
        check_accounts = accounts.Accounts(name='check_admin')
        if not check_accounts.admin_available():
            is_admin = False
    else:
        try:
            cred_provider.get_configured_credentials('identity_admin',
                                                     fill_in=False)
        except exceptions.InvalidConfiguration:
            is_admin = False
    return is_admin

    def setUpClass(cls):
        super(TestCase, cls).setUpClass()

        # If no credentials are provided, the Manager will use those
        # in CONF.identity and generate an auth_provider from them
        cls.creds = cred_provider.get_configured_credentials(
            credential_type='identity_admin')
        mgr = clients.Manager(cls.creds)
        cls.client = MuranoClient(mgr.auth_provider)

 def get_alt_creds(self):
     if self.isolated_creds.get('alt'):
         return self.isolated_creds.get('alt')
     if not self.use_default_creds:
         creds = self.get_creds(1)
         alt_credential = cred_provider.get_credentials(**creds)
     else:
         alt_credential = cred_provider.get_configured_credentials(
             'alt_user')
     self.isolated_creds['alt'] = alt_credential
     return alt_credential

 def get_primary_creds(self):
     if self.isolated_creds.get('primary'):
         return self.isolated_creds.get('primary')
     if not self.use_default_creds:
         creds = self.get_creds(0)
         primary_credential = cred_provider.get_credentials(**creds)
     else:
         primary_credential = cred_provider.get_configured_credentials(
             'user')
     self.isolated_creds['primary'] = primary_credential
     return primary_credential

def is_admin_available(identity_version):
    is_admin = True
    # If dynamic credentials is enabled admin will be available
    if CONF.auth.use_dynamic_credentials:
        return is_admin
    # Check whether test accounts file has the admin specified or not
    elif (CONF.auth.test_accounts_file and
            os.path.isfile(CONF.auth.test_accounts_file)):
        check_accounts = preprov_creds.PreProvisionedCredentialProvider(
            identity_version=identity_version, name='check_admin',
            admin_role=CONF.identity.admin_role)
        if not check_accounts.admin_available():
            is_admin = False
    else:
        try:
            cred_provider.get_configured_credentials(
                'identity_admin', fill_in=False,
                identity_version=identity_version)
        except exceptions.InvalidConfiguration:
            is_admin = False
    return is_admin

 def __init__(self, identity_version=None, name=None,
              network_resources=None):
     super(IsolatedCreds, self).__init__(identity_version, name,
                                         network_resources)
     self.network_resources = network_resources
     self.isolated_creds = {}
     self.ports = []
     self.default_admin_creds = cred_provider.get_configured_credentials(
         'identity_admin', fill_in=True,
         identity_version=self.identity_version)
     self.identity_admin_client, self.network_admin_client = (
         self._get_admin_clients())
     # Domain where isolated credentials are provisioned (v3 only).
     # Use that of the admin account is None is configured.
     self.creds_domain_name = None
     if self.identity_version == 'v3':
         self.creds_domain_name = (
             CONF.auth.tenant_isolation_domain_name or
             self.default_admin_creds.project_domain_name)
     self.creds_client = get_creds_client(
         self.identity_admin_client, self.creds_domain_name)

 def __init__(self, identity_version, name=None, network_resources=None,
              credentials_domain=None):
     super(DynamicCredentialProvider, self).__init__(
         identity_version=identity_version, name=name,
         network_resources=network_resources,
         credentials_domain=credentials_domain)
     self._creds = {}
     self.ports = []
     self.default_admin_creds = cred_provider.get_configured_credentials(
         'identity_admin', fill_in=True,
         identity_version=self.identity_version)
     (self.identity_admin_client, self.network_admin_client,
      self.networks_admin_client,
      self.subnets_admin_client) = self._get_admin_clients()
     # Domain where isolated credentials are provisioned (v3 only).
     # Use that of the admin account is None is configured.
     self.creds_domain_name = None
     if self.identity_version == 'v3':
         self.creds_domain_name = (
             self.default_admin_creds.project_domain_name or
             self.credentials_domain)
     self.creds_client = cred_client.get_creds_client(
         self.identity_admin_client, self.creds_domain_name)

def main():
    credentials = cred_provider.get_configured_credentials('identity_admin')
    network_client, image_client, glance_client, nova_client = set_context(credentials)
    # Start to config
    fix_cirros(glance_client, image_client)
    fix_tempest_conf(network_client, nova_client)

def main():
    config = read_tempest_conf()
    credentials = cred_provider.get_configured_credentials('identity_admin')
    manager = clients.Manager(credentials=credentials)
    check_image_ref(manager)
    fix_tempest_conf(manager, config)

 def __init__(self, service=None):
     super(AdminManager, self).__init__(
         credentials=cred_provider.get_configured_credentials(
             'identity_admin'),
         service=service)