def create_from_config(config, prefix='', with_transaction=True):
"""Create a PostgreSQLClient client using settings in the provided config.
"""
if sqlalchemy is None:
message = ('PostgreSQL SQLAlchemy dependency missing. '
'Refer to installation section in documentation.')
raise ImportWarning(message)
from zope.sqlalchemy import ZopeTransactionExtension, invalidate
from sqlalchemy.orm import sessionmaker, scoped_session
settings = {**config.get_settings()}
# Custom Kinto settings, unsupported by SQLAlchemy.
blacklist = [prefix + setting for setting in BLACKLISTED_SETTINGS]
filtered_settings = {
k: v
for k, v in settings.items() if k not in blacklist
}
transaction_per_request = with_transaction \
and filtered_settings.pop('transaction_per_request', False)
url = filtered_settings[prefix + 'url']
existing_client = _CLIENTS[transaction_per_request].get(url)
if existing_client:
msg = ('Reuse existing PostgreSQL connection. '
'Parameters {}* will be ignored.'.format(prefix))
warnings.warn(msg)
return existing_client
# Initialize SQLAlchemy engine from filtered_settings.
poolclass_key = prefix + 'poolclass'
filtered_settings.setdefault(poolclass_key,
('kinto.core.storage.postgresql.'
'pool.QueuePoolWithMaxBacklog'))
filtered_settings[poolclass_key] = config.maybe_dotted(
filtered_settings[poolclass_key])
engine = sqlalchemy.engine_from_config(filtered_settings,
prefix=prefix,
url=url)
# Initialize thread-safe session factory.
options = {}
if transaction_per_request:
# Plug with Pyramid transaction manager
options['extension'] = ZopeTransactionExtension()
session_factory = scoped_session(sessionmaker(bind=engine, **options))
# Store one client per URI.
commit_manually = (not transaction_per_request)
client = PostgreSQLClient(session_factory, commit_manually, invalidate)
_CLIENTS[transaction_per_request][url] = client
return client
def create_from_config(config, prefix="", with_transaction=True):
"""Create a PostgreSQLClient client using settings in the provided config.
"""
if sqlalchemy is None:
message = (
"PostgreSQL SQLAlchemy dependency missing. "
"Refer to installation section in documentation."
)
raise ImportWarning(message)
from zope.sqlalchemy import ZopeTransactionExtension, invalidate
from sqlalchemy.orm import sessionmaker, scoped_session
settings = {**config.get_settings()}
# Custom Kinto settings, unsupported by SQLAlchemy.
blacklist = [prefix + setting for setting in BLACKLISTED_SETTINGS]
filtered_settings = {k: v for k, v in settings.items() if k not in blacklist}
transaction_per_request = with_transaction and filtered_settings.pop(
"transaction_per_request", False
)
url = filtered_settings[prefix + "url"]
existing_client = _CLIENTS[transaction_per_request].get(url)
if existing_client:
msg = "Reuse existing PostgreSQL connection. " "Parameters {}* will be ignored.".format(
prefix
)
warnings.warn(msg)
return existing_client
# Initialize SQLAlchemy engine from filtered_settings.
poolclass_key = prefix + "poolclass"
filtered_settings.setdefault(
poolclass_key, ("kinto.core.storage.postgresql." "pool.QueuePoolWithMaxBacklog")
)
filtered_settings[poolclass_key] = config.maybe_dotted(filtered_settings[poolclass_key])
engine = sqlalchemy.engine_from_config(filtered_settings, prefix=prefix, url=url)
# Initialize thread-safe session factory.
options = {}
if transaction_per_request:
# Plug with Pyramid transaction manager
options["extension"] = ZopeTransactionExtension()
session_factory = scoped_session(sessionmaker(bind=engine, **options))
# Store one client per URI.
commit_manually = not transaction_per_request
client = PostgreSQLClient(session_factory, commit_manually, invalidate)
_CLIENTS[transaction_per_request][url] = client
return client
def create_from_config(config, prefix="", with_transaction=True):
"""Create a PostgreSQLClient client using settings in the provided config.
"""
if sqlalchemy is None:
message = ("PostgreSQL SQLAlchemy dependency missing. "
"Refer to installation section in documentation.")
raise ImportWarning(message)
from zope.sqlalchemy import register, invalidate
from sqlalchemy.orm import sessionmaker, scoped_session
settings = {**config.get_settings()}
# Custom Kinto settings, unsupported by SQLAlchemy.
blacklist = [prefix + setting for setting in BLACKLISTED_SETTINGS]
filtered_settings = {
k: v
for k, v in settings.items() if k not in blacklist
}
transaction_per_request = with_transaction and filtered_settings.pop(
"transaction_per_request", False)
url = filtered_settings[prefix + "url"]
existing_client = _CLIENTS[transaction_per_request].get(url)
if existing_client:
msg = "Reuse existing PostgreSQL connection. " f"Parameters {prefix}* will be ignored."
warnings.warn(msg)
return existing_client
# Initialize SQLAlchemy engine from filtered_settings.
poolclass_key = prefix + "poolclass"
filtered_settings.setdefault(poolclass_key,
("kinto.core.storage.postgresql."
"pool.QueuePoolWithMaxBacklog"))
filtered_settings[poolclass_key] = config.maybe_dotted(
filtered_settings[poolclass_key])
engine = sqlalchemy.engine_from_config(filtered_settings,
prefix=prefix,
url=url)
# Initialize thread-safe session factory.
session_factory = scoped_session(sessionmaker(bind=engine))
if transaction_per_request:
# Plug with Pyramid transaction manager
register(session_factory)
# Store one client per URI.
commit_manually = not transaction_per_request
client = PostgreSQLClient(session_factory, commit_manually, invalidate)
_CLIENTS[transaction_per_request][url] = client
return client
def create_from_config(config, prefix='', with_transaction=True):
"""Create a PostgreSQLClient client using settings in the provided config.
"""
if sqlalchemy is None:
message = ("PostgreSQL SQLAlchemy dependency missing. "
"Refer to installation section in documentation.")
raise ImportWarning(message)
from zope.sqlalchemy import ZopeTransactionExtension, invalidate
from sqlalchemy.orm import sessionmaker, scoped_session
settings = config.get_settings().copy()
# Custom Kinto settings, unsupported by SQLAlchemy.
settings.pop(prefix + 'backend', None)
settings.pop(prefix + 'max_fetch_size', None)
settings.pop(prefix + 'max_size_bytes', None)
settings.pop(prefix + 'prefix', None)
transaction_per_request = with_transaction and settings.pop(
'transaction_per_request', False)
url = settings[prefix + 'url']
existing_client = _CLIENTS[transaction_per_request].get(url)
if existing_client:
msg = ("Reuse existing PostgreSQL connection. "
"Parameters %s* will be ignored." % prefix)
warnings.warn(msg)
return existing_client
# Initialize SQLAlchemy engine from settings.
poolclass_key = prefix + 'poolclass'
settings.setdefault(poolclass_key, ('kinto.core.storage.postgresql.'
'pool.QueuePoolWithMaxBacklog'))
settings[poolclass_key] = config.maybe_dotted(settings[poolclass_key])
engine = sqlalchemy.engine_from_config(settings, prefix=prefix, url=url)
# Initialize thread-safe session factory.
options = {}
if transaction_per_request:
# Plug with Pyramid transaction manager
options['extension'] = ZopeTransactionExtension()
session_factory = scoped_session(sessionmaker(bind=engine, **options))
# Store one client per URI.
commit_manually = (not transaction_per_request)
client = PostgreSQLClient(session_factory, commit_manually, invalidate)
_CLIENTS[transaction_per_request][url] = client
return client
def create_from_config(config, prefix=''):
"""Create a PostgreSQLClient client using settings in the provided config.
"""
if sqlalchemy is None:
message = ("PostgreSQL SQLAlchemy dependency missing. "
"Refer to installation section in documentation.")
raise ImportWarning(message)
from zope.sqlalchemy import ZopeTransactionExtension, invalidate
from sqlalchemy.orm import sessionmaker, scoped_session
settings = config.get_settings().copy()
# Custom Kinto settings, unsupported by SQLAlchemy.
settings.pop(prefix + 'backend', None)
settings.pop(prefix + 'max_fetch_size', None)
settings.pop(prefix + 'prefix', None)
transaction_per_request = settings.pop('transaction_per_request', False)
url = settings[prefix + 'url']
existing_client = _CLIENTS[transaction_per_request].get(url)
if existing_client:
msg = ("Reuse existing PostgreSQL connection. "
"Parameters %s* will be ignored." % prefix)
warnings.warn(msg)
return existing_client
# Initialize SQLAlchemy engine from settings.
poolclass_key = prefix + 'poolclass'
settings.setdefault(poolclass_key, ('kinto.core.storage.postgresql.'
'pool.QueuePoolWithMaxBacklog'))
settings[poolclass_key] = config.maybe_dotted(settings[poolclass_key])
engine = sqlalchemy.engine_from_config(settings, prefix=prefix, url=url)
# Initialize thread-safe session factory.
options = {}
if transaction_per_request:
# Plug with Pyramid transaction manager
options['extension'] = ZopeTransactionExtension()
session_factory = scoped_session(sessionmaker(bind=engine, **options))
# Store one client per URI.
commit_manually = (not transaction_per_request)
client = PostgreSQLClient(session_factory, commit_manually, invalidate)
_CLIENTS[transaction_per_request][url] = client
return client
