@

Home 

OpenStack Study: keystone

OpenStack Index

Next

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

OpenStack Index

Next