[夏肇毅部落格] CentOS 6.5下OpenStack keystone 安裝問題:ConfigFileNotFound(夏肇毅部落格)

[夏肇毅部落格] 這幾天在CentOS6.5上安裝在keystone 時發生 CRITICAL keystone [-] ConfigFileNotFound　的問題.以前好像不會.
比較開發環境後發現缺少了"keystone-paste.ini". 將其複製至/etc/keystone 下重起即可.

[root@controller keystone]# service openstack-keystone start
Starting keystone:                                         [FAILED]

[root@controller keystone]# cat /var/log/keystone/keystone-startup.log
2014-09-20 21:27:17.086 12404 CRITICAL keystone [-] ConfigFileNotFound: An unexpected error prevented the server from fulfilling your request.

**Need to get a "keystone-paste.ini" file and copy it into /etc/keystone/

[root@controller keystone]# service openstack-keystone start
Starting keystone:                                         [  OK  ]

[夏肇毅部落格] OpenStack Study 筆記: keystone assignment backends ldap.py

[夏肇毅部落格] 看完kvs(Key Value Store) 之後,我們就要看assignment 的第二個backend: ldap.
從CubicPower首頁中之 keystone  進入keystone index 第一頁,
看到的第二個檔案就是:

\OpenStack\keystone-2014.1\keystone\assignment\backends\ldap.py

點入
def __init__(self):
可見ldap 的基本資料設定:
**** CubicPower OpenStack Study ****
    def __init__(self):
        super(Assignment, self).__init__()
        self.LDAP_URL = CONF.ldap.url
        self.LDAP_USER = CONF.ldap.user
        self.LDAP_PASSWORD = CONF.ldap.password
        self.suffix = CONF.ldap.suffix
        #These are the only deep dependency from assignment back
        #to identity.  The assumption is that if you are using
        #LDAP for assignments, you are using it for Id as well.
        self.user = ldap_identity.UserApi(CONF)
        self.group = ldap_identity.GroupApi(CONF)
        self.project = ProjectApi(CONF)
        self.role = RoleApi(CONF)
一旦選用 ldap 則identity 亦從ldap 來.
此檔案前面import部份有定義ldap_identity的來源:
from keystone.identity.backends import ldap as ldap_identity

init 之後就是由ldap 所提供的assignment 介面方法.
看一下def get_project(self, tenant_id):
**** CubicPower OpenStack Study ****
    def get_project(self, tenant_id):
        return self._set_default_domain(self.project.get(tenant_id))
前面有定義 self.project = ProjectApi(CONF)
所以就要再去研究一下 之後的類別ProjectApi:
class ProjectApi(common_ldap.EnabledEmuMixIn, common_ldap.BaseLdap):

[夏肇毅部落格]OpenStack Study 筆記: keystone assignment backends kvs.py

[夏肇毅部落格] 從CubicPower首頁中之 keystone  進入keystone index 第一頁
首先看到的第一個檔案就是

\OpenStack\keystone-2014.1\keystone\assignment\backends\kvs.py

第一個類別是 class Assignment(kvs.Base, assignment.Driver):
點入就可見一些kvs(key value store)的格式說明:
"""KVS Assignment backend.
This backend uses the following mappings to store data:
* Domains:
* domain_list -> [domain_id, ...]
* domain-{id} -> domain_ref
* domain_name-{name} -> domain_ref
* Projects:
* tenant-{id} -> project_ref
* tenant_name-{name} -> project_ref
* Roles:
* role_list -> [role_id, ...]
* role-{id} -> role_ref
* Role assignments:
* metadata_user-{target}-{user_id} ->
{'roles': [{'id': role-id, ...}, ...]}
* metadata_group-{target}-{group_id} ->
{'roles': [{'id': role-id, ...}, ...]}
"""
# Public interface

這就是kvs中儲存資料的內容規格.
再回前一頁 接下去 就是他提供的存取資料介面:
   def __init__(self):
    def get_project(self, tenant_id):
    def list_projects(self, hints):
    def list_projects_in_domain(self, domain_id):
    def get_project_by_name(self, tenant_name, domain_id):
    def create_project(self, tenant_id, tenant):
    def update_project(self, tenant_id, tenant):
    def _get_metadata(self, user_id=None, tenant_id=None, domain_id=None, group_id=None):
        def _get_roles_for_just_user_and_project(user_id, tenant_id):
        def _get_roles_for_group_and_project(group_id, project_id):
    def get_role(self, role_id):
    def list_roles(self, hints):
    def list_projects_for_user(self, user_id, group_ids, hints):
    def get_roles_for_groups(self, group_ids, project_id=None, domain_id=None):
    def list_projects_for_groups(self, group_ids):
    def list_domains_for_groups(self, group_ids):
    def list_user_ids_for_project(self, tenant_id):
    def _subrole_id_to_dn(self, role_id, tenant_id):
    def add_role_to_user_and_project(self, user_id, tenant_id, role_id):
    def _add_role_to_group_and_project(self, group_id, tenant_id, role_id):
    def create_role(self, role_id, role):
    def delete_role(self, role_id):
    def delete_project(self, tenant_id):
    def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):
    def _remove_role_from_group_and_project(self, group_id, tenant_id, role_id):
    def update_role(self, role_id, role):
    def create_domain(self, domain_id, domain):
    def get_domain(self, domain_id):
    def update_domain(self, domain_id, domain):
    def delete_domain(self, domain_id):
    def list_domains(self, hints):
    def delete_user(self, user_id):
    def delete_group(self, group_id):
    def create_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def get_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def delete_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def list_grants(self, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def get_domain_by_name(self, domain_name):
    def list_role_assignments(self):
點入看第一個方法def get_project(self, tenant_id):
**** CubicPower OpenStack Study ****
    def get_project(self, tenant_id):
        try:
            return self.db.get('tenant-%s' % tenant_id)
        except exception.NotFound:
            raise exception.ProjectNotFound(project_id=tenant_id)

其中self.db.get('tenant-%s' % tenant_id)
就是從db 中以tenant_id抓取project的資料.
就如同開頭的資料規格所說:
* Projects:
* tenant-{id} -> project_ref

[夏肇毅部落格] 從根了解OpenStack 之keystone元件功能: credential與 identity

[夏肇毅部落格] keystone中最主要的功能 就是credential與 identity
這裡列出了處理id 的程式 與classes

\OpenStack\keystone-2014.1\keystone\credential\backends\sql.py

class CredentialModel(sql.ModelBase, sql.DictBase):
class Credential(credential.Driver):
    def db_sync(self, version=None):
    def create_credential(self, credential_id, credential):
    def list_credentials(self, **filters):
    def _get_credential(self, session, credential_id):
    def get_credential(self, credential_id):
    def update_credential(self, credential_id, credential):
    def delete_credential(self, credential_id):
    def delete_credentials_for_project(self, project_id):
    def delete_credentials_for_user(self, user_id):

\OpenStack\keystone-2014.1\keystone\credential\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\credential\controllers.py

class CredentialV3(controller.V3Controller):
    def __init__(self):
    def _assign_unique_id(self, ref, trust_id=None):
    def create_credential(self, context, credential):
    def _blob_to_json(ref):
    def list_credentials(self, context):
    def get_credential(self, context, credential_id):
    def update_credential(self, context, credential_id, credential):
    def delete_credential(self, context, credential_id):

\OpenStack\keystone-2014.1\keystone\credential\core.py

class Manager(manager.Manager):
    def __init__(self):
class Driver(object):
    def create_credential(self, credential_id, credential):
    def list_credentials(self, **filters):
    def get_credential(self, credential_id):
    def update_credential(self, credential_id, credential):
    def delete_credential(self, credential_id):
    def delete_credentials_for_project(self, project_id):
    def delete_credentials_for_user(self, user_id):
    def _delete_credentials(self, match_fn):

\OpenStack\keystone-2014.1\keystone\credential\routers.py

def append_v3_routers(mapper, routers):

\OpenStack\keystone-2014.1\keystone\credential\__init__.py

\OpenStack\keystone-2014.1\keystone\exception.py

class Error(Exception):
    def __init__(self, message=None, **kwargs):
    def _build_message(self, message, **kwargs):
class ValidationError(Error):
class ValidationTimeStampError(Error):
class StringLengthExceeded(ValidationError):
class ValidationSizeError(Error):
class PKITokenExpected(Error):
class SecurityError(Error):
    def _build_message(self, message, **kwargs):
class Unauthorized(SecurityError):
class AuthPluginException(Unauthorized):
    def __init__(self, *args, **kwargs):
class MissingGroups(Unauthorized):
class AuthMethodNotSupported(AuthPluginException):
    def __init__(self, *args, **kwargs):
class AdditionalAuthRequired(AuthPluginException):
    def __init__(self, auth_response=None, **kwargs):
class Forbidden(SecurityError):
class ForbiddenAction(Forbidden):
class ImmutableAttributeError(Forbidden):
class NotFound(Error):
class EndpointNotFound(NotFound):
class MetadataNotFound(NotFound):
class PolicyNotFound(NotFound):
class RoleNotFound(NotFound):
class RegionNotFound(NotFound):
class ServiceNotFound(NotFound):
class DomainNotFound(NotFound):
class ProjectNotFound(NotFound):
class TokenNotFound(NotFound):
class UserNotFound(NotFound):
class GroupNotFound(NotFound):
class MappingNotFound(NotFound):
class TrustNotFound(NotFound):
class TrustUseLimitReached(Forbidden):
class CredentialNotFound(NotFound):
class VersionNotFound(NotFound):
class IdentityProviderNotFound(NotFound):
class FederatedProtocolNotFound(NotFound):
class Conflict(Error):
class RequestTooLarge(Error):
class UnexpectedError(SecurityError):
    def message_format(self):
    def _build_message(self, message, **kwargs):
class CertificateFilesUnavailable(UnexpectedError):
class MalformedEndpoint(UnexpectedError):
class MappedGroupNotFound(UnexpectedError):
class NotImplemented(Error):
class Gone(Error):
class ConfigFileNotFound(UnexpectedError):
class MigrationNotProvided(Exception):
    def __init__(self, mod_name, path):

\OpenStack\keystone-2014.1\keystone\identity\backends\kvs.py

class _UserIdToDomainId(object):
    def __init__(self, db):
    def _calc_key(self, user_id):
    def notify_user_created(self, user_id, domain_id):
    def notify_user_deleted(self, user_id):
    def get(self, user_id):
class Identity(kvs.Base, identity.Driver):
    def __init__(self):
    def default_assignment_driver(self):
    def is_domain_aware(self):
    def authenticate(self, user_id, password):
    def _get_user(self, user_id):
    def _calc_user_name_key(self, name, domain_id):
    def _get_user_by_name(self, user_name, domain_id):
    def get_user(self, user_id):
    def get_user_by_name(self, user_name, domain_id):
    def list_users(self, hints):
    def create_user(self, user_id, user):
    def update_user(self, user_id, user):
    def add_user_to_group(self, user_id, group_id):
    def check_user_in_group(self, user_id, group_id):
    def remove_user_from_group(self, user_id, group_id):
    def list_users_in_group(self, group_id, hints):
    def list_groups_for_user(self, user_id, hints):
    def delete_user(self, user_id):
    def create_group(self, group_id, group):
    def list_groups(self, hints):
    def get_group(self, group_id):
    def update_group(self, group_id, group):
    def delete_group(self, group_id):

\OpenStack\keystone-2014.1\keystone\identity\backends\ldap.py

class Identity(identity.Driver):
    def __init__(self, conf=None):
    def default_assignment_driver(self):
    def is_domain_aware(self):
    def authenticate(self, user_id, password):
    def _get_user(self, user_id):
    def get_user(self, user_id):
    def list_users(self, hints):
    def get_user_by_name(self, user_name, domain_id):
    def create_user(self, user_id, user):
    def update_user(self, user_id, user):
    def delete_user(self, user_id):
    def create_group(self, group_id, group):
    def get_group(self, group_id):
    def update_group(self, group_id, group):
    def delete_group(self, group_id):
    def add_user_to_group(self, user_id, group_id):
    def remove_user_from_group(self, user_id, group_id):
    def list_groups_for_user(self, user_id, hints):
    def list_groups(self, hints):
    def list_users_in_group(self, group_id, hints):
    def check_user_in_group(self, user_id, group_id):
class UserApi(common_ldap.EnabledEmuMixIn, common_ldap.BaseLdap):
    def __init__(self, conf):
    def _ldap_res_to_model(self, res):
    def mask_enabled_attribute(self, values):
    def create(self, values):
    def check_password(self, user_id, password):
    def get_filtered(self, user_id):
    def get_all_filtered(self):
class GroupApi(common_ldap.BaseLdap):
    def __init__(self, conf):
    def create(self, values):
    def delete(self, group_id):
    def update(self, group_id, values):
    def add_user(self, user_dn, group_id, user_id):
    def remove_user(self, user_dn, group_id, user_id):
    def list_user_groups(self, user_dn):
    def list_group_users(self, group_id):

\OpenStack\keystone-2014.1\keystone\identity\backends\sql.py

class User(sql.ModelBase, sql.DictBase):
    def to_dict(self, include_extra_dict=False):
class Group(sql.ModelBase, sql.DictBase):
class UserGroupMembership(sql.ModelBase, sql.DictBase):
class Identity(identity.Driver):
    def default_assignment_driver(self):
    def db_sync(self, version=None):
    def _check_password(self, password, user_ref):
    def is_domain_aware(self):
    def authenticate(self, user_id, password):
    def create_user(self, user_id, user):
    def list_users(self, hints):
    def _get_user(self, session, user_id):
    def get_user(self, user_id):
    def get_user_by_name(self, user_name, domain_id):
    def update_user(self, user_id, user):
    def add_user_to_group(self, user_id, group_id):
    def check_user_in_group(self, user_id, group_id):
    def remove_user_from_group(self, user_id, group_id):
    def list_groups_for_user(self, user_id, hints):
    def list_users_in_group(self, group_id, hints):
    def delete_user(self, user_id):
    def create_group(self, group_id, group):
    def list_groups(self, hints):
    def _get_group(self, session, group_id):
    def get_group(self, group_id):
    def update_group(self, group_id, group):
    def delete_group(self, group_id):

\OpenStack\keystone-2014.1\keystone\identity\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\identity\controllers.py

class DeprecatedMeta(type):
    def moved_to_assignment(class_name):
        def inner(f):
    def _is_wrappable(item):
    def __new__(mcs, class_name, bases, namespace):
        def get_attribute(self, item):
    def __getattribute__(cls, item):
class User(controller.V2Controller):
    def get_user(self, context, user_id):
    def get_users(self, context):
    def get_user_by_name(self, context, user_name):
    def create_user(self, context, user):
    def update_user(self, context, user_id, user):
    def delete_user(self, context, user_id):
    def set_user_enabled(self, context, user_id, user):
    def set_user_password(self, context, user_id, user):
    def _normalize_OSKSADM_password_on_request(ref):
class UserV3(controller.V3Controller):
    def __init__(self):
    def _check_user_and_group_protection(self, context, prep_info, user_id, group_id):
    def create_user(self, context, user):
    def list_users(self, context, filters):
    def list_users_in_group(self, context, filters, group_id):
    def get_user(self, context, user_id):
    def _update_user(self, context, user_id, user, domain_scope):
    def update_user(self, context, user_id, user):
    def add_user_to_group(self, context, user_id, group_id):
    def check_user_in_group(self, context, user_id, group_id):
    def remove_user_from_group(self, context, user_id, group_id):
    def delete_user(self, context, user_id):
    def change_password(self, context, user_id, user):
class GroupV3(controller.V3Controller):
    def __init__(self):
    def create_group(self, context, group):
    def list_groups(self, context, filters):
    def list_groups_for_user(self, context, filters, user_id):
    def get_group(self, context, group_id):
    def update_group(self, context, group_id, group):
    def delete_group(self, context, group_id):
class Tenant(assignment_controllers.Tenant):
class Role(assignment_controllers.Role):
class DomainV3(assignment_controllers.DomainV3):
class ProjectV3(assignment_controllers.ProjectV3):
class RoleV3(assignment_controllers.RoleV3):
class RoleAssignmentV3(assignment_controllers.RoleAssignmentV3):

\OpenStack\keystone-2014.1\keystone\identity\core.py

def moved_to_assignment(f):
def filter_user(user_ref):
class DomainConfigs(dict):
    def _load_driver(self, assignment_api, domain_id):
    def _load_config(self, assignment_api, file_list, domain_name):
    def setup_domain_drivers(self, standard_driver, assignment_api):
    def get_domain_driver(self, domain_id):
    def get_domain_conf(self, domain_id):
    def reload_domain_driver(self, assignment_api, domain_id):
def domains_configured(f):
    def wrapper(self, *args, **kwargs):
class Manager(manager.Manager):
    def __init__(self):
    def _set_domain_id(self, ref, domain_id):
    def _clear_domain_id(self, ref):
    def _normalize_scope(self, domain_scope):
    def _select_identity_driver(self, domain_id):
    def _get_domain_id_and_driver(self, domain_scope):
    def _mark_domain_id_filter_satisfied(self, hints):
    def authenticate(self, context, user_id, password, domain_scope=None):
    def create_user(self, user_id, user_ref):
    def get_user(self, user_id, domain_scope=None):
    def get_user_by_name(self, user_name, domain_id):
    def list_users(self, domain_scope=None, hints=None):
    def update_user(self, user_id, user_ref, domain_scope=None):
    def delete_user(self, user_id, domain_scope=None):
    def create_group(self, group_id, group_ref):
    def get_group(self, group_id, domain_scope=None):
    def update_group(self, group_id, group, domain_scope=None):
    def revoke_tokens_for_group(self, group_id, domain_scope):
    def delete_group(self, group_id, domain_scope=None):
    def add_user_to_group(self, user_id, group_id, domain_scope=None):
    def remove_user_from_group(self, user_id, group_id, domain_scope=None):
    def list_groups_for_user(self, user_id, domain_scope=None, hints=None):
    def list_groups(self, domain_scope=None, hints=None):
    def list_users_in_group(self, group_id, domain_scope=None, hints=None):
    def check_user_in_group(self, user_id, group_id, domain_scope=None):
    def change_password(self, context, user_id, original_password, new_password, domain_scope):
    def get_domain_by_name(self, domain_name):
    def get_domain(self, domain_id):
    def update_domain(self, domain_id, domain):
    def list_domains(self, hints=None):
    def delete_domain(self, domain_id):
    def create_domain(self, domain_id, domain):
    def list_projects_for_user(self, user_id):
    def add_user_to_project(self, tenant_id, user_id):
    def remove_user_from_project(self, tenant_id, user_id):
    def get_project(self, tenant_id):
    def list_projects(self, hints=None):
    def get_role(self, role_id):
    def list_roles(self, hints=None):
    def get_project_users(self, tenant_id):
    def get_roles_for_user_and_project(self, user_id, tenant_id):
    def get_roles_for_user_and_domain(self, user_id, domain_id):
    def add_role_to_user_and_project(self, user_id, tenant_id, role_id):
    def create_role(self, role_id, role):
    def delete_role(self, role_id):
    def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):
    def update_role(self, role_id, role):
    def create_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def list_grants(self, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def get_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
    def delete_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):
class Driver(object):
    def _get_list_limit(self):
    def authenticate(self, user_id, password):
    def create_user(self, user_id, user):
    def list_users(self, hints):
    def list_users_in_group(self, group_id, hints):
    def get_user(self, user_id):
    def update_user(self, user_id, user):
    def add_user_to_group(self, user_id, group_id):
    def check_user_in_group(self, user_id, group_id):
    def remove_user_from_group(self, user_id, group_id):
    def delete_user(self, user_id):
    def get_user_by_name(self, user_name, domain_id):
    def create_group(self, group_id, group):
    def list_groups(self, hints):
    def list_groups_for_user(self, user_id, hints):
    def get_group(self, group_id):
    def update_group(self, group_id, group):
    def delete_group(self, group_id):
    def is_domain_aware(self):

\OpenStack\keystone-2014.1\keystone\identity\routers.py

class Admin(wsgi.ComposableRouter):
    def add_routes(self, mapper):
def append_v3_routers(mapper, routers):

\OpenStack\keystone-2014.1\keystone\identity\__init__.py

[夏肇毅部落格] 從根了解OpenStack 之keystone元件功能: common,contrib

[夏肇毅部落格]  這裡列出keystone中的common,contrib 等常用模組功能列表.
主要是由OpenStack\keystone-2014.1 版原始碼整理而得.
名稱基本上都用詞或句表示, 淺顯易懂.
看看名稱就大概能了解他處理了哪些資料.
有興趣再點入連結看原始碼詳讀.

\OpenStack\keystone-2014.1\keystone\common\authorization.py

def flatten(d, parent_key=''):
def is_v3_token(token):
def v3_token_to_auth_context(token):
def v2_token_to_auth_context(token):
def token_to_auth_context(token):

\OpenStack\keystone-2014.1\keystone\common\base64utils.py

class InvalidBase64Error(ValueError):
def is_valid_base64(text):
def is_valid_base64url(text):
def filter_formatting(text):
def base64_to_base64url(text):
def base64url_to_base64(text):
def base64_is_padded(text, pad='='):
def base64url_percent_encode(text):
def base64url_percent_decode(text):
def base64_strip_padding(text, pad='='):
def base64_assure_padding(text, pad='='):
def base64_wrap_iter(text, width=64):
def base64_wrap(text, width=64):

\OpenStack\keystone-2014.1\keystone\common\cache\backends\mongo.py

class MongoCacheBackend(api.CacheBackend):
    def __init__(self, arguments):
    def client(self):
    def get(self, key):
    def get_multi(self, keys):
    def set(self, key, value):
    def set_multi(self, mapping):
    def delete(self, key):
    def delete_multi(self, keys):
class MongoApi(object):
    def __init__(self, arguments):
    def _init_args(self, arguments):
    def _ssl_cert_req_type(self, req_type):
    def _get_db(self):
    def _assign_data_mainpulator(self):
    def _get_doc_date(self):
    def get_cache_collection(self):
    def _get_cache_entry(self, key, value, meta, doc_date):
    def _validate_ttl_index(self, collection, coll_name, ttl_seconds):
    def get(self, key):
    def get_multi(self, keys):
    def _get_results_as_dict(self, keys):
    def set(self, key, value):
    def set_multi(self, mapping):
    def delete(self, key):
    def delete_multi(self, keys):
class AbstractManipulator(object):
    def transform_incoming(self, son, collection):
    def transform_outgoing(self, son, collection):
    def will_copy(self):
class BaseTransform(AbstractManipulator):
    def transform_incoming(self, son, collection):
    def transform_outgoing(self, son, collection):

\OpenStack\keystone-2014.1\keystone\common\cache\backends\noop.py

class NoopCacheBackend(api.CacheBackend):
    def __init__(self, *args):
    def get(self, key):
    def get_multi(self, keys):
    def set(self, key, value):
    def set_multi(self, mapping):
    def delete(self, key):
    def delete_multi(self, keys):

\OpenStack\keystone-2014.1\keystone\common\cache\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\common\cache\core.py

class DebugProxy(proxy.ProxyBackend):
    def get(self, key):
    def get_multi(self, keys):
    def set(self, key, value):
    def set_multi(self, keys):
    def delete(self, key):
    def delete_multi(self, keys):
        def function(arg1, arg2):
    def should_cache(value):
def key_generate_to_str(s):
def function_key_generator(namespace, fn, to_str=key_generate_to_str):

\OpenStack\keystone-2014.1\keystone\common\cache\__init__.py

\OpenStack\keystone-2014.1\keystone\common\config.py

def setup_authentication(conf=None):
def configure(conf=None):
def list_opts():

\OpenStack\keystone-2014.1\keystone\common\controller.py

def v2_deprecated(f):
def _build_policy_check_credentials(self, action, context, kwargs):
def protected(callback=None):
 def wrapper(f):
def filterprotected(*filters):
 def _filterprotected(f):
class V2Controller(wsgi.Application):
    def _normalize_domain_id(self, context, ref):
    def filter_domain_id(ref):
    def normalize_username_in_response(ref):
    def normalize_username_in_request(ref):
    def v3_to_v2_user(ref):
        def _format_default_project_id(ref):
        def _normalize_and_filter_user_properties(ref):
class V3Controller(wsgi.Application):
    def base_url(cls, context, path=None):
    def _add_self_referential_link(cls, context, ref):
    def wrap_member(cls, context, ref):
    def wrap_collection(cls, context, refs, hints=None):
    def limit(cls, refs, hints):
    def filter_by_attributes(cls, refs, hints):
        def _attr_match(ref_attr, val_attr):
        def _inexact_attr_match(filter, ref):
    def build_driver_hints(cls, context, supported_filters):
    def _require_matching_id(self, value, ref):
    def _require_matching_domain_id(self, ref_id, ref, get_member):
    def _assign_unique_id(self, ref):
    def _get_domain_id_for_request(self, context):
    def _normalize_domain_id(self, context, ref):
    def filter_domain_id(ref):
    def check_protection(self, context, prep_info, target_attr=None):
    def check_immutable_params(cls, ref):
    def check_required_params(cls, ref):
    def filter_params(cls, ref):

\OpenStack\keystone-2014.1\keystone\common\dependency.py

class UnresolvableDependencyException(Exception):
    def __init__(self, name):
def provider(name):
    def wrapper(cls):
        def wrapped(init):
    def process(obj, attr_name, unresolved_in_out):
def requires(*dependencies):
    def wrapper(self, *args, **kwargs):
    def wrapped(cls):
def optional(*dependencies):
    def wrapper(self, *args, **kwargs):
    def wrapped(cls):
def resolve_future_dependencies(provider_name=None):
def reset():

\OpenStack\keystone-2014.1\keystone\common\driver_hints.py

class Hints(list):
    def add_filter(self, name, value, comparator='equals', case_sensitive=False):
    def filters(self):
    def get_exact_filter_by_name(self, name):
    def set_limit(self, limit, truncated=False):
    def get_limit(self):

\OpenStack\keystone-2014.1\keystone\common\environment\eventlet_server.py

class Server(object):
    def __init__(self, application, host=None, port=None, threads=1000, keepalive=False, keepidle=None):
    def start(self, key=None, backlog=128):
    def set_ssl(self, certfile, keyfile=None, ca_certs=None, cert_required=True):
    def kill(self):
    def wait(self):
    def _run(self, application, socket):

\OpenStack\keystone-2014.1\keystone\common\environment\__init__.py

def configure_once(name):
def use_eventlet(monkeypatch_thread=None):
def use_stdlib():

\OpenStack\keystone-2014.1\keystone\common\extension.py

def register_admin_extension(url_prefix, extension_data):
def register_public_extension(url_prefix, extension_data):

\OpenStack\keystone-2014.1\keystone\common\kvs\backends\inmemdb.py

class MemoryBackend(api.CacheBackend):
    def __init__(self, arguments):
    def _isolate_value(self, value):
    def get(self, key):
    def get_multi(self, keys):
    def set(self, key, value):
    def set_multi(self, mapping):
    def delete(self, key):
    def delete_multi(self, keys):

\OpenStack\keystone-2014.1\keystone\common\kvs\backends\memcached.py

class MemcachedLock(object):
    def __init__(self, client_fn, key, lock_timeout, max_lock_attempts):
    def acquire(self, wait=True):
    def release(self):
class MemcachedBackend(manager.Manager):
    def __init__(self, arguments):
    def _get_set_arguments_driver_attr(self, exclude_expiry=False):
    def set(self, key, value):
    def set_multi(self, mapping):
    def from_config_dict(cls, config_dict, prefix):
    def key_mangler(self):
    def key_mangler(self, key_mangler):
    def _rehash_keys(self):
    def get_mutex(self, key):

\OpenStack\keystone-2014.1\keystone\common\kvs\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\common\kvs\core.py

def _register_backends():
class LockTimeout(exception.UnexpectedError):
class KeyValueStore(object):
    def __init__(self, kvs_region):
    def configure(self, backing_store, key_mangler=None, proxy_list=None, locking=True, **region_config_args):
    def _apply_region_proxy(self, proxy_list):
    def _assert_configured(self):
    def _set_keymangler_on_backend(self, key_mangler):
    def _set_key_mangler(self, key_mangler):
    def _configure_region(self, backend, **config_args):
    def _mutex(self, key):
    def _create_mutex(self, key):
        def __init__(self, lock_timeout):
        def acquire(self, wait=True):
        def release(self):
    def get(self, key):
    def get_multi(self, keys):
    def set(self, key, value, lock=None):
    def set_multi(self, mapping):
    def delete(self, key, lock=None):
    def delete_multi(self, keys):
    def get_lock(self, key):
    def _action_with_lock(self, key, lock=None):
class KeyValueStoreLock(object):
    def __init__(self, mutex, key, locking_enabled=True):
    def acquire(self):
    def expired(self):
    def release(self):
    def __exit__(self, exc_type, exc_val, exc_tb):
def get_key_value_store(name, kvs_region=None):

\OpenStack\keystone-2014.1\keystone\common\kvs\legacy.py

class DictKvs(dict):
    def get(self, key, default=None):
    def set(self, key, value):
    def delete(self, key):
class Base(object):
    def __init__(self, db=None):

\OpenStack\keystone-2014.1\keystone\common\kvs\__init__.py

\OpenStack\keystone-2014.1\keystone\common\ldap\core.py

def py2ldap(val):
def ldap2py(val):
def safe_iter(attrs):
def parse_deref(opt):
def parse_tls_cert(opt):
def ldap_scope(scope):
def register_handler(prefix, handler):
def get_handler(conn_url):
class BaseLdap(object):
    def __init__(self, conf):
    def _not_found(self, object_id):
    def _parse_extra_attrs(self, option_list):
    def get_connection(self, user=None, password=None):
    def _id_to_dn_string(self, object_id):
    def _id_to_dn(self, object_id):
    def _dn_to_id(dn):
    def _ldap_res_to_model(self, res):
    def check_allow_create(self):
    def check_allow_update(self):
    def check_allow_delete(self):
    def affirm_unique(self, values):
    def create(self, values):
    def _ldap_get(self, object_id, ldap_filter=None):
    def _ldap_get_all(self, ldap_filter=None):
    def get(self, object_id, ldap_filter=None):
    def get_by_name(self, name, ldap_filter=None):
    def get_all(self, ldap_filter=None):
    def update(self, object_id, values, old_obj=None):
    def delete(self, object_id):
    def deleteTree(self, object_id):
class LdapWrapper(object):
    def __init__(self, url, page_size, alias_dereferencing=None, use_tls=False, tls_cacertfile=None, tls_cacertdir=None, tls_req_cert='demand', chase_referrals=None):
    def simple_bind_s(self, user, password):
    def unbind_s(self):
    def add_s(self, dn, attrs):
    def search_s(self, dn, scope, query, attrlist=None):
    def paged_search_s(self, dn, scope, query, attrlist=None):
    def modify_s(self, dn, modlist):
    def delete_s(self, dn):
    def delete_ext_s(self, dn, serverctrls):
    def _disable_paging(self):
class EnabledEmuMixIn(BaseLdap):
    def __init__(self, conf):
    def _get_enabled(self, object_id):
    def _add_enabled(self, object_id):
    def _remove_enabled(self, object_id):
    def create(self, values):
    def get(self, object_id, ldap_filter=None):
    def get_all(self, ldap_filter=None):
    def update(self, object_id, values, old_obj=None):
    def delete(self, object_id):

\OpenStack\keystone-2014.1\keystone\common\ldap\__init__.py

\OpenStack\keystone-2014.1\keystone\common\manager.py

def response_truncated(f):
 def wrapper(self, *args, **kwargs):
class Manager(object):
    def __init__(self, driver_name):
    def __getattr__(self, name):
        def _wrapper(*args, **kw):

\OpenStack\keystone-2014.1\keystone\common\models.py

class Model(dict):
    def __hash__(self):
    def known_keys(cls):
class Token(Model):
class Service(Model):
class Endpoint(Model):
class User(Model):
class Group(Model):
class Project(Model):
class Role(Model):
class Trust(Model):
class Domain(Model):

\OpenStack\keystone-2014.1\keystone\common\openssl.py

def file_exists(file_path):
class BaseCertificateConfigure(object):
    def __init__(self, conf_obj, keystone_user, keystone_group, **kwargs):
    def exec_command(self, command):
    def build_ssl_config_file(self):
    def build_ca_cert(self):
    def build_private_key(self):
    def build_signing_cert(self):
    def run(self):
class ConfigurePKI(BaseCertificateConfigure):
    def __init__(self, keystone_user, keystone_group):
class ConfigureSSL(BaseCertificateConfigure):
    def __init__(self, keystone_user, keystone_group):

\OpenStack\keystone-2014.1\keystone\common\pemutils.py

class PEMParseResult(object):
    def __init__(self, pem_type=None, pem_header=None, pem_start=None, pem_end=None, base64_start=None, base64_end=None, binary_data=None):
    def pem_type(self):
    def pem_type(self, pem_type):
    def pem_header(self):
    def pem_header(self, pem_header):
def pem_search(text, start=0):
def parse_pem(text, pem_type=None, max_items=None):
def get_pem_data(text, pem_type='cert'):
def is_pem(text, pem_type='cert'):
def base64_to_pem(base64_text, pem_type='cert'):
def binary_to_pem(binary_data, pem_type='cert'):

\OpenStack\keystone-2014.1\keystone\common\router.py

class Router(wsgi.ComposableRouter):
    def __init__(self, controller, collection_key, key):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\common\serializer.py

def from_xml(xml):
def to_xml(d, xmlns=None):
class XmlDeserializer(object):
    def __call__(self, xml_str):
    def _deserialize_links(self, links):
    def _qualified_name(tag, namespace):
    def walk_element(self, element, namespace=False):
class XmlSerializer(object):
    def __call__(self, d, xmlns=None):
    def _populate_links(self, element, links_json):
    def _populate_truncated(self, element, truncated_value):
    def _populate_list(self, element, k, v):
    def _populate_dict(self, element, k, v):
    def _populate_bool(self, element, k, v):
    def _populate_str(self, element, k, v):
    def _populate_number(self, element, k, v):
    def populate_element(self, element, value):
    def _populate_sequence(self, element, l):
    def _populate_tree(self, element, d):

\OpenStack\keystone-2014.1\keystone\common\sql\core.py

def initialize():
def initialize_decorator(init):
 def initialize(self, *args, **kwargs):
class JsonBlob(sql_types.TypeDecorator):
    def process_bind_param(self, value, dialect):
    def process_result_value(self, value, dialect):
class DictBase(models.ModelBase):
    def from_dict(cls, d):
    def to_dict(self, include_extra_dict=False):
    def __getitem__(self, key):
class ModelDictMixin(object):
    def from_dict(cls, d):
    def to_dict(self):
def _get_engine_facade():
def cleanup():
def get_engine():
def get_session(expire_on_commit=False):
def transaction(expire_on_commit=False):
def truncated(f):
    def wrapper(self, hints, *args, **kwargs):
def _filter(model, query, hints):
    def inexact_filter(model, query, filter_, hints):
    def exact_filter(model, filter_, cumulative_filter_dict, hints):
def _limit(query, hints):
def filter_limit_query(model, query, hints):
def handle_conflicts(conflict_type='object'):
    def decorator(method):
        def wrapper(*args, **kwargs):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\manage.py

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\001_add_initial_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\002_token_id_hash.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\003_token_valid.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\004_undo_token_id_hash.py

def downgrade(migrate_engine):
def upgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\005_set_utf8_character_set.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\006_add_policy_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\007_add_domain_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\008_create_default_domain.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\009_normalize_identity.py

def downgrade_user_table_with_copy(meta, migrate_engine):
def downgrade_tenant_table_with_copy(meta, migrate_engine):
def downgrade_user_table_with_column_drop(meta, migrate_engine):
def downgrade_tenant_table_with_column_drop(meta, migrate_engine):
def upgrade_user_table(meta, migrate_engine):
def upgrade_tenant_table(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\010_normalize_identity_migration.py

def is_enabled(enabled):
def downgrade_user_table(meta, migrate_engine, session):
def downgrade_tenant_table(meta, migrate_engine, session):
def upgrade_user_table(meta, migrate_engine, session):
def upgrade_tenant_table(meta, migrate_engine, session):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\011_endpoints_v3.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\012_populate_endpoint_type.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\013_drop_legacy_endpoints.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\014_add_group_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\015_tenant_to_project.py

def rename_with_constraints(meta, legacy_project_table_name, new_project_table_name, legacy_user_project_membership_table_name, new_user_project_membership_table_name):
def upgrade_with_rename(meta, migrate_engine):
def downgrade_with_rename(meta, migrate_engine):
def upgrade_with_copy(meta, migrate_engine):
def downgrade_with_copy(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\016_normalize_domain_ids.py

def _disable_foreign_constraints(session, migrate_engine):
def _enable_foreign_constraints(session, migrate_engine):
def upgrade_user_table_with_copy(meta, migrate_engine, session):
def upgrade_project_table_with_copy(meta, migrate_engine, session):
def downgrade_user_table_with_copy(meta, migrate_engine, session):
def downgrade_project_table_with_copy(meta, migrate_engine, session):
def upgrade_user_table_with_col_create(meta, migrate_engine, session):
def upgrade_project_table_with_col_create(meta, migrate_engine, session):
def downgrade_user_table_with_col_drop(meta, migrate_engine, session):
def downgrade_project_table_with_col_drop(meta, migrate_engine, session):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\017_membership_role.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\018_add_trust_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\019_fixup_role.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\020_migrate_metadata_table_roles.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\021_add_trust_to_token.py

def downgrade_token_table_with_column_drop(meta, migrate_engine):
def create_column_forgiving(migrate_engine, table, column):
def upgrade_token_table(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\022_move_legacy_endpoint_id.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\023_drop_credential_constraints.py

def list_constraints(migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\024_add_index_to_expires.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\025_add_index_to_valid.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\026_drop_user_group_constraints.py

def list_constraints(migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\027_set_engine_mysql_innodb.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\028_fixup_group_metadata.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\029_update_assignment_metadata.py

def build_update(table_name, upgrade_table, row, values):
def upgrade_grant_table(meta, migrate_engine, session, table_name):
def downgrade_grant_table(meta, migrate_engine, session, table_name):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\030_drop_credential_constraint_sqlite.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):
def drop_credential_table_foreign_key_constraints_for_sqlite(migrate_engine):
def add_credential_table_foreign_key_constraints_for_sqlite(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\031_drop_credential_indexes.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\032_username_length.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\033_migrate_ec2credentials_table_credentials.py

def upgrade(migrate_engine):
def check_credential_exists(ec2credential, credential_table, session):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\034_add_default_project_id_column_to_user.py

def migrate_default_project_from_extra_json(meta, migrate_engine):
def migrate_default_project_to_extra_json(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\035_add_compound_revoked_token_index.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\036_token_drop_valid_index.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\037_add_region_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\038_add_assignment_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\039_grant_to_assignment.py

def migrate_grant_table(meta, migrate_engine, session, table_name):
def downgrade_assignment_table(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\040_drop_grant_tables.py

def recreate_grant_tables(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\041_add_remaining_uses_count_to_trusts.py

def downgrade_trust_table_with_column_drop(meta, migrate_engine):
def upgrade_trust_table(meta, migrate_engine):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\042_endpoint_enabled.py

def _migrate_enabled_from_extra(migrate_engine, endpoint_table):
def _migrate_enabled_to_extra(migrate_engine, endpoint_table):
def upgrade(migrate_engine):
def _downgrade_endpoint_table_with_copy(meta, migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\043_fixup_region_description.py

def _migrate_to_new_region_table(meta, migrate_engine, region_table):
def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\044_service_enabled.py

def _migrate_enabled_from_extra(migrate_engine, service_table):
def _migrate_enabled_to_extra(migrate_engine, service_table):
def upgrade(migrate_engine):
def _downgrade_service_table_with_copy(meta, migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\common\sql\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\common\sql\migration_helpers.py

def get_constraints_names(table, column_name):
def remove_constraints(constraints):
def add_constraints(constraints):
def rename_tables_with_constraints(renames, constraints, engine):
def find_migrate_repo(package=None, repo_name='migrate_repo'):
def sync_database_to_version(extension=None, version=None):
def get_db_version(extension=None):
def print_db_version(extension=None):

\OpenStack\keystone-2014.1\keystone\common\sql\__init__.py

\OpenStack\keystone-2014.1\keystone\common\systemd.py

def _sd_notify(msg):
def notify():

\OpenStack\keystone-2014.1\keystone\common\utils.py

def read_cached_file(filename, cache_info, reload_func=None):
class SmarterEncoder(json.JSONEncoder):
    def default(self, obj):
def trunc_password(password):
def hash_access_key(access):
def hash_user_password(user):
def hash_ldap_user_password(user):
def hash_password(password):
def ldap_hash_password(password):
def ldap_check_password(password, hashed):
def check_password(password, hashed):
def attr_as_boolean(val_attr):
def check_output(*popenargs, **kwargs):
def get_blob_from_credential(credential):
def convert_ec2_to_v3_credential(ec2credential):
def convert_v3_to_ec2_credential(credential):
def git(*args):
def unixtime(dt_obj):
def auth_str_equal(provided, known):
def setup_remote_pydev_debug():
class LimitingReader(object):
    def __init__(self, data, limit):
    def __iter__(self):
    def read(self, i=None):
def get_unix_user(user=None):
def get_unix_group(group=None):
def set_permissions(path, mode=None, user=None, group=None, log=None):
def make_dirs(path, mode=None, user=None, group=None, log=None):

\OpenStack\keystone-2014.1\keystone\common\wsgi.py

def validate_token_bind(context, token_ref):
def best_match_language(req):
class BaseApplication(object):
    def factory(cls, global_config, **local_config):
    def __call__(self, environ, start_response):
        def __call__(self, req):
class Application(BaseApplication):
    def __call__(self, req):
    def _get_response_code(self, req):
    def _normalize_arg(self, arg):
    def _normalize_dict(self, d):
    def assert_admin(self, context):
    def _require_attribute(self, ref, attr):
    def _get_trust_id_for_request(self, context):
    def base_url(cls, context, endpoint_type):
class Middleware(Application):
    def factory(cls, global_config, **local_config):
        def _factory(app):
    def __init__(self, application):
    def process_request(self, request):
    def process_response(self, request, response):
    def __call__(self, request):
class Debug(Middleware):
    def __call__(self, req):
    def print_generator(app_iter):
class Router(object):
    def __init__(self, mapper):
    def __call__(self, req):
    def _dispatch(req):
class ComposingRouter(Router):
    def __init__(self, mapper=None, routers=None):
class ComposableRouter(Router):
    def __init__(self, mapper=None):
    def add_routes(self, mapper):
class ExtensionRouter(Router):
    def __init__(self, application, mapper=None):
    def add_routes(self, mapper):
    def factory(cls, global_config, **local_config):
        def _factory(app):

\OpenStack\keystone-2014.1\keystone\common\__init__.py

\OpenStack\keystone-2014.1\keystone\config.py

def set_default_for_default_log_levels():
def setup_logging():
def find_paste_config():

\OpenStack\keystone-2014.1\keystone\contrib\access\core.py

class AccessLogMiddleware(wsgi.Middleware):
    def __init__(self, *args, **kwargs):
    def __call__(self, request):

\OpenStack\keystone-2014.1\keystone\contrib\access\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\admin_crud\core.py

class CrudExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\admin_crud\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\ec2\controllers.py

class Ec2ControllerCommon(object):
    def check_signature(self, creds_ref, credentials):
    def authenticate(self, context, credentials=None, ec2Credentials=None):
    def _authenticate(self, credentials=None, ec2credentials=None):
    def create_credential(self, context, user_id, tenant_id):
    def get_credentials(self, user_id):
    def get_credential(self, user_id, credential_id):
    def delete_credential(self, user_id, credential_id):
    def _convert_v3_to_ec2_credential(credential):
    def _get_credentials(self, credential_id):
class Ec2Controller(Ec2ControllerCommon, controller.V2Controller):
    def authenticate(self, context, credentials=None, ec2Credentials=None):
    def get_credential(self, context, user_id, credential_id):
    def get_credentials(self, context, user_id):
    def create_credential(self, context, user_id, tenant_id):
    def delete_credential(self, context, user_id, credential_id):
    def _assert_identity(self, context, user_id):
    def _is_admin(self, context):
    def _assert_owner(self, user_id, credential_id):
class Ec2ControllerV3(Ec2ControllerCommon, controller.V3Controller):
    def __init__(self):
    def _check_credential_owner_and_user_id_match(self, context, prep_info, user_id, credential_id):
    def authenticate(self, context, credentials=None, ec2Credentials=None):
    def ec2_get_credential(self, context, user_id, credential_id):
    def ec2_list_credentials(self, context, user_id):
    def ec2_create_credential(self, context, user_id, tenant_id):
    def ec2_delete_credential(self, context, user_id, credential_id):
def render_token_data_response(token_id, token_data):

\OpenStack\keystone-2014.1\keystone\contrib\ec2\core.py

\OpenStack\keystone-2014.1\keystone\contrib\ec2\routers.py

class Ec2Extension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):
class Ec2ExtensionV3(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\ec2\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\backends\catalog_sql.py

class EndpointFilterCatalog(sql.Catalog):
    def get_v3_catalog(self, user_id, project_id, metadata=None):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\backends\sql.py

class ProjectEndpoint(sql.ModelBase, sql.DictBase):
class EndpointFilter(object):
    def db_sync(self, version=None):
    def add_endpoint_to_project(self, endpoint_id, project_id):
    def _get_project_endpoint_ref(self, session, endpoint_id, project_id):
    def check_endpoint_in_project(self, endpoint_id, project_id):
    def remove_endpoint_from_project(self, endpoint_id, project_id):
    def list_endpoints_for_project(self, project_id):
    def list_projects_for_endpoint(self, endpoint_id):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\controllers.py

class EndpointFilterV3Controller(controller.V3Controller):
    def add_endpoint_to_project(self, context, project_id, endpoint_id):
    def check_endpoint_in_project(self, context, project_id, endpoint_id):
    def list_endpoints_for_project(self, context, project_id):
    def remove_endpoint_from_project(self, context, project_id, endpoint_id):
    def list_projects_for_endpoint(self, context, endpoint_id):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\core.py

class Manager(manager.Manager):
    def __init__(self):
class Driver(object):
    def add_endpoint_to_project(self, endpoint_id, project_id):
    def remove_endpoint_from_project(self, endpoint_id, project_id):
    def check_endpoint_in_project(self, endpoint_id, project_id):
    def list_endpoints_for_project(self, project_id):
    def list_projects_for_endpoint(self, endpoint_id):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\migrate_repo\versions\001_add_endpoint_filtering_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\routers.py

class EndpointFilterExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\endpoint_filter\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\example\controllers.py

class ExampleV3Controller(controller.V3Controller):
    def example_get(self, context):

\OpenStack\keystone-2014.1\keystone\contrib\example\core.py

class ExampleManager(manager.Manager):
    def __init__(self):
    def project_deleted_callback(self, service, resource_type, operation, payload):
    def project_created_callback(self, service, resource_type, operation, payload):
class ExampleDriver(object):
    def do_something(self, data):

\OpenStack\keystone-2014.1\keystone\contrib\example\migrate_repo\versions\001_example_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\example\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\example\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\example\routers.py

class ExampleRouter(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\example\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\federation\backends\sql.py

class FederationProtocolModel(sql.ModelBase, sql.DictBase):
    def from_dict(cls, dictionary):
    def to_dict(self):
class IdentityProviderModel(sql.ModelBase, sql.DictBase):
    def from_dict(cls, dictionary):
    def to_dict(self, include_extra_dict=False):
class MappingModel(sql.ModelBase, sql.DictBase):
    def from_dict(cls, dictionary):
    def to_dict(self):
class Federation(core.Driver):
    def db_sync(self):
    def create_idp(self, idp_id, idp):
    def delete_idp(self, idp_id):
    def _get_idp(self, session, idp_id):
    def list_idps(self):
    def get_idp(self, idp_id):
    def update_idp(self, idp_id, idp):
    def _get_protocol(self, session, idp_id, protocol_id):
    def create_protocol(self, idp_id, protocol_id, protocol):
    def update_protocol(self, idp_id, protocol_id, protocol):
    def get_protocol(self, idp_id, protocol_id):
    def list_protocols(self, idp_id):
    def delete_protocol(self, idp_id, protocol_id):
    def _get_mapping(self, session, mapping_id):
    def create_mapping(self, mapping_id, mapping):
    def delete_mapping(self, mapping_id):
    def list_mappings(self):
    def get_mapping(self, mapping_id):
    def update_mapping(self, mapping_id, mapping):
    def get_mapping_from_idp_and_protocol(self, idp_id, protocol_id):

\OpenStack\keystone-2014.1\keystone\contrib\federation\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\federation\controllers.py

class _ControllerBase(controller.V3Controller):
    def base_url(cls, context, path=None):
class IdentityProvider(_ControllerBase):
    def _add_related_links(cls, context, ref):
    def _add_self_referential_link(cls, context, ref):
    def wrap_member(cls, context, ref):
    def _delete_tokens_issued_by_idp(self, idp_id):
    def create_identity_provider(self, context, idp_id, identity_provider):
    def list_identity_providers(self, context):
    def get_identity_provider(self, context, idp_id):
    def delete_identity_provider(self, context, idp_id):
    def update_identity_provider(self, context, idp_id, identity_provider):
class FederationProtocol(_ControllerBase):
    def _add_self_referential_link(cls, context, ref):
    def _add_related_links(cls, context, ref):
    def wrap_member(cls, context, ref):
    def create_protocol(self, context, idp_id, protocol_id, protocol):
    def update_protocol(self, context, idp_id, protocol_id, protocol):
    def get_protocol(self, context, idp_id, protocol_id):
    def list_protocols(self, context, idp_id):
    def delete_protocol(self, context, idp_id, protocol_id):
class MappingController(_ControllerBase):
    def create_mapping(self, context, mapping_id, mapping):
    def list_mappings(self, context):
    def get_mapping(self, context, mapping_id):
    def delete_mapping(self, context, mapping_id):
    def update_mapping(self, context, mapping_id, mapping):
class Auth(auth_controllers.Auth):
    def federated_authentication(self, context, identity_provider, protocol):
class DomainV3(controller.V3Controller):
    def __init__(self):
    def list_domains_for_groups(self, context):
class ProjectV3(controller.V3Controller):
    def __init__(self):
    def list_projects_for_groups(self, context):

\OpenStack\keystone-2014.1\keystone\contrib\federation\core.py

class Manager(manager.Manager):
    def __init__(self):
class Driver(object):
    def create_idp(self, idp_id, idp):
    def delete_idp(self, idp_id):
    def list_idps(self):
    def get_idp(self, idp_id):
    def update_idp(self, idp_id, idp):
    def create_protocol(self, idp_id, protocol_id, protocol):
    def update_protocol(self, idp_id, protocol_id, protocol):
    def get_protocol(self, idp_id, protocol_id):
    def list_protocols(self, idp_id):
    def delete_protocol(self, idp_id, protocol_id):
    def create_mapping(self, mapping_ref):
    def delete_mapping(self, mapping_id):
    def update_mapping(self, mapping_id, mapping_ref):
    def list_mappings(self):
    def get_mapping(self, mapping_id):
    def get_mapping_from_idp_and_protocol(self, idp_id, protocol_id):

\OpenStack\keystone-2014.1\keystone\contrib\federation\migrate_repo\versions\001_add_identity_provider_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\federation\migrate_repo\versions\002_add_mapping_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\federation\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\federation\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\federation\routers.py

class FederationExtension(wsgi.ExtensionRouter):
    def _construct_url(self, suffix):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\federation\utils.py

def validate_mapping_structure(ref):
class RuleProcessor(object):
    def __init__(self, rules):
    def process(self, assertion_data):
    def _transform(self, identity_values):
    def _update_local_mapping(self, local, direct_maps):
    def _verify_all_requirements(self, requirements, assertion):
    def _evaluate_requirement(self, values, requirement_type, eval_type, regex, assertion):

\OpenStack\keystone-2014.1\keystone\contrib\federation\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\backends\sql.py

class Consumer(sql.ModelBase, sql.DictBase):
class RequestToken(sql.ModelBase, sql.DictBase):
    def from_dict(cls, user_dict):
    def to_dict(self):
class AccessToken(sql.ModelBase, sql.DictBase):
    def from_dict(cls, user_dict):
    def to_dict(self):
class OAuth1(object):
    def db_sync(self):
    def _get_consumer(self, session, consumer_id):
    def get_consumer_with_secret(self, consumer_id):
    def get_consumer(self, consumer_id):
    def create_consumer(self, consumer):
    def _delete_consumer(self, session, consumer_id):
    def _delete_request_tokens(self, session, consumer_id):
    def _delete_access_tokens(self, session, consumer_id):
    def delete_consumer(self, consumer_id):
    def list_consumers(self):
    def update_consumer(self, consumer_id, consumer):
    def create_request_token(self, consumer_id, project_id, token_duration, request_token_id=None, request_token_secret=None):
    def _get_request_token(self, session, request_token_id):
    def get_request_token(self, request_token_id):
    def authorize_request_token(self, request_token_id, user_id, role_ids):
    def create_access_token(self, request_token_id, token_duration, access_token_id=None, access_token_secret=None):
    def _get_access_token(self, session, access_token_id):
    def get_access_token(self, access_token_id):
    def list_access_tokens(self, user_id):
    def delete_access_token(self, user_id, access_token_id):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\controllers.py

class ConsumerCrudV3(controller.V3Controller):
    def base_url(cls, context, path=None):
    def create_consumer(self, context, consumer):
    def update_consumer(self, context, consumer_id, consumer):
    def list_consumers(self, context):
    def get_consumer(self, context, consumer_id):
    def delete_consumer(self, context, consumer_id):
    def _validate_consumer_ref(self, consumer):
class AccessTokenCrudV3(controller.V3Controller):
    def get_access_token(self, context, user_id, access_token_id):
    def list_access_tokens(self, context, user_id):
    def delete_access_token(self, context, user_id, access_token_id):
    def _format_token_entity(self, context, entity):
class AccessTokenRolesV3(controller.V3Controller):
    def list_access_token_roles(self, context, user_id, access_token_id):
    def get_access_token_role(self, context, user_id, access_token_id, role_id):
    def _format_role_entity(self, role_id):
class OAuthControllerV3(controller.V3Controller):
    def create_request_token(self, context):
    def create_access_token(self, context):
    def authorize_request_token(self, context, request_token_id, roles):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\core.py

class Token(object):
    def __init__(self, key, secret):
    def set_verifier(self, verifier):
def token_generator(*args, **kwargs):
def filter_consumer(consumer_ref):
def filter_token(access_token_ref):
def get_oauth_headers(headers):
def extract_non_oauth_params(query_string):
class Manager(manager.Manager):
    def __init__(self):
    def create_consumer(self, consumer_ref):
    def update_consumer(self, consumer_id, consumer_ref):
    def delete_consumer(self, consumer_id):
    def create_access_token(self, request_id, access_token_duration):
    def delete_access_token(self, user_id, access_token_id):
    def create_request_token(self, consumer_id, requested_project, request_token_duration):
class Driver(object):
    def create_consumer(self, consumer_ref):
    def update_consumer(self, consumer_id, consumer_ref):
    def list_consumers(self):
    def get_consumer(self, consumer_id):
    def get_consumer_with_secret(self, consumer_id):
    def delete_consumer(self, consumer_id):
    def list_access_tokens(self, user_id):
    def delete_access_token(self, user_id, access_token_id):
    def create_request_token(self, consumer_id, requested_project, request_token_duration):
    def get_request_token(self, request_token_id):
    def get_access_token(self, access_token_id):
    def authorize_request_token(self, request_id, user_id, role_ids):
    def create_access_token(self, request_id, access_token_duration):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\versions\001_add_oauth_tables.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\versions\002_fix_oauth_tables_fk.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\versions\003_consumer_description_nullalbe.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\versions\004_request_token_roles_nullable.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\routers.py

class OAuth1Extension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\validator.py

class OAuthValidator(oauth1.RequestValidator):
    def enforce_ssl(self):
    def safe_characters(self):
    def _check_token(self, token):
    def check_client_key(self, client_key):
    def check_request_token(self, request_token):
    def check_access_token(self, access_token):
    def check_nonce(self, nonce):
    def check_verifier(self, verifier):
    def get_client_secret(self, client_key, request):
    def get_request_token_secret(self, client_key, token, request):
    def get_access_token_secret(self, client_key, token, request):
    def get_default_realms(self, client_key, request):
    def get_realms(self, token, request):
    def get_redirect_uri(self, token, request):
    def get_rsa_key(self, client_key, request):
    def invalidate_request_token(self, client_key, request_token, request):
    def validate_client_key(self, client_key, request):
    def validate_request_token(self, client_key, token, request):
    def validate_access_token(self, client_key, token, request):
    def validate_timestamp_and_nonce(self, client_key, timestamp, nonce, request, request_token=None, access_token=None):
    def validate_redirect_uri(self, client_key, redirect_uri, request):
    def validate_requested_realms(self, client_key, realms, request):
    def validate_realms(self, client_key, token, request, uri=None, realms=None):
    def validate_verifier(self, client_key, token, verifier, request):
    def verify_request_token(self, token, request):
    def verify_realms(self, token, realms, request):
    def save_access_token(self, token, request):
    def save_request_token(self, token, request):
    def save_verifier(self, token, verifier, request):

\OpenStack\keystone-2014.1\keystone\contrib\oauth1\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\revoke\backends\kvs.py

class Revoke(revoke.Driver):
    def __init__(self, **kwargs):
    def _get_event(self):
    def _prune_expired_events_and_get(self, last_fetch=None, new_event=None):
    def get_events(self, last_fetch=None):
    def revoke(self, event):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\backends\sql.py

class RevocationEvent(sql.ModelBase, sql.ModelDictMixin):
class Revoke(revoke.Driver):
    def _flush_batch_size(self, dialect):
    def _prune_expired_events(self):
    def get_events(self, last_fetch=None):
    def revoke(self, event):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\revoke\controllers.py

class RevokeController(controller.V3Controller):
    def list_revoke_events(self, context):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\core.py

def revoked_before_cutoff_time():
class Manager(manager.Manager):
    def __init__(self):
    def _user_callback(self, service, resource_type, operation, payload):
    def _role_callback(self, service, resource_type, operation, payload):
    def _project_callback(self, service, resource_type, operation, payload):
    def _domain_callback(self, service, resource_type, operation, payload):
    def _trust_callback(self, service, resource_type, operation, payload):
    def _consumer_callback(self, service, resource_type, operation, payload):
    def _access_token_callback(self, service, resource_type, operation, payload):
    def _register_listeners(self):
    def revoke_by_user(self, user_id):
    def revoke_by_expiration(self, user_id, expires_at):
    def revoke_by_grant(self, role_id, user_id=None, domain_id=None, project_id=None):
    def revoke_by_user_and_project(self, user_id, project_id):
    def revoke_by_project_role_assignment(self, project_id, role_id):
    def revoke_by_domain_role_assignment(self, domain_id, role_id):
    def _get_revoke_tree(self):
    def check_token(self, token_values):
    def revoke(self, event):
class Driver(object):
    def get_events(self, last_fetch=None):
    def revoke(self, event):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\migrate_repo\versions\001_revoke_table.py

def upgrade(migrate_engine):
def downgrade(migrate_engine):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\migrate_repo\versions\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\revoke\migrate_repo\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\revoke\model.py

def blank_token_data(issued_at):
class RevokeEvent(object):
    def __init__(self, **kwargs):
    def to_dict(self):
    def key_for_name(self, name):
def attr_keys(event):
class RevokeTree(object):
    def __init__(self, revoke_events=None):
    def add_event(self, event):
    def remove_event(self, event):
    def add_events(self, revoke_events):
    def is_revoked(self, token_data):
def build_token_values_v2(access, default_domain_id):
def build_token_values(token_data):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\routers.py

class RevokeExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\revoke\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\s3\core.py

class S3Extension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):
class S3Controller(controllers.Ec2Controller):
    def check_signature(self, creds_ref, credentials):

\OpenStack\keystone-2014.1\keystone\contrib\s3\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\simple_cert\controllers.py

class SimpleCert(controller.V3Controller):
    def _get_certificate(self, name):
    def get_ca_certificate(self, context):
    def list_certificates(self, context):

\OpenStack\keystone-2014.1\keystone\contrib\simple_cert\core.py

\OpenStack\keystone-2014.1\keystone\contrib\simple_cert\routers.py

class SimpleCertExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\simple_cert\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\stats\backends\kvs.py

class Stats(kvs.Base, stats.Driver):
    def get_stats(self, api):
    def set_stats(self, api, stats_ref):
    def increment_stat(self, api, category, value):

\OpenStack\keystone-2014.1\keystone\contrib\stats\backends\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\stats\core.py

class Manager(manager.Manager):
    def __init__(self):
class Driver(object):
    def get_stats(self, api):
    def set_stats(self, api, stats_ref):
    def increment_stat(self, api, category, value):
class StatsExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):
class StatsController(wsgi.Application):
    def __init__(self):
    def get_stats(self, context):
    def reset_stats(self, context):
class StatsMiddleware(wsgi.Middleware):
    def __init__(self, *args, **kwargs):
    def _resolve_api(self, host):
    def capture_stats(self, host, obj, attributes):
    def process_request(self, request):
    def process_response(self, request, response):

\OpenStack\keystone-2014.1\keystone\contrib\stats\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\user_crud\core.py

class UserController(identity.controllers.User):
    def set_user_password(self, context, user_id, user):
class CrudExtension(wsgi.ExtensionRouter):
    def add_routes(self, mapper):

\OpenStack\keystone-2014.1\keystone\contrib\user_crud\__init__.py

\OpenStack\keystone-2014.1\keystone\contrib\__init__.py