@

Home 

OpenStack Study: keystone

OpenStack Index

Previous

Next

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-2014.1\keystone\middleware\core.py

class TokenAuthMiddleware(wsgi.Middleware):

    def process_request(self, request):

class AdminTokenAuthMiddleware(wsgi.Middleware):

    def process_request(self, request):

class PostParamsMiddleware(wsgi.Middleware):

    def process_request(self, request):

class JsonBodyMiddleware(wsgi.Middleware):

    def process_request(self, request):

class XmlBodyMiddleware(wsgi.Middleware):

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

    def process_request(self, request):

    def process_response(self, request, response):

class XmlBodyMiddlewareV2(XmlBodyMiddleware):

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

class XmlBodyMiddlewareV3(XmlBodyMiddleware):

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

class NormalizingFilter(wsgi.Middleware):

    def process_request(self, request):

class RequestBodySizeLimiter(wsgi.Middleware):

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

    def __call__(self, req):

class AuthContextMiddleware(wsgi.Middleware):

    def _build_auth_context(self, request):

    def process_request(self, request):

\OpenStack\keystone-2014.1\keystone\middleware\ec2_token.py

class EC2Token(wsgi.Middleware):

    def __call__(self, req):

\OpenStack\keystone-2014.1\keystone\middleware\s3_token.py

class S3Token(s3_token.S3Token):

    def __init__(self, app, conf):

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

\OpenStack\keystone-2014.1\keystone\notifications.py

class ManagerNotificationWrapper(object):

    def __init__(self, operation, resource_type, public=True, resource_id_arg_index=1):

    def __call__(self, f):

        def wrapper(*args, **kwargs):

class CadfNotificationWrapper(object):

    def __init__(self, action):

    def __call__(self, f):

        def wrapper(wrapped_self, context, user_id, *args, **kwargs):

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

def generate(argv):

def _import_module(mod_str):

def _is_in_group(opt, group):

def _guess_groups(opt, mod_obj):

def _list_opts(obj):

def print_group_opts(group, opts_by_module):

def _get_my_ip():

def _sanitize_default(name, value):

def _print_opt(opt):

def main():

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

\OpenStack\keystone-2014.1\keystone\openstack\common\context.py

def generate_request_id():

class RequestContext(object):

    def __init__(self, auth_token=None, user=None, tenant=None, domain=None, user_domain=None, project_domain=None, is_admin=False, read_only=False, show_deleted=False, request_id=None, instance_uuid=None):

    def to_dict(self):

def get_admin_context(show_deleted=False):

def get_context_from_function_and_args(function, args, kwargs):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\api.py

def safe_for_db_retry(f):

class wrap_db_retry(object):

    def __init__(self, retry_interval, max_retries, inc_retry_interval, max_retry_interval):

    def __call__(self, f):

        def wrapper(*args, **kwargs):

class DBAPI(object):

    def __init__(self, backend_name, backend_mapping=None, lazy=False, **kwargs):

    def _load_backend(self):

    def __getattr__(self, key):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\exception.py

class DBError(Exception):

    def __init__(self, inner_exception=None):

class DBDuplicateEntry(DBError):

    def __init__(self, columns=[], inner_exception=None):

class DBDeadlock(DBError):

    def __init__(self, inner_exception=None):

class DBInvalidUnicodeParameter(Exception):

class DbMigrationError(DBError):

    def __init__(self, message=None):

class DBConnectionError(DBError):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\options.py

def set_defaults(sql_connection, sqlite_db, max_pool_size=None, max_overflow=None, pool_timeout=None):

def list_opts():

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\migration.py

def _get_unique_constraints(self, table):

def _recreate_table(self, table, column=None, delta=None, omit_uniques=None):

def _visit_migrate_unique_constraint(self, *p, **k):

def patch_migrate():

def db_sync(engine, abs_path, version=None, init_version=0, sanity_check=True):

def _db_schema_sanity_check(engine):

def db_version(engine, abs_path, init_version):

def db_version_control(engine, abs_path, version=None):

def _find_migrate_repo(abs_path):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\models.py

class ModelBase(six.Iterator):

    def save(self, session):

    def __setitem__(self, key, value):

    def __getitem__(self, key):

    def get(self, key, default=None):

    def _extra_keys(self):

    def __iter__(self):

    def __next__(self):

    def next(self):

    def update(self, values):

    def iteritems(self):

class TimestampMixin(object):

class SoftDeleteMixin(object):

    def soft_delete(self, session):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\provision.py

def get_engine(uri):

def _execute_sql(engine, sql, driver):

def create_database(engine):

def drop_database(admin_engine, current_uri):

def main():

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\session.py

class SqliteForeignKeysListener(PoolListener):

    def connect(self, dbapi_con, con_record):

def _raise_if_duplicate_entry_error(integrity_error, engine_name):

    def get_columns_from_uniq_cons_or_name(columns):

def _raise_if_deadlock_error(operational_error, engine_name):

def _wrap_db_error(f):

    def _wrap(self, *args, **kwargs):

def _synchronous_switch_listener(dbapi_conn, connection_rec):

def _add_regexp_listener(dbapi_con, con_record):

    def regexp(expr, item):

def _thread_yield(dbapi_con, con_record):

def _ping_listener(engine, dbapi_conn, connection_rec, connection_proxy):

def _set_session_sql_mode(dbapi_con, connection_rec, sql_mode=None):

def _mysql_get_effective_sql_mode(engine):

def _mysql_check_effective_sql_mode(engine):

def _mysql_set_mode_callback(engine, sql_mode):

def _is_db_connection_error(args):

def _raise_if_db_connection_lost(error, engine):

def create_engine(sql_connection, sqlite_fk=False, mysql_sql_mode=None, idle_timeout=3600, connection_debug=0, max_pool_size=None, max_overflow=None, pool_timeout=None, sqlite_synchronous=True, connection_trace=False, max_retries=10, retry_interval=10):

class Query(sqlalchemy.orm.query.Query):

    def soft_delete(self, synchronize_session='evaluate'):

class Session(sqlalchemy.orm.session.Session):

    def query(self, *args, **kwargs):

    def flush(self, *args, **kwargs):

    def execute(self, *args, **kwargs):

def get_maker(engine, autocommit=True, expire_on_commit=False):

def _patch_mysqldb_with_stacktrace_comments():

    def _do_query(self, q):

class EngineFacade(object):

    def __init__(self, sql_connection, sqlite_fk=False, autocommit=True, expire_on_commit=False, **kwargs):

    def get_engine(self):

    def get_session(self, **kwargs):

    def from_config(cls, connection_string, conf, sqlite_fk=False, autocommit=True, expire_on_commit=False):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\test_base.py

class DbFixture(fixtures.Fixture):

    def _get_uri(self):

    def __init__(self, test):

    def setUp(self):

class DbTestCase(test.BaseTestCase):

    def setUp(self):

def backend_specific(*dialects):

    def wrap(f):

        def ins_wrap(self):

class OpportunisticFixture(DbFixture):

    def _get_uri(self):

class OpportunisticTestCase(DbTestCase):

    def setUp(self):

class MySQLOpportunisticFixture(OpportunisticFixture):

class PostgreSQLOpportunisticFixture(OpportunisticFixture):

class MySQLOpportunisticTestCase(OpportunisticTestCase):

class PostgreSQLOpportunisticTestCase(OpportunisticTestCase):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\test_migrations.py

def _have_mysql(user, passwd, database):

def _have_postgresql(user, passwd, database):

def _set_db_lock(lock_path=None, lock_prefix=None):

 def decorator(f):

class BaseMigrationTestCase(test.BaseTestCase):

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

    def setUp(self):

    def tearDown(self):

    def execute_cmd(self, cmd=None):

    def _reset_pg(self, conn_pieces):

    def _reset_databases(self):

class WalkVersionsMixin(object):

    def _walk_versions(self, engine=None, snake_walk=False, downgrade=True):

    def _migrate_down(self, engine, version, with_data=False):

    def _migrate_up(self, engine, version, with_data=False):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\utils.py

def sanitize_db_url(url):

class InvalidSortKey(Exception):

def paginate_query(query, model, limit, sort_keys, marker=None, sort_dir=None, sort_dirs=None):

def _read_deleted_filter(query, db_model, read_deleted):

def _project_filter(query, db_model, context, project_only):

def model_query(context, model, session, args=None, project_only=False, read_deleted=None):

def get_table(engine, name):

class InsertFromSelect(UpdateBase):

    def __init__(self, table, select):

def visit_insert_from_select(element, compiler, **kw):

class ColumnError(Exception):

    def is_deleted_column_constraint(constraint):

def get_connect_string(backend, database, user=None, passwd=None):

def is_backend_avail(backend, database, user=None, passwd=None):

def get_db_connection_info(conn_pieces):

\OpenStack\keystone-2014.1\keystone\openstack\common\db\sqlalchemy\__init__.py

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

\OpenStack\keystone-2014.1\keystone\openstack\common\eventlet_backdoor.py

class EventletBackdoorConfigValueError(Exception):

    def __init__(self, port_range, help_msg, ex):

def _dont_use_this():

def _find_objects(t):

def _print_greenthreads():

def _print_nativethreads():

def _parse_port_range(port_range):

def _listen(host, start_port, end_port, listen_func):

def initialize_if_enabled():

    def displayhook(val):

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

class Error(Exception):

    def __init__(self, message=None):

class ApiError(Error):

    def __init__(self, message='Unknown', code='Unknown'):

class NotFound(Error):

class UnknownScheme(Error):

    def __init__(self, scheme):

class BadStoreUri(Error):

    def __init__(self, uri, reason):

class Duplicate(Error):

class NotAuthorized(Error):

class NotEmpty(Error):

class Invalid(Error):

class BadInputError(Exception):

class MissingArgumentError(Error):

class DatabaseMigrationError(Error):

class ClientConnectionError(Exception):

    def _wrap(*args, **kw):

class OpenstackException(Exception):

    def __init__(self, **kwargs):

    def __str__(self):

class MalformedRequestBody(OpenstackException):

class InvalidContentType(OpenstackException):

\OpenStack\keystone-2014.1\keystone\openstack\common\excutils.py

class save_and_reraise_exception(object):

    def __init__(self):

    def __enter__(self):

    def __exit__(self, exc_type, exc_val, exc_tb):

def forever_retry_uncaught_exceptions(infunc):

    def inner_func(*args, **kwargs):

\OpenStack\keystone-2014.1\keystone\openstack\common\fileutils.py

def ensure_tree(path):

def read_cached_file(filename, force_reload=False):

def delete_if_exists(path, remove=os.unlink):

def remove_path_on_error(path, remove=delete_if_exists):

def file_open(*args, **kwargs):

def write_to_tempfile(content, path=None, suffix='', prefix='tmp'):

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

class Config(fixtures.Fixture):

    def __init__(self, conf=cfg.CONF):

    def setUp(self):

    def config(self, **kw):

    def _unregister_config_opts(self):

    def register_opt(self, opt, group=None):

    def register_opts(self, opts, group=None):

\OpenStack\keystone-2014.1\keystone\openstack\common\fixture\lockutils.py

class LockFixture(fixtures.Fixture):

    def __init__(self, name, lock_file_prefix=None):

    def setUp(self):

\OpenStack\keystone-2014.1\keystone\openstack\common\fixture\mockpatch.py

class PatchObject(fixtures.Fixture):

    def __init__(self, obj, attr, new=mock.DEFAULT, **kwargs):

    def setUp(self):

class Patch(fixtures.Fixture):

    def __init__(self, obj, new=mock.DEFAULT, **kwargs):

    def setUp(self):

\OpenStack\keystone-2014.1\keystone\openstack\common\fixture\moxstubout.py

class MoxStubout(fixtures.Fixture):

    def setUp(self):

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

\OpenStack\keystone-2014.1\keystone\openstack\common\gettextutils.py

def enable_lazy():

def _(msg):

def _log_translation(msg, level):

def install(domain, lazy=False):

class Message(six.text_type):

    def __new__(cls, msgid, msgtext=None, params=None, domain='keystone', *args):

    def translate(self, desired_locale=None):

    def _translate_msgid(msgid, domain, desired_locale=None):

    def __mod__(self, other):

    def _sanitize_mod_params(self, other):

    def _trim_dictionary_parameters(self, dict_param):

    def _copy_param(self, param):

    def __add__(self, other):

    def __radd__(self, other):

    def __str__(self):

def get_available_languages(domain):

def translate(obj, desired_locale=None):

def _translate_args(args, desired_locale=None):

class TranslationHandler(handlers.MemoryHandler):

    def __init__(self, locale=None, target=None):

    def setFormatter(self, fmt):

    def emit(self, record):

    def _translate_and_log_record(self, record):

\OpenStack\keystone-2014.1\keystone\openstack\common\importutils.py

def import_class(import_str):

def import_object(import_str, *args, **kwargs):

def import_object_ns(name_space, import_str, *args, **kwargs):

def import_module(import_str):

def try_import(import_str, default=None):

\OpenStack\keystone-2014.1\keystone\openstack\common\jsonutils.py

def to_primitive(value, convert_instances=False, convert_datetime=True, level=0, max_depth=3):

def dumps(value, default=to_primitive, **kwargs):

def loads(s):

def load(s):

\OpenStack\keystone-2014.1\keystone\openstack\common\local.py

class WeakLocal(threading.local):

    def __getattribute__(self, attr):

    def __setattr__(self, attr, value):

\OpenStack\keystone-2014.1\keystone\openstack\common\lockutils.py

def set_defaults(lock_path):

class _InterProcessLock(object):

    def __init__(self, name):

    def __enter__(self):

    def __exit__(self, exc_type, exc_val, exc_tb):

    def trylock(self):

    def unlock(self):

class _WindowsLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

class _PosixLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

        def foo(self, *args):

        def foo(self, *args):

        def bar(self, *args):

    def wrap(f):

        def inner(*args, **kwargs):

        def bar(self, *args):

\OpenStack\keystone-2014.1\keystone\openstack\common\log.py

def _dictify_context(context):

def _get_binary_name():

def _get_log_file_path(binary=None):

def mask_password(message, secret="***"):

class BaseLoggerAdapter(logging.LoggerAdapter):

    def audit(self, msg, *args, **kwargs):

class LazyAdapter(BaseLoggerAdapter):

    def __init__(self, name='unknown', version='unknown'):

    def logger(self):

class ContextAdapter(BaseLoggerAdapter):

    def __init__(self, logger, project_name, version_string):

    def handlers(self):

    def deprecated(self, msg, *args, **kwargs):

    def process(self, msg, kwargs):

class JSONFormatter(logging.Formatter):

    def __init__(self, fmt=None, datefmt=None):

    def formatException(self, ei, strip_newlines=True):

    def format(self, record):

def _create_logging_excepthook(product_name):

    def logging_excepthook(exc_type, value, tb):

class LogConfigError(Exception):

    def __init__(self, log_config, err_msg):

    def __str__(self):

def _load_log_config(log_config_append):

def setup(product_name, version='unknown'):

def set_defaults(logging_context_format_string):

def _find_facility_from_conf():

class RFCSysLogHandler(logging.handlers.SysLogHandler):

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

    def format(self, record):

def _setup_logging_from_conf(project, version):

def getLogger(name='unknown', version='unknown'):

def getLazyLogger(name='unknown', version='unknown'):

class WritableLogger(object):

    def __init__(self, logger, level=logging.INFO):

    def write(self, msg):

class ContextFormatter(logging.Formatter):

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

    def format(self, record):

    def formatException(self, exc_info, record=None):

class ColorHandler(logging.StreamHandler):

    def format(self, record):

class DeprecatedConfig(Exception):

    def __init__(self, msg):

\OpenStack\keystone-2014.1\keystone\openstack\common\loopingcall.py

class LoopingCallDone(Exception):

    def __init__(self, retvalue=True):

class LoopingCallBase(object):

    def __init__(self, f=None, *args, **kw):

    def stop(self):

    def wait(self):

class FixedIntervalLoopingCall(LoopingCallBase):

    def start(self, interval, initial_delay=None):

        def _inner():

class DynamicLoopingCall(LoopingCallBase):

    def start(self, initial_delay=None, periodic_interval_max=None):

        def _inner():

\OpenStack\keystone-2014.1\keystone\openstack\common\network_utils.py

def parse_host_port(address, default_port=None):

def urlsplit(url, scheme='', allow_fragments=True):

\OpenStack\keystone-2014.1\keystone\openstack\common\policy.py

class PolicyNotAuthorized(Exception):

    def __init__(self, rule):

class Rules(dict):

    def load_json(cls, data, default_rule=None):

    def __init__(self, rules=None, default_rule=None):

    def __missing__(self, key):

    def __str__(self):

class Enforcer(object):

    def __init__(self, policy_file=None, rules=None, default_rule=None):

    def set_rules(self, rules, overwrite=True):

    def clear(self):

    def load_rules(self, force_reload=False):

    def _get_policy_path(self):

    def enforce(self, rule, target, creds, do_raise=False, exc=None, *args, **kwargs):

class BaseCheck(object):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

class FalseCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

class TrueCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

class Check(BaseCheck):

    def __init__(self, kind, match):

    def __str__(self):

class NotCheck(BaseCheck):

    def __init__(self, rule):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

class AndCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

    def add_check(self, rule):

class OrCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred, enforcer):

    def add_check(self, rule):

def _parse_check(rule):

def _parse_list_rule(rule):

def _parse_tokenize(rule):

class ParseStateMeta(type):

    def __new__(mcs, name, bases, cls_dict):

def reducer(*tokens):

    def decorator(func):

class ParseState(object):

    def __init__(self):

    def reduce(self):

    def shift(self, tok, value):

    def result(self):

    def _wrap_check(self, _p1, check, _p2):

    def _make_and_expr(self, check1, _and, check2):

    def _extend_and_expr(self, and_expr, _and, check):

    def _make_or_expr(self, check1, _or, check2):

    def _extend_or_expr(self, or_expr, _or, check):

    def _make_not_expr(self, _not, check):

def _parse_text_rule(rule):

def parse_rule(rule):

def register(name, func=None):

    def decorator(func):

class RuleCheck(Check):

    def __call__(self, target, creds, enforcer):

class RoleCheck(Check):

    def __call__(self, target, creds, enforcer):

class HttpCheck(Check):

    def __call__(self, target, creds, enforcer):

class GenericCheck(Check):

    def __call__(self, target, creds, enforcer):

\OpenStack\keystone-2014.1\keystone\openstack\common\processutils.py

class InvalidArgumentError(Exception):

    def __init__(self, message=None):

class UnknownArgumentError(Exception):

    def __init__(self, message=None):

class ProcessExecutionError(Exception):

    def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None, description=None):

class NoRootWrapSpecified(Exception):

    def __init__(self, message=None):

def _subprocess_setup():

def execute(*cmd, **kwargs):

def trycmd(*args, **kwargs):

def ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True):

\OpenStack\keystone-2014.1\keystone\openstack\common\py3kcompat\urlutils.py

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

\OpenStack\keystone-2014.1\keystone\openstack\common\service.py

def _sighup_supported():

def _is_sighup(signo):

def _signo_to_signame(signo):

def _set_signals_handler(handler):

class Launcher(object):

    def __init__(self):

    def launch_service(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

class SignalExit(SystemExit):

    def __init__(self, signo, exccode=1):

class ServiceLauncher(Launcher):

    def _handle_signal(self, signo, frame):

    def handle_signal(self):

    def _wait_for_exit_or_signal(self, ready_callback=None):

    def wait(self, ready_callback=None):

class ServiceWrapper(object):

    def __init__(self, service, workers):

class ProcessLauncher(object):

    def __init__(self):

    def handle_signal(self):

    def _handle_signal(self, signo, frame):

    def _pipe_watcher(self):

    def _child_process_handle_signal(self):

        def _sigterm(*args):

        def _sighup(*args):

    def _child_wait_for_exit_or_signal(self, launcher):

    def _child_process(self, service):

    def _start_child(self, wrap):

    def launch_service(self, service, workers=1):

    def _wait_child(self):

    def _respawn_children(self):

    def wait(self):

class Service(object):

    def __init__(self, threads=1000):

    def reset(self):

    def start(self):

    def stop(self):

    def wait(self):

class Services(object):

    def __init__(self):

    def add(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

    def run_service(service, done):

def launch(service, workers=None):

\OpenStack\keystone-2014.1\keystone\openstack\common\strutils.py

def int_from_bool_as_string(subject):

def bool_from_string(subject, strict=False, default=False):

def safe_decode(text, incoming=None, errors='strict'):

def safe_encode(text, incoming=None, encoding='utf-8', errors='strict'):

def to_bytes(text, default=0):

def to_slug(value, incoming=None, errors="strict"):

\OpenStack\keystone-2014.1\keystone\openstack\common\test.py

class BaseTestCase(testtools.TestCase):

    def setUp(self):

    def _set_timeout(self):

    def _fake_output(self):

\OpenStack\keystone-2014.1\keystone\openstack\common\threadgroup.py

def _thread_done(gt, *args, **kwargs):

class Thread(object):

    def __init__(self, thread, group):

    def stop(self):

    def wait(self):

    def link(self, func, *args, **kwargs):

class ThreadGroup(object):

    def __init__(self, thread_pool_size=10):

    def add_dynamic_timer(self, callback, initial_delay=None, periodic_interval_max=None, *args, **kwargs):

    def add_timer(self, interval, callback, initial_delay=None, *args, **kwargs):

    def add_thread(self, callback, *args, **kwargs):

    def thread_done(self, thread):

    def stop(self):

    def wait(self):

\OpenStack\keystone-2014.1\keystone\openstack\common\timeutils.py

def isotime(at=None, subsecond=False):

def parse_isotime(timestr):

def strtime(at=None, fmt=PERFECT_TIME_FORMAT):

def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT):

def normalize_time(timestamp):

def is_older_than(before, seconds):

def is_newer_than(after, seconds):

def utcnow_ts():

def utcnow():

def iso8601_from_timestamp(timestamp):

def set_time_override(override_time=None):

def advance_time_delta(timedelta):

def advance_time_seconds(seconds):

def clear_time_override():

def marshall_now(now=None):

def unmarshall_time(tyme):

def delta_seconds(before, after):

def total_seconds(delta):

def is_soon(dt, window):

\OpenStack\keystone-2014.1\keystone\openstack\common\uuidutils.py

def generate_uuid():

def is_uuid_like(val):

\OpenStack\keystone-2014.1\keystone\openstack\common\versionutils.py

class deprecated(object):

    def __init__(self, as_of, in_favor_of=None, remove_in=2, what=None):

    def __call__(self, func):

        def wrapped(*args, **kwargs):

    def _get_safe_to_remove_release(self, release):

    def _build_message(self):

def is_compatible(requested_version, current_version, same_major=True):

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

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

\OpenStack\keystone-2014.1\keystone\policy\backends\rules.py

def reset():

def init():

def _set_rules(data):

def enforce(credentials, action, target, do_raise=True):

class Policy(policy.Driver):

    def enforce(self, credentials, action, target):

    def create_policy(self, policy_id, policy):

    def list_policies(self):

    def get_policy(self, policy_id):

    def update_policy(self, policy_id, policy):

    def delete_policy(self, policy_id):

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

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

class Policy(rules.Policy):

    def db_sync(self, version=None):

    def create_policy(self, policy_id, policy):

    def list_policies(self):

    def _get_policy(self, session, policy_id):

    def get_policy(self, policy_id):

    def update_policy(self, policy_id, policy):

    def delete_policy(self, policy_id):

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

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

class PolicyV3(controller.V3Controller):

    def create_policy(self, context, policy):

    def list_policies(self, context, filters):

    def get_policy(self, context, policy_id):

    def update_policy(self, context, policy_id, policy):

    def delete_policy(self, context, policy_id):

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

class Manager(manager.Manager):

    def __init__(self):

    def get_policy(self, policy_id):

    def update_policy(self, policy_id, policy):

    def list_policies(self, hints=None):

OpenStack Index

Previous

Next