def exchange_from_config(app_config, prefix, **kwargs):
"""Make an Exchange from a configuration dictionary.
The keys useful to :py:func:`exchange_from_config` should be prefixed,
e.g. ``amqp.exchange_name`` etc. The ``prefix`` argument specifies the
prefix used to filter keys. Each key is mapped to a corresponding keyword
argument on the :py:class:`~kombu.Exchange` constructor. Any keyword
arguments given to this function will be passed through to the
:py:class:`~kombu.Exchange` constructor. Keyword arguments take precedence
over the configuration file.
Supported keys:
* ``exchange_name``
* ``exchange_type``
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"exchange_name": config.Optional(config.String),
"exchange_type": config.String
})
options = parser.parse(prefix[:-1], app_config)
return Exchange(name=options.exchange_name or "",
type=options.exchange_type,
**kwargs)
def connection_from_config(app_config, prefix, **kwargs):
"""Make a Connection from a configuration dictionary.
The keys useful to :py:func:`connection_from_config` should be prefixed,
e.g. ``amqp.hostname`` etc. The ``prefix`` argument specifies the
prefix used to filter keys. Each key is mapped to a corresponding keyword
argument on the :py:class:`~kombu.connection.Connection` constructor. Any
keyword arguments given to this function will be passed through to the
:py:class:`~kombu.connection.Connection` constructor. Keyword arguments
take precedence over the configuration file.
Supported keys:
* ``hostname``
* ``virtual_host``
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"hostname": config.String,
"virtual_host": config.Optional(config.String)
})
options = parser.parse(prefix[:-1], app_config)
return Connection(hostname=options.hostname,
virtual_host=options.virtual_host,
**kwargs)
def pool_from_config(app_config,
prefix="memcache.",
serializer=None,
deserializer=None):
"""Make a PooledClient from a configuration dictionary.
The keys useful to :py:func:`pool_from_config` should be prefixed, e.g.
``memcache.endpoint``, ``memcache.max_pool_size``, etc. The ``prefix``
argument specifies the prefix used to filter keys. Each key is mapped to a
corresponding keyword argument on the
:py:class:`~pymemcache.client.base.PooledClient` constructor.
Supported keys:
* ``endpoint`` (required): a string representing a host and port to connect
to memcached service, e.g. ``localhost:11211`` or ``127.0.0.1:11211``.
* ``max_pool_size``: an integer for the maximum pool size to use, by default
this is ``2147483648``.
* ``connect_timeout``: a float representing seconds to wait for a connection to
memcached server. Defaults to the underlying socket default timeout.
* ``timeout``: a float representing seconds to wait for calls on the
socket connected to memcache. Defaults to the underlying socket default
timeout.
:param dict app_config: the config dictionary
:param str prefix: prefix for config keys
:param callable serializer: function to serialize values to strings suitable
for being stored in memcached. An example is
:py:func:`~baseplate.context.memcache.lib.make_dump_and_compress_fn`.
:param callable deserializer: function to convert strings returned from
memcached to arbitrary objects, must be compatible with ``serializer``.
An example is :py:func:`~baseplate.context.memcache.lib.decompress_and_load`.
:returns: :py:class:`pymemcache.client.base.PooledClient`
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"endpoint":
config.Endpoint,
"max_pool_size":
config.Optional(config.Integer, default=None),
"connect_timeout":
config.Optional(config.Float, default=None),
"timeout":
config.Optional(config.Float, default=None),
"no_delay":
config.Optional(config.Boolean, default=True),
})
options = parser.parse(prefix[:-1], app_config)
return PooledClient(
server=options.endpoint.address,
connect_timeout=options.connect_timeout,
timeout=options.timeout,
serializer=serializer,
deserializer=deserializer,
no_delay=options.no_delay,
max_pool_size=options.max_pool_size,
)
def hvac_factory_from_config(app_config, secrets_store, prefix="vault."):
"""Make an HVAC client factory from a configuration dictionary.
The keys useful to :py:func:`hvac_factory_from_config` should be prefixed,
e.g. ``vault.timeout``. The ``prefix`` argument specifies the prefix used
to filter keys.
Supported keys:
* ``timeout``: How long to wait for calls to Vault.
:param dict app_config: The raw application configuration.
:param baseplate.secrets.SecretsStore secrets_store: A configured secrets
store from which we can get a Vault authentication token.
:param str prefix: The prefix for configuration keys.
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"timeout":
config.Optional(config.Timespan, default=datetime.timedelta(seconds=1))
})
options = parser.parse(prefix[:-1], app_config)
return HvacContextFactory(secrets_store, options.timeout)
def cluster_from_config(
app_config: config.RawConfig,
secrets: Optional[SecretsStore] = None,
prefix: str = "cassandra.",
execution_profiles: Optional[Dict[str, ExecutionProfile]] = None,
**kwargs: Any,
):
"""Make a Cluster from a configuration dictionary.
The keys useful to :py:func:`cluster_from_config` should be prefixed, e.g.
``cassandra.contact_points`` etc. The ``prefix`` argument specifies the
prefix used to filter keys. Each key is mapped to a corresponding keyword
argument on the :py:class:`~cassandra.cluster.Cluster` constructor. Any
keyword arguments given to this function will be passed through to the
:py:class:`~cassandra.cluster.Cluster` constructor. Keyword arguments take
precedence over the configuration file.
Supported keys:
* ``contact_points`` (required): comma delimited list of contact points to
try connecting for cluster discovery
* ``port``: The server-side port to open connections to.
* ``credentials_secret`` (optional): the key used to retrieve the database
credentials from ``secrets`` as a :py:class:`~baseplate.secrets.CredentialSecret`.
:param execution_profiles: Configured execution profiles to provide to the
rest of the application.
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"contact_points":
config.TupleOf(config.String),
"port":
config.Optional(config.Integer, default=None),
"credentials_secret":
config.Optional(config.String),
})
options = parser.parse(prefix[:-1], app_config)
if options.port:
kwargs.setdefault("port", options.port)
if options.credentials_secret:
if not secrets:
raise TypeError(
"'secrets' is required if 'credentials_secret' is set")
credentials = secrets.get_credentials(options.credentials_secret)
kwargs.setdefault(
"auth_provider",
PlainTextAuthProvider(username=credentials.username,
password=credentials.password),
)
return Cluster(options.contact_points,
execution_profiles=execution_profiles,
**kwargs)
def thrift_pool_from_config(app_config, prefix, **kwargs):
"""Make a ThriftConnectionPool from a configuration dictionary.
The keys useful to :py:func:`thrift_pool_from_config` should be prefixed,
e.g. ``example_service.endpoint`` etc. The ``prefix`` argument specifies
the prefix used to filter keys. Each key is mapped to a corresponding
keyword argument on the :py:class:`ThriftConnectionPool` constructor. Any
keyword arguments given to this function will be also be passed through to
the constructor. Keyword arguments take precedence over the configuration
file.
Supported keys:
* ``endpoint`` (required): A ``host:port`` pair, e.g. ``localhost:2014``,
where the Thrift server can be found.
* ``size``: The size of the connection pool.
* ``max_age``: The oldest a connection can be before it's recycled and
replaced with a new one. Written as a time span e.g. ``1 minute``.
* ``timeout``: The maximum amount of time a connection attempt or RPC call
can take before a TimeoutError is raised.
* ``max_retries``: The maximum number of times the pool will attempt to
open a connection.
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"endpoint":
config.Endpoint,
"size":
config.Optional(config.Integer, default=10),
"max_age":
config.Optional(config.Timespan, default=config.Timespan("1 minute")),
"timeout":
config.Optional(config.Timespan, default=config.Timespan("1 second")),
"max_retries":
config.Optional(config.Integer, default=3),
})
options = parser.parse(prefix[:-1], app_config)
if options.size is not None:
kwargs.setdefault("size", options.size)
if options.max_age is not None:
kwargs.setdefault("max_age", options.max_age.total_seconds())
if options.timeout is not None:
kwargs.setdefault("timeout", options.timeout.total_seconds())
if options.max_retries is not None:
kwargs.setdefault("max_retries", options.max_retries)
return ThriftConnectionPool(endpoint=options.endpoint, **kwargs)
def pool_from_config(app_config, prefix="redis.", **kwargs):
"""Make a ConnectionPool from a configuration dictionary.
The keys useful to :py:func:`pool_from_config` should be prefixed, e.g.
``redis.url``, ``redis.max_connections``, etc. The ``prefix`` argument
specifies the prefix used to filter keys. Each key is mapped to a
corresponding keyword argument on the :py:class:`redis.ConnectionPool`
constructor.
Supported keys:
* ``url`` (required): a URL like ``redis://localhost/0``.
* ``max_connections``: an integer maximum number of connections in the pool
* ``socket_connect_timeout``: a timespan of how long to wait for sockets
to connect. e.g. ``200 milliseconds``.
* ``socket_timeout``: a timespan of how long to wait for socket operations,
e.g. ``200 milliseconds``.
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"url":
config.String,
"max_connections":
config.Optional(config.Integer, default=None),
"socket_connect_timeout":
config.Optional(config.Timespan, default=None),
"socket_timeout":
config.Optional(config.Timespan, default=None),
})
options = parser.parse(prefix[:-1], app_config)
if options.max_connections is not None:
kwargs.setdefault("max_connections", options.max_connections)
if options.socket_connect_timeout is not None:
kwargs.setdefault("socket_connect_timeout",
options.socket_connect_timeout.total_seconds())
if options.socket_timeout is not None:
kwargs.setdefault("socket_timeout",
options.socket_timeout.total_seconds())
return redis.BlockingConnectionPool.from_url(options.url, **kwargs)
def engine_from_config(app_config, secrets=None, prefix="database.", **kwargs):
"""Make an :py:class:`~sqlalchemy.engine.Engine` from a configuration dictionary.
The keys useful to :py:func:`engine_from_config` should be prefixed, e.g.
``database.url``, etc. The ``prefix`` argument specifies the prefix used to
filter keys.
Supported keys:
* ``url``: the connection URL to the database, passed to
:py:func:`~sqlalchemy.engine.url.make_url` to create the
:py:class:`~sqlalchemy.engine.url.URL` used to connect to the database.
* ``credentials_secret`` (optional): the key used to retrieve the database
credentials from ``secrets`` as a :py:class:`~baseplate.secrets.CredentialSecret`.
If this is supplied, any credentials given in ``url`` we be replaced by
these.
"""
assert prefix.endswith(".")
parser = config.SpecParser({
"url":
config.String,
"credentials_secret":
config.Optional(config.String)
})
options = parser.parse(prefix[:-1], app_config)
url = make_url(options.url)
if options.credentials_secret:
if not secrets:
raise TypeError(
"'secrets' is required if 'credentials_secret' is set")
credentials = secrets.get_credentials(options.credentials_secret)
url.username = credentials.username
url.password = credentials.password
return create_engine(url, **kwargs)