OpenStack Study: keystone

OpenStack Index

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

class Assignment(kvs.Base, assignment.Driver):

def get_project(self, tenant_id):

def _build_project_refs(self):

def list_projects(self, hints):

def list_projects_in_domain(self, domain_id):

def get_project_by_name(self, tenant_name, domain_id):

def list_user_ids_for_project(self, tenant_id):

def _get_metadata(self, user_id=None, tenant_id=None, domain_id=None, group_id=None):

def get_role(self, role_id):

def list_roles(self, hints):

def _list_roles(self):

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 add_role_to_user_and_project(self, user_id, tenant_id, role_id):

def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):

def list_role_assignments(self):

def create_project(self, tenant_id, tenant):

def update_project(self, tenant_id, tenant):

def delete_project(self, tenant_id):

def _create_metadata(self, user_id, tenant_id, metadata, domain_id=None, group_id=None):

def _update_metadata(self, user_id, tenant_id, metadata, domain_id=None, group_id=None):

def create_role(self, role_id, role):

def update_role(self, role_id, role):

def delete_role(self, role_id):

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):

def create_domain(self, domain_id, domain):

def list_domains(self, hints):

def get_domain(self, domain_id):

def get_domain_by_name(self, domain_name):

def update_domain(self, domain_id, domain):

def delete_domain(self, domain_id):

def delete_user(self, user_id):

def delete_group(self, group_id):

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

class Assignment(assignment.Driver):

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):

class ProjectApi(common_ldap.EnabledEmuMixIn, common_ldap.BaseLdap):

def __init__(self, conf):

def create(self, values):

def get_user_projects(self, user_dn, associations):

def add_user(self, tenant_id, user_dn):

def remove_user(self, tenant_id, user_dn, user_id):

def get_user_dns(self, tenant_id, rolegrants, role_dn=None):

def update(self, project_id, values):

class UserRoleAssociation(object):

def __init__(self, user_dn=None, role_dn=None, tenant_dn=None, *args, **kw):

class GroupRoleAssociation(object):

def __init__(self, group_dn=None, role_dn=None, tenant_dn=None, *args, **kw):

class RoleApi(common_ldap.BaseLdap):

def __init__(self, conf):

def get(self, role_id, role_filter=None):

def create(self, values):

def add_user(self, role_id, role_dn, user_dn, user_id, tenant_id=None):

def delete_user(self, role_dn, user_dn, tenant_dn, user_id, role_id):

def get_role_assignments(self, tenant_dn):

def list_global_roles_for_user(self, user_dn):

def list_project_roles_for_user(self, user_dn, project_subtree):

def roles_delete_subtree_by_project(self, tenant_dn):

def update(self, role_id, role):

def delete(self, role_id, tenant_dn):

def list_role_assignments(self, project_tree_dn):

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

class Assignment(assignment.Driver):

def db_sync(self, version=None):

def _get_project(self, session, project_id):

def get_project(self, tenant_id):

def get_project_by_name(self, tenant_name, domain_id):

def list_user_ids_for_project(self, tenant_id):

def _get_metadata(self, user_id=None, tenant_id=None, domain_id=None, group_id=None, session=None):

def create_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):

def calculate_type(user_id, group_id, project_id, domain_id):

def list_grants(self, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):

def _build_grant_filter(self, session, role_id, user_id, group_id, domain_id, project_id, inherited_to_projects):

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_projects(self, hints):

def list_projects_in_domain(self, domain_id):

def list_projects_for_user(self, user_id, group_ids, hints):

def _project_ids_to_dicts(session, ids):

def get_roles_for_groups(self, group_ids, project_id=None, domain_id=None):

def _list_entities_for_groups(self, group_ids, entity):

def list_projects_for_groups(self, group_ids):

def list_domains_for_groups(self, group_ids):

def add_role_to_user_and_project(self, user_id, tenant_id, role_id):

def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):

def list_role_assignments(self):

def denormalize_role(ref):

def create_project(self, tenant_id, tenant):

def update_project(self, tenant_id, tenant):

def delete_project(self, tenant_id):

def create_domain(self, domain_id, domain):

def list_domains(self, hints):

def _get_domain(self, session, domain_id):

def get_domain(self, domain_id):

def get_domain_by_name(self, domain_name):

def update_domain(self, domain_id, domain):

def delete_domain(self, domain_id):

def create_role(self, role_id, role):

def list_roles(self, hints):

def _get_role(self, session, role_id):

def get_role(self, role_id):

def update_role(self, role_id, role):

def delete_role(self, role_id):

def delete_user(self, user_id):

def delete_group(self, group_id):

class Domain(sql.ModelBase, sql.DictBase):

class Project(sql.ModelBase, sql.DictBase):

class Role(sql.ModelBase, sql.DictBase):

class RoleAssignment(sql.ModelBase, sql.DictBase):

def to_dict(self):

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

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

class Tenant(controller.V2Controller):

def get_all_projects(self, context, **kw):

def get_projects_for_token(self, context, **kw):

def get_project(self, context, tenant_id):

def get_project_by_name(self, context, tenant_name):

def create_project(self, context, tenant):

def update_project(self, context, tenant_id, tenant):

def delete_project(self, context, tenant_id):

def get_project_users(self, context, tenant_id, **kw):

def _format_project_list(self, tenant_refs, **kwargs):

class Role(controller.V2Controller):

def get_user_roles(self, context, user_id, tenant_id=None):

def get_role(self, context, role_id):

def create_role(self, context, role):

def delete_role(self, context, role_id):

def get_roles(self, context):

def add_role_to_user(self, context, user_id, role_id, tenant_id=None):

def remove_role_from_user(self, context, user_id, role_id, tenant_id=None):

def get_role_refs(self, context, user_id):

def create_role_ref(self, context, user_id, role):

def delete_role_ref(self, context, user_id, role_ref_id):

class DomainV3(controller.V3Controller):

def __init__(self):

def create_domain(self, context, domain):

def list_domains(self, context, filters):

def get_domain(self, context, domain_id):

def update_domain(self, context, domain_id, domain):

def delete_domain(self, context, domain_id):

class ProjectV3(controller.V3Controller):

def __init__(self):

def create_project(self, context, project):

def list_projects(self, context, filters):

def list_user_projects(self, context, filters, user_id):

def get_project(self, context, project_id):

def update_project(self, context, project_id, project):

def delete_project(self, context, project_id):

class RoleV3(controller.V3Controller):

def __init__(self):

def create_role(self, context, role):

def list_roles(self, context, filters):

def get_role(self, context, role_id):

def update_role(self, context, role_id, role):

def delete_role(self, context, role_id):

def _require_domain_xor_project(self, domain_id, project_id):

def _require_user_xor_group(self, user_id, group_id):

def _check_if_inherited(self, context):

def _check_grant_protection(self, context, protection, role_id=None, user_id=None, group_id=None, domain_id=None, project_id=None):

def create_grant(self, context, role_id, user_id=None, group_id=None, domain_id=None, project_id=None):

def list_grants(self, context, user_id=None, group_id=None, domain_id=None, project_id=None):

def check_grant(self, context, role_id, user_id=None, group_id=None, domain_id=None, project_id=None):

def revoke_grant(self, context, role_id, user_id=None, group_id=None, domain_id=None, project_id=None):

class RoleAssignmentV3(controller.V3Controller):

def wrap_member(cls, context, ref):

def _format_entity(self, context, entity):

def _expand_indirect_assignments(self, context, refs):

def _get_group_members(ref):

def _build_user_assignment_equivalent_of_group( user, group_id, template):

def _build_project_equivalent_of_user_domain_role( project_id, domain_id, template):

def _build_project_equivalent_of_group_domain_role( user_id, group_id, project_id, domain_id, template):

def _query_filter_is_true(self, filter_value):

def _filter_inherited(self, entry):

def list_role_assignments(self, context, filters):

def get_role_assignment(self, context):

def update_role_assignment(self, context):

def delete_role_assignment(self, context):

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

def calc_default_domain():

class Manager(manager.Manager):

def __init__(self):

def create_project(self, tenant_id, tenant):

def _disable_project(self, tenant_id):

def update_project(self, tenant_id, tenant):

def delete_project(self, tenant_id):

def get_roles_for_user_and_project(self, user_id, tenant_id):

def _get_group_project_roles(user_id, project_ref):

def _get_user_project_roles(user_id, project_ref):

def get_roles_for_user_and_domain(self, user_id, domain_id):

def _get_group_domain_roles(user_id, domain_id):

def _get_user_domain_roles(user_id, domain_id):

def add_user_to_project(self, tenant_id, user_id):

def remove_user_from_project(self, tenant_id, user_id):

def list_projects_for_user(self, user_id, hints=None):

def get_domain(self, domain_id):

def get_domain_by_name(self, domain_name):

def create_domain(self, domain_id, domain):

def list_domains(self, hints=None):

def _disable_domain(self, domain_id):

def update_domain(self, domain_id, domain):

def delete_domain(self, domain_id):

def _delete_domain_contents(self, domain_id):

def list_projects(self, hints=None):

def list_projects_in_domain(self, domain_id):

def list_user_projects(self, user_id, hints=None):

def get_project(self, project_id):

def get_project_by_name(self, tenant_name, domain_id):

def get_role(self, role_id):

def create_role(self, role_id, role):

def list_roles(self, hints=None):

def update_role(self, role_id, role):

def delete_role(self, role_id):

def list_role_assignments_for_role(self, role_id=None):

def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):

def delete_grant(self, role_id, user_id=None, group_id=None, domain_id=None, project_id=None, inherited_to_projects=False):

def _delete_tokens_for_role(self, role_id):

class Driver(object):

def _role_to_dict(self, role_id, inherited):

def _roles_from_role_dicts(self, dict_list, inherited):

def _add_role_to_role_dicts(self, role_id, inherited, dict_list, allow_existing=True):

def _remove_role_from_role_dicts(self, role_id, inherited, dict_list):

def _get_list_limit(self):

def get_project_by_name(self, tenant_name, domain_id):

def list_user_ids_for_project(self, tenant_id):

def add_role_to_user_and_project(self, user_id, tenant_id, role_id):

def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):

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):

def list_role_assignments(self):

def create_domain(self, domain_id, domain):

def list_domains(self, hints):

def get_domain(self, domain_id):

def get_domain_by_name(self, domain_name):

def update_domain(self, domain_id, domain):

def delete_domain(self, domain_id):

def create_project(self, project_id, project):

def list_projects(self, hints):

def list_projects_in_domain(self, domain_id):

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 get_project(self, project_id):

def update_project(self, project_id, project):

def delete_project(self, project_id):

def create_role(self, role_id, role):

def list_roles(self, hints):

def get_role(self, role_id):

def update_role(self, role_id, role):

def delete_role(self, role_id):

def delete_user(self, user_id):

def delete_group(self, group_id):

def _set_default_domain(self, ref):

def _validate_default_domain(self, ref):

def _validate_default_domain_id(self, domain_id):

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

class Public(wsgi.ComposableRouter):

def add_routes(self, mapper):

class Admin(wsgi.ComposableRouter):

def add_routes(self, mapper):

def append_v3_routers(mapper, routers):

\OpenStack\keystone-2014.1\keystone\assignment\init.py

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

def load_auth_methods():

def get_auth_method(method_name):

class AuthInfo(object):

def create(context, auth=None):

def __init__(self, context, auth=None):

def _assert_project_is_enabled(self, project_ref):

def _assert_domain_is_enabled(self, domain_ref):

def _lookup_domain(self, domain_info):

def _lookup_project(self, project_info):

def _lookup_trust(self, trust_info):

def _validate_and_normalize_scope_data(self):

def _validate_auth_methods(self):

def _validate_and_normalize_auth_data(self):

def get_method_names(self):

def get_method_data(self, method):

def get_scope(self):

def set_scope(self, domain_id=None, project_id=None, trust=None):

class Auth(controller.V3Controller):

def __init__(self, *args, **kw):

def authenticate_for_token(self, context, auth=None):

def _check_and_set_default_scoping(self, auth_info, auth_context):

def authenticate(self, context, auth_info, auth_context):

def check_token(self, context):

def revoke_token(self, context):

def validate_token(self, context):

def revocation_list(self, context, auth=None):

def render_token_data_response(token_id, token_data, created=False):

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

class AuthMethodHandler(object):

def __init__(self):

def authenticate(self, context, auth_payload, auth_context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\external.py

class Base(auth.AuthMethodHandler):

def authenticate(self, context, auth_info, auth_context):

def _authenticate(self, remote_user, context):

class DefaultDomain(Base):

def _authenticate(self, remote_user, context):

class Domain(Base):

def _authenticate(self, remote_user, context):

class ExternalDefault(DefaultDomain):

def __init__(self):

class ExternalDomain(Domain):

def __init__(self):

class LegacyDefaultDomain(Base):

def __init__(self):

def _authenticate(self, remote_user, context):

class LegacyDomain(Base):

def __init__(self):

def _authenticate(self, remote_user, context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\oauth1.py

class OAuth(auth.AuthMethodHandler):

def authenticate(self, context, auth_info, auth_context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\password.py

class UserAuthInfo(object):

def create(auth_payload):

def __init__(self):

def _assert_domain_is_enabled(self, domain_ref):

def _assert_user_is_enabled(self, user_ref):

def _lookup_domain(self, domain_info):

def _validate_and_normalize_auth_data(self, auth_payload):

class Password(auth.AuthMethodHandler):

def authenticate(self, context, auth_payload, user_context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\saml2.py

class Saml2(auth.AuthMethodHandler):

def authenticate(self, context, auth_payload, auth_context):

def _handle_scoped_token(self, auth_payload):

def _handle_unscoped_token(self, context, auth_payload):

def _validate_expiration(self, token_ref):

def _validate_groups(self, group_ids, mapping_id):

def _get_assertion_params_from_env(self, context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\token.py

class Token(auth.AuthMethodHandler):

def __init__(self):

def authenticate(self, context, auth_payload, user_context):

\OpenStack\keystone-2014.1\keystone\auth\plugins\init.py

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

def append_v3_routers(mapper, routers):

\OpenStack\keystone-2014.1\keystone\auth\init.py

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

class Catalog(kvs.Base, catalog.Driver):

def get_catalog(self, user_id, tenant_id, metadata=None):

def _delete_child_regions(self, region_id):

def _check_parent_region(self, region_ref):

def create_region(self, region):

def list_regions(self):

def get_region(self, region_id):

def update_region(self, region_id, region):

def delete_region(self, region_id):

def create_service(self, service_id, service):

def list_services(self, hints):

def get_service(self, service_id):

def update_service(self, service_id, service):

def delete_service(self, service_id):

def create_endpoint(self, endpoint_id, endpoint):

def list_endpoints(self, hints):

def get_endpoint(self, endpoint_id):

def update_endpoint(self, endpoint_id, endpoint):

def delete_endpoint(self, endpoint_id):

def _create_catalog(self, user_id, tenant_id, data):

def get_v3_catalog(self, user_id, tenant_id, metadata=None):

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

class Region(sql.ModelBase, sql.DictBase):

class Service(sql.ModelBase, sql.DictBase):

class Endpoint(sql.ModelBase, sql.DictBase):

class Catalog(catalog.Driver):

def db_sync(self, version=None):

def list_regions(self):

def _get_region(self, session, region_id):

def _delete_child_regions(self, session, region_id):

def _check_parent_region(self, session, region_ref):

def get_region(self, region_id):

def delete_region(self, region_id):

def create_region(self, region_ref):

def update_region(self, region_id, region_ref):

def list_services(self, hints):

def _get_service(self, session, service_id):

def get_service(self, service_id):

def delete_service(self, service_id):

def create_service(self, service_id, service_ref):

def update_service(self, service_id, service_ref):

def create_endpoint(self, endpoint_id, endpoint_ref):

def delete_endpoint(self, endpoint_id):

def _get_endpoint(self, session, endpoint_id):

def get_endpoint(self, endpoint_id):

def list_endpoints(self, hints):

def update_endpoint(self, endpoint_id, endpoint_ref):

def get_catalog(self, user_id, tenant_id, metadata=None):

def get_v3_catalog(self, user_id, tenant_id, metadata=None):

def make_v3_endpoint(endpoint):

\OpenStack\keystone-2014.1\keystone\catalog\backends\templated.py

def parse_templates(template_lines):

class Catalog(kvs.Catalog):

def __init__(self, templates=None):

def _load_templates(self, template_file):

def get_catalog(self, user_id, tenant_id, metadata=None):

def get_v3_catalog(self, user_id, tenant_id, metadata=None):

class TemplatedCatalog(Catalog):

\OpenStack\keystone-2014.1\keystone\catalog\backends\init.py

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

class Service(controller.V2Controller):

def get_services(self, context):

def get_service(self, context, service_id):

def delete_service(self, context, service_id):

def create_service(self, context, OS_KSADM_service):

class Endpoint(controller.V2Controller):

def get_endpoints(self, context):

def create_endpoint(self, context, endpoint):

def delete_endpoint(self, context, endpoint_id):

class RegionV3(controller.V3Controller):

def create_region_with_id(self, context, region_id, region):

def create_region(self, context, region):

def list_regions(self, context):

def get_region(self, context, region_id):

def update_region(self, context, region_id, region):

def delete_region(self, context, region_id):

class ServiceV3(controller.V3Controller):

def __init__(self):

def _validate_service(self, service):

def create_service(self, context, service):

def list_services(self, context, filters):

def get_service(self, context, service_id):

def update_service(self, context, service_id, service):

def delete_service(self, context, service_id):

class EndpointV3(controller.V3Controller):

def __init__(self):

def filter_endpoint(cls, ref):

def wrap_member(cls, context, ref):

def _validate_endpoint(self, endpoint):

def create_endpoint(self, context, endpoint):

def list_endpoints(self, context, filters):

def get_endpoint(self, context, endpoint_id):

def update_endpoint(self, context, endpoint_id, endpoint):

def delete_endpoint(self, context, endpoint_id):

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

def format_url(url, data):

class Manager(manager.Manager):

def __init__(self):

def create_region(self, region_ref):

def get_region(self, region_id):

def delete_region(self, region_id):

def create_service(self, service_id, service_ref):

def get_service(self, service_id):

def delete_service(self, service_id):

def list_services(self, hints=None):

def create_endpoint(self, endpoint_id, endpoint_ref):

def delete_endpoint(self, endpoint_id):

def get_endpoint(self, endpoint_id):

def list_endpoints(self, hints=None):

def get_catalog(self, user_id, tenant_id, metadata=None):

class Driver(object):

def _get_list_limit(self):

def create_region(self, region_ref):

def list_regions(self):

def get_region(self, region_id):

def update_region(self, region_id):

def delete_region(self, region_id):

def create_service(self, service_id, service_ref):

def list_services(self):

def get_service(self, service_id):

def update_service(self, service_id):

def delete_service(self, service_id):

def create_endpoint(self, endpoint_id, endpoint_ref):

def get_endpoint(self, endpoint_id):

def list_endpoints(self):

def update_endpoint(self, endpoint_id, endpoint_ref):

def delete_endpoint(self, endpoint_id):

def get_catalog(self, user_id, tenant_id, metadata=None):

def get_v3_catalog(self, user_id, tenant_id, metadata=None):

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

def append_v3_routers(mapper, routers):

\OpenStack\keystone-2014.1\keystone\catalog\init.py

\OpenStack\keystone-2014.1\keystone\clean.py

def check_length(property_name, value, min_length=1, max_length=64):

def check_type(property_name, value, expected_type, display_expected_type):

def check_enabled(property_name, enabled):

def check_name(property_name, name, min_length=1, max_length=64):

def domain_name(name):

def project_name(name):

def project_enabled(enabled):

def user_name(name):

def user_enabled(enabled):

def group_name(name):

\OpenStack\keystone-2014.1\keystone\cli.py

class BaseApp(object):

def add_argument_parser(cls, subparsers):

class DbSync(BaseApp):

def add_argument_parser(cls, subparsers):

def main():

class DbVersion(BaseApp):

def add_argument_parser(cls, subparsers):

def main():

class BaseCertificateSetup(BaseApp):

def add_argument_parser(cls, subparsers):

def get_user_group():

class PKISetup(BaseCertificateSetup):

def main(cls):

class SSLSetup(BaseCertificateSetup):

def main(cls):

class TokenFlush(BaseApp):

def main(cls):

def add_command_parsers(subparsers):

def main(argv=None, config_files=None):

\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 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):

OpenStack Study: keystone

Next

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

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

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

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

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

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

\OpenStack\keystone-2014.1\keystone\clean.py

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

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

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

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

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

Next