def register_models(options):
"""Register Models and create properties"""
supported_memcache_models = ast.literal_eval(options["backend_entities"])
for supported_memcache_model in supported_memcache_models:
model = utils.import_module(MODEL_PREFIX + supported_memcache_model)
top_models.set_value(supported_memcache_model, model)
if model.__api__ != None:
model_api = utils.import_module(API_PREFIX + model.__api__)
top_api.set_value(model.__api__, model_api.get())
def register_models(options):
"""Register Models and create properties"""
supported_memcache_models = ast.literal_eval(
options["backend_entities"])
for supported_memcache_model in supported_memcache_models:
model = utils.import_module(MODEL_PREFIX + supported_memcache_model)
top_models.set_value(supported_memcache_model, model)
if model.__api__ is not None:
model_api = utils.import_module(API_PREFIX + model.__api__)
top_api.set_value(model.__api__, model_api.get())
def _init_models(self, model_list):
for model in model_list:
model_path = '.'.join([__package__, 'models', model])
module = utils.import_module(model_path)
top_models.set_value(model, module)
if module.__api__ is not None:
api_path = '.'.join([__package__, 'api', module.__api__])
api_module = utils.import_module(api_path)
top_api.set_value(module.__api__, api_module.get())
def setUp(self, options=None): # pylint: disable=W0221
super(BackendTestCase, self).setUp()
# Set up root options if missing
if options is None:
options = {
'backends': None,
"keystone-service-admin-role": "KeystoneServiceAdmin",
"keystone-admin-role": "KeystoneAdmin",
"hash-password": "******"
}
# set up default backend if none supplied
if 'backends' not in options or options['backends'] is None:
options['backends'] = 'keystone.backends.sqlalchemy'
if 'keystone.backends.sqlalchemy' not in options:
options['keystone.backends.sqlalchemy'] = {
"sql_connection": "sqlite://",
"backend_entities": "['UserRoleAssociation', 'Endpoints',\
'Role', 'Tenant', 'User',\
'Credentials', 'EndpointTemplates',\
'Token', 'Service']",
"sql_idle_timeout": "30"
}
# Init backends module constants (without initializing backends)
no_backend_init = options.copy()
no_backend_init['backends'] = None
reload(backends)
backends.configure_backends(no_backend_init)
backend_list = options['backends']
for backend in backend_list.split(','):
backend_module = utils.import_module(backend)
settings = options[backend]
backend_module.configure_backend(settings)
def setUp(self, options=None): # pylint: disable=W0221
super(BackendTestCase, self).setUp()
# Set up root options if missing
if options is None:
options = {
"backends": None,
"keystone-service-admin-role": "KeystoneServiceAdmin",
"keystone-admin-role": "KeystoneAdmin",
"hash-password": "******",
}
# set up default backend if none supplied
if "backends" not in options or options["backends"] is None:
options["backends"] = "keystone.backends.sqlalchemy"
if "keystone.backends.sqlalchemy" not in options:
options["keystone.backends.sqlalchemy"] = {
"sql_connection": "sqlite://",
"backend_entities": "['UserRoleAssociation', 'Endpoints',\
'Role', 'Tenant', 'User',\
'Credentials', 'EndpointTemplates',\
'Token', 'Service']",
"sql_idle_timeout": "30",
}
# Init backends module constants (without initializing backends)
no_backend_init = options.copy()
no_backend_init["backends"] = None
reload(backends)
backends.configure_backends(no_backend_init)
backend_list = options["backends"]
for backend in backend_list.split(","):
backend_module = utils.import_module(backend)
settings = options[backend]
backend_module.configure_backend(settings)
def configure_backends(options):
'''Load backends given in the 'backends' option.'''
backend_names = options.get('backends', DEFAULT_BACKENDS)
for backend in backend_names.split(','):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
#Initialize common configs general to all backends.
global KeyStoneAdminRole
KeyStoneAdminRole = options["keystone-admin-role"]
def register_models(options):
"""Register Models and create properties"""
global _ENGINE
assert _ENGINE
supported_alchemy_models = ast.literal_eval(
options["backend_entities"])
supported_alchemy_tables = []
for supported_alchemy_model in supported_alchemy_models:
model = utils.import_module(MODEL_PREFIX + supported_alchemy_model)
supported_alchemy_tables.append(model.__table__)
top_models.set_value(supported_alchemy_model, model)
if model.__api__ != None:
model_api = utils.import_module(API_PREFIX + model.__api__)
top_api.set_value(model.__api__, model_api.get())
creation_tables = []
for table in reversed(BASE.metadata.sorted_tables):
if table in supported_alchemy_tables:
creation_tables.append(table)
BASE.metadata.create_all(_ENGINE, tables=creation_tables, checkfirst=True)
def configure_backends():
"""Load backends given in the 'backends' option."""
global SHOULD_HASH_PASSWORD # pylint: disable=W0603
SHOULD_HASH_PASSWORD = CONF.hash_password
backend_names = CONF.backends or DEFAULT_BACKENDS
for module_name in backend_names.split(","):
backend_module = utils.import_module(module_name)
backend_conf = GroupConf(module_name)
backend_module.configure_backend(backend_conf)
def configure_backends(options):
"""Load backends given in the 'backends' option."""
backend_names = options.get("backends", DEFAULT_BACKENDS)
for backend in backend_names.split(","):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
# Initialize common configs general to all backends.
global KEYSTONEADMINROLE
KEYSTONEADMINROLE = options["keystone-admin-role"]
global KEYSTONESERVICEADMINROLE
KEYSTONESERVICEADMINROLE = options["keystone-service-admin-role"]
def _init_models(self, model_list):
for model in model_list:
model_class = getattr(models, model)
top_models.set_value(model, model_class)
if model_class.__api__ is not None:
api_path = '.'.join([__package__, 'api', model_class.__api__])
api_module = sys.modules.get(api_path)
if api_module is None:
api_module = utils.import_module(api_path)
top_api.set_value(model_class.__api__, api_module.get())
def register_models(options):
"""Register Models and create properties"""
global _ENGINE
assert _ENGINE
# Need to decide.Not This is missing
# and prevents foreign key reference checks.
# _ENGINE.execute('pragma foreign_keys=on')
supported_alchemy_models = ast.literal_eval(options["backend_entities"])
supported_alchemy_tables = []
for supported_alchemy_model in supported_alchemy_models:
model = utils.import_module(MODEL_PREFIX + supported_alchemy_model)
supported_alchemy_tables.append(model.__table__)
top_models.set_value(supported_alchemy_model, model)
if model.__api__ != None:
model_api = utils.import_module(API_PREFIX + model.__api__)
top_api.set_value(model.__api__, model_api.get())
creation_tables = []
for table in reversed(BASE.metadata.sorted_tables):
if table in supported_alchemy_tables:
creation_tables.append(table)
BASE.metadata.create_all(_ENGINE, tables=creation_tables, checkfirst=True)
def configure_backends(options):
'''Load backends given in the 'backends' option.'''
backend_names = options.get('backends', DEFAULT_BACKENDS)
if backend_names:
for backend in backend_names.split(','):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
#Initialize common configs general to all backends.
global SHOULD_HASH_PASSWORD
if ("hash-password" in options
and ast.literal_eval(options["hash-password"])):
SHOULD_HASH_PASSWORD = options["hash-password"]
def configure_backends(options):
'''Load backends given in the 'backends' option.'''
backend_names = options.get('backends', DEFAULT_BACKENDS)
for backend in backend_names.split(','):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
#Initialize common configs general to all backends.
global ADMIN_ROLE_NAME
ADMIN_ROLE_NAME = options["keystone-admin-role"]
global SERVICE_ADMIN_ROLE_NAME
SERVICE_ADMIN_ROLE_NAME = options["keystone-service-admin-role"]
def register_models(options):
"""Register Models and create properties"""
global _ENGINE
assert _ENGINE
# Need to decide.Not This is missing
# and prevents foreign key reference checks.
# _ENGINE.execute('pragma foreign_keys=on')
supported_alchemy_models = ast.literal_eval(
options["backend_entities"])
supported_alchemy_tables = []
for supported_alchemy_model in supported_alchemy_models:
model = utils.import_module(MODEL_PREFIX + supported_alchemy_model)
supported_alchemy_tables.append(model.__table__)
top_models.set_value(supported_alchemy_model, model)
if model.__api__ != None:
model_api = utils.import_module(API_PREFIX + model.__api__)
top_api.set_value(model.__api__, model_api.get())
creation_tables = []
for table in reversed(BASE.metadata.sorted_tables):
if table in supported_alchemy_tables:
creation_tables.append(table)
BASE.metadata.create_all(_ENGINE, tables=creation_tables, checkfirst=True)
def configure_backends(options):
'''Load backends given in the 'backends' option.'''
backend_names = options.get('backends', DEFAULT_BACKENDS)
if backend_names:
for backend in backend_names.split(','):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
#Initialize common configs general to all backends.
global SHOULD_HASH_PASSWORD
if ("hash-password" in options
and ast.literal_eval(options["hash-password"])):
SHOULD_HASH_PASSWORD = options["hash-password"]
def configure_extensions(self, extension_type, mapper, options):
supported_extensions = options.get(CONFIG_EXTENSION_PROPERTY,
DEFAULT_EXTENSIONS)
for supported_extension in supported_extensions.split(','):
self.extension_handlers = []
supported_extension = EXTENSION_PREFIX\
+ extension_type + '.' + supported_extension.strip()\
+ '.ExtensionHandler'
try:
extenion_handler = utils.import_module(supported_extension)()
extenion_handler.map_extension_methods(mapper, options)
self.extension_handlers.append(extenion_handler)
except Exception as err:
logging.exception("Could not load extension for " +\
extension_type + ':' + supported_extension + str(err))
def configure_extensions(self, extension_type, mapper, options):
supported_extensions = options.get(CONFIG_EXTENSION_PROPERTY,
DEFAULT_EXTENSIONS)
for supported_extension in supported_extensions.split(','):
self.extension_handlers = []
supported_extension = "%s%s.%s" % (
EXTENSION_PREFIX, extension_type, supported_extension.strip())
try:
extension_module = utils.import_module(supported_extension)
if hasattr(extension_module, 'ExtensionHandler'):
extension_class = extension_module.ExtensionHandler()
extension_class.map_extension_methods(mapper, options)
self.extension_handlers.append(extension_class)
except Exception as err:
logger.exception("Could not load extension for %s:%s %s" %
(extension_type, supported_extension, err))
def configure_extensions(self, extension_type,
mapper, options):
supported_extensions = options.get(
CONFIG_EXTENSION_PROPERTY, DEFAULT_EXTENSIONS)
for supported_extension in supported_extensions.split(','):
self.extension_handlers = []
supported_extension = EXTENSION_PREFIX\
+ extension_type + '.' + supported_extension.strip()\
+ '.ExtensionHandler'
try:
extenion_handler = utils.import_module(supported_extension)()
extenion_handler.map_extension_methods(mapper, options)
self.extension_handlers.append(extenion_handler)
except Exception as err:
logging.exception("Could not load extension for " +\
extension_type + ':' + supported_extension + str(err))
def _init_tables(self, model_list):
tables = []
for model in model_list:
model_path = '.'.join([__package__, 'models', model])
module = utils.import_module(model_path)
tables.append(module.__table__)
tables_to_create = []
for table in reversed(models.Base.metadata.sorted_tables):
if table in tables:
tables_to_create.append(table)
logger.debug('Creating tables: %s' % \
','.join([table.name for table in tables_to_create]))
models.Base.metadata.create_all(self._engine, tables=tables_to_create,
checkfirst=True)
def configure_backends(options):
'''Load backends given in the 'backends' option.'''
backend_names = options.get('backends', DEFAULT_BACKENDS)
for backend in backend_names.split(','):
backend_module = utils.import_module(backend)
backend_module.configure_backend(options[backend])
#Initialize common configs general to all backends.
global ADMIN_ROLE_NAME
ADMIN_ROLE_NAME = options["keystone-admin-role"]
global SERVICE_ADMIN_ROLE_NAME
SERVICE_ADMIN_ROLE_NAME = options["keystone-service-admin-role"]
global SHOULD_HASH_PASSWORD
if "hash-password" in options\
and ast.literal_eval(options["hash-password"]) == True:
SHOULD_HASH_PASSWORD = options["hash-password"]