OpenStack Study: keystone
OpenStack IndexPreviousNext
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 IndexPreviousNext
|
