repository_name
stringlengths 5
67
| func_path_in_repository
stringlengths 4
234
| func_name
stringlengths 0
314
| whole_func_string
stringlengths 52
3.87M
| language
stringclasses 6
values | func_code_string
stringlengths 52
3.87M
| func_documentation_string
stringlengths 1
47.2k
| func_code_url
stringlengths 85
339
|
|---|---|---|---|---|---|---|---|
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocolV2.consume | def consume(self, callback, queue, previous_consumer=None):
"""
Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
previous_consumer (ConsumerV2): If this is the resumption of a prior
consumer, you can provide the previous consumer so its result
deferred can be re-used.
Returns:
Deferred: A Deferred that fires when the consumer is successfully
registered with the message broker. The callback receives a
:class:`.ConsumerV2` object that represents the AMQP consumer.
The Deferred may error back with a :class:`PermissionException`
if the user cannot read from the queue, a
:class:`NoFreeChannels` if this connection has hit its channel
limit, or a :class:`ConnectionException` if the connection dies
before the consumer is successfully registered.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
"""
if queue in self._consumers:
self._consumers[queue].callback = callback
defer.returnValue(self._consumers[queue])
if previous_consumer is not None:
consumer = previous_consumer
else:
consumer = ConsumerV2(queue=queue, callback=callback)
consumer._protocol = self
consumer._channel = yield self._allocate_channel()
try:
queue_object, _ = yield consumer._channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer._tag
)
except pika.exceptions.ChannelClosed as exc:
if exc.args[0] == 403:
raise PermissionException(
obj_type="queue", description=queue, reason=exc.args[1]
)
else:
raise ConnectionException(reason=exc)
def on_cancel_callback(frame):
"""
Called when the consumer is canceled server-side.
This can happen, for example, when the queue is deleted.
To handle this, we do the necessary book-keeping to remove the consumer
and then fire the errback on the consumer so the caller of
:func:`fedora_messaging.api.consume` can decide what to do.
Args:
frame (pika.frame.Method): The cancel method from the server,
unused here because we already know what consumer is being
canceled.
"""
_std_log.error("%r was canceled by the AMQP broker!", consumer)
# If client and server are racing to cancel it might already be gone which
# is why both are marked as no cover.
try:
del self._consumers[consumer.queue]
except KeyError: # pragma: no cover
pass
try:
del self.factory._consumers[consumer.queue]
except KeyError: # pragma: no cover
pass
consumer._running = False
consumer.result.errback(fail=ConsumerCanceled())
try:
consumer._channel.add_on_cancel_callback(on_cancel_callback)
except AttributeError:
pass # pika 1.0.0+
def read_loop_errback(failure):
"""
Handle errors coming out of the read loop.
There are two basic categories of errors: ones where the ``consumer.result``
Deferred needs to be fired because the error is not recoverable, ones
where we can recover from by letting the connection restart, and ones
which are fatal for this consumer only (the queue was deleted by an
administrator).
Args:
failure (twisted.python.failure.Failure): The exception raised by
the read loop encapsulated in a Failure.
"""
exc = failure.value
if failure.check(pika.exceptions.ConsumerCancelled):
# Pika 1.0.0+ raises this exception. To support previous versions
# we register a callback (called below) ourselves with the channel.
on_cancel_callback(None)
elif failure.check(pika.exceptions.ChannelClosed):
if exc.args[0] == 403:
# This is a mis-configuration, the consumer can register itself,
# but it doesn't have permissions to read from the queue,
# so no amount of restarting will help.
e = PermissionException(
obj_type="queue",
description=queue,
reason=failure.value.args[1],
)
consumer.result.errback(Failure(e, PermissionException))
consumer.cancel()
else:
_std_log.exception(
"Consumer halted (%r) unexpectedly; "
"the connection should restart.",
failure,
)
elif failure.check(error.ConnectionDone, error.ConnectionLost):
_std_log.warning(
"The connection to the broker was lost (%r), consumer halted; "
"the connection should restart and consuming will resume.",
exc,
)
elif failure.check(pika.exceptions.AMQPError):
_std_log.exception(
"An unexpected AMQP error occurred; the connection should "
"restart, but please report this as a bug."
)
else:
consumer.result.errback(failure)
consumer.cancel()
consumer._read_loop = self._read(queue_object, consumer)
consumer._read_loop.addErrback(read_loop_errback)
self._consumers[queue] = consumer
_std_log.info("Successfully registered AMQP consumer %r", consumer)
defer.returnValue(consumer) | python | def consume(self, callback, queue, previous_consumer=None):
"""
Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
previous_consumer (ConsumerV2): If this is the resumption of a prior
consumer, you can provide the previous consumer so its result
deferred can be re-used.
Returns:
Deferred: A Deferred that fires when the consumer is successfully
registered with the message broker. The callback receives a
:class:`.ConsumerV2` object that represents the AMQP consumer.
The Deferred may error back with a :class:`PermissionException`
if the user cannot read from the queue, a
:class:`NoFreeChannels` if this connection has hit its channel
limit, or a :class:`ConnectionException` if the connection dies
before the consumer is successfully registered.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
"""
if queue in self._consumers:
self._consumers[queue].callback = callback
defer.returnValue(self._consumers[queue])
if previous_consumer is not None:
consumer = previous_consumer
else:
consumer = ConsumerV2(queue=queue, callback=callback)
consumer._protocol = self
consumer._channel = yield self._allocate_channel()
try:
queue_object, _ = yield consumer._channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer._tag
)
except pika.exceptions.ChannelClosed as exc:
if exc.args[0] == 403:
raise PermissionException(
obj_type="queue", description=queue, reason=exc.args[1]
)
else:
raise ConnectionException(reason=exc)
def on_cancel_callback(frame):
"""
Called when the consumer is canceled server-side.
This can happen, for example, when the queue is deleted.
To handle this, we do the necessary book-keeping to remove the consumer
and then fire the errback on the consumer so the caller of
:func:`fedora_messaging.api.consume` can decide what to do.
Args:
frame (pika.frame.Method): The cancel method from the server,
unused here because we already know what consumer is being
canceled.
"""
_std_log.error("%r was canceled by the AMQP broker!", consumer)
# If client and server are racing to cancel it might already be gone which
# is why both are marked as no cover.
try:
del self._consumers[consumer.queue]
except KeyError: # pragma: no cover
pass
try:
del self.factory._consumers[consumer.queue]
except KeyError: # pragma: no cover
pass
consumer._running = False
consumer.result.errback(fail=ConsumerCanceled())
try:
consumer._channel.add_on_cancel_callback(on_cancel_callback)
except AttributeError:
pass # pika 1.0.0+
def read_loop_errback(failure):
"""
Handle errors coming out of the read loop.
There are two basic categories of errors: ones where the ``consumer.result``
Deferred needs to be fired because the error is not recoverable, ones
where we can recover from by letting the connection restart, and ones
which are fatal for this consumer only (the queue was deleted by an
administrator).
Args:
failure (twisted.python.failure.Failure): The exception raised by
the read loop encapsulated in a Failure.
"""
exc = failure.value
if failure.check(pika.exceptions.ConsumerCancelled):
# Pika 1.0.0+ raises this exception. To support previous versions
# we register a callback (called below) ourselves with the channel.
on_cancel_callback(None)
elif failure.check(pika.exceptions.ChannelClosed):
if exc.args[0] == 403:
# This is a mis-configuration, the consumer can register itself,
# but it doesn't have permissions to read from the queue,
# so no amount of restarting will help.
e = PermissionException(
obj_type="queue",
description=queue,
reason=failure.value.args[1],
)
consumer.result.errback(Failure(e, PermissionException))
consumer.cancel()
else:
_std_log.exception(
"Consumer halted (%r) unexpectedly; "
"the connection should restart.",
failure,
)
elif failure.check(error.ConnectionDone, error.ConnectionLost):
_std_log.warning(
"The connection to the broker was lost (%r), consumer halted; "
"the connection should restart and consuming will resume.",
exc,
)
elif failure.check(pika.exceptions.AMQPError):
_std_log.exception(
"An unexpected AMQP error occurred; the connection should "
"restart, but please report this as a bug."
)
else:
consumer.result.errback(failure)
consumer.cancel()
consumer._read_loop = self._read(queue_object, consumer)
consumer._read_loop.addErrback(read_loop_errback)
self._consumers[queue] = consumer
_std_log.info("Successfully registered AMQP consumer %r", consumer)
defer.returnValue(consumer) | Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
previous_consumer (ConsumerV2): If this is the resumption of a prior
consumer, you can provide the previous consumer so its result
deferred can be re-used.
Returns:
Deferred: A Deferred that fires when the consumer is successfully
registered with the message broker. The callback receives a
:class:`.ConsumerV2` object that represents the AMQP consumer.
The Deferred may error back with a :class:`PermissionException`
if the user cannot read from the queue, a
:class:`NoFreeChannels` if this connection has hit its channel
limit, or a :class:`ConnectionException` if the connection dies
before the consumer is successfully registered.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L318-L461 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocolV2.declare_exchanges | def declare_exchanges(self, exchanges):
"""
Declare a number of exchanges at once.
This simply wraps the :meth:`pika.channel.Channel.exchange_declare`
method and deals with error handling and channel allocation.
Args:
exchanges (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* exchange (str): The exchange's name
* exchange_type (str): The type of the exchange ("direct", "topic", etc)
* passive (bool): If true, this will just assert that the exchange exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the exchange is durable
* arguments (dict): Extra arguments for the exchange's creation.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If an exchange could not be declared. This can occur
if the exchange already exists, but does its type does not match
(e.g. it is declared as a "topic" exchange, but exists as a "direct"
exchange). It can also occur if it does not exist, but the current
user does not have permissions to create the object.
"""
channel = yield self._allocate_channel()
try:
for exchange in exchanges:
args = exchange.copy()
args.setdefault("passive", config.conf["passive_declares"])
try:
yield channel.exchange_declare(**args)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("exchange", args, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | python | def declare_exchanges(self, exchanges):
"""
Declare a number of exchanges at once.
This simply wraps the :meth:`pika.channel.Channel.exchange_declare`
method and deals with error handling and channel allocation.
Args:
exchanges (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* exchange (str): The exchange's name
* exchange_type (str): The type of the exchange ("direct", "topic", etc)
* passive (bool): If true, this will just assert that the exchange exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the exchange is durable
* arguments (dict): Extra arguments for the exchange's creation.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If an exchange could not be declared. This can occur
if the exchange already exists, but does its type does not match
(e.g. it is declared as a "topic" exchange, but exists as a "direct"
exchange). It can also occur if it does not exist, but the current
user does not have permissions to create the object.
"""
channel = yield self._allocate_channel()
try:
for exchange in exchanges:
args = exchange.copy()
args.setdefault("passive", config.conf["passive_declares"])
try:
yield channel.exchange_declare(**args)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("exchange", args, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | Declare a number of exchanges at once.
This simply wraps the :meth:`pika.channel.Channel.exchange_declare`
method and deals with error handling and channel allocation.
Args:
exchanges (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* exchange (str): The exchange's name
* exchange_type (str): The type of the exchange ("direct", "topic", etc)
* passive (bool): If true, this will just assert that the exchange exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the exchange is durable
* arguments (dict): Extra arguments for the exchange's creation.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If an exchange could not be declared. This can occur
if the exchange already exists, but does its type does not match
(e.g. it is declared as a "topic" exchange, but exists as a "direct"
exchange). It can also occur if it does not exist, but the current
user does not have permissions to create the object. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L464-L505 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocolV2.declare_queues | def declare_queues(self, queues):
"""
Declare a list of queues.
Args:
queues (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* queue (str): The name of the queue
* passive (bool): If true, this will just assert that the queue exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the queue is durable
* exclusive (bool): Whether or not the queue is exclusive to this connection.
* auto_delete (bool): Whether or not the queue should be automatically
deleted once this connection ends.
* arguments (dict): Additional arguments for the creation of the queue.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a queue could not be declared. This can occur
if the queue already exists, but does its type does not match
(e.g. it is declared as a durable queue, but exists as a non-durable
queue). It can also occur if it does not exist, but the current
user does not have permissions to create the object.
"""
channel = yield self._allocate_channel()
try:
for queue in queues:
args = queue.copy()
args.setdefault("passive", config.conf["passive_declares"])
try:
yield channel.queue_declare(**args)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("queue", args, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | python | def declare_queues(self, queues):
"""
Declare a list of queues.
Args:
queues (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* queue (str): The name of the queue
* passive (bool): If true, this will just assert that the queue exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the queue is durable
* exclusive (bool): Whether or not the queue is exclusive to this connection.
* auto_delete (bool): Whether or not the queue should be automatically
deleted once this connection ends.
* arguments (dict): Additional arguments for the creation of the queue.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a queue could not be declared. This can occur
if the queue already exists, but does its type does not match
(e.g. it is declared as a durable queue, but exists as a non-durable
queue). It can also occur if it does not exist, but the current
user does not have permissions to create the object.
"""
channel = yield self._allocate_channel()
try:
for queue in queues:
args = queue.copy()
args.setdefault("passive", config.conf["passive_declares"])
try:
yield channel.queue_declare(**args)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("queue", args, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | Declare a list of queues.
Args:
queues (list of dict): A list of dictionaries, where each dictionary
represents an exchange. Each dictionary can have the following keys:
* queue (str): The name of the queue
* passive (bool): If true, this will just assert that the queue exists,
but won't create it if it doesn't. Defaults to the configuration value
:ref:`conf-passive-declares`
* durable (bool): Whether or not the queue is durable
* exclusive (bool): Whether or not the queue is exclusive to this connection.
* auto_delete (bool): Whether or not the queue should be automatically
deleted once this connection ends.
* arguments (dict): Additional arguments for the creation of the queue.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a queue could not be declared. This can occur
if the queue already exists, but does its type does not match
(e.g. it is declared as a durable queue, but exists as a non-durable
queue). It can also occur if it does not exist, but the current
user does not have permissions to create the object. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L508-L548 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocolV2.bind_queues | def bind_queues(self, bindings):
"""
Declare a set of bindings between queues and exchanges.
Args:
bindings (list of dict): A list of binding definitions. Each dictionary
must contain the "queue" key whose value is the name of the queue
to create the binding on, as well as the "exchange" key whose value
should be the name of the exchange to bind to. Additional acceptable
keys are any keyword arguments accepted by
:meth:`pika.channel.Channel.queue_bind`.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a binding could not be declared. This can occur if the
queue or exchange don't exist, or if they do, but the current user does
not have permissions to create bindings.
"""
channel = yield self._allocate_channel()
try:
for binding in bindings:
try:
yield channel.queue_bind(**binding)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("binding", binding, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | python | def bind_queues(self, bindings):
"""
Declare a set of bindings between queues and exchanges.
Args:
bindings (list of dict): A list of binding definitions. Each dictionary
must contain the "queue" key whose value is the name of the queue
to create the binding on, as well as the "exchange" key whose value
should be the name of the exchange to bind to. Additional acceptable
keys are any keyword arguments accepted by
:meth:`pika.channel.Channel.queue_bind`.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a binding could not be declared. This can occur if the
queue or exchange don't exist, or if they do, but the current user does
not have permissions to create bindings.
"""
channel = yield self._allocate_channel()
try:
for binding in bindings:
try:
yield channel.queue_bind(**binding)
except pika.exceptions.ChannelClosed as e:
raise BadDeclaration("binding", binding, e)
finally:
try:
channel.close()
except pika.exceptions.AMQPError:
pass | Declare a set of bindings between queues and exchanges.
Args:
bindings (list of dict): A list of binding definitions. Each dictionary
must contain the "queue" key whose value is the name of the queue
to create the binding on, as well as the "exchange" key whose value
should be the name of the exchange to bind to. Additional acceptable
keys are any keyword arguments accepted by
:meth:`pika.channel.Channel.queue_bind`.
Raises:
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
BadDeclaration: If a binding could not be declared. This can occur if the
queue or exchange don't exist, or if they do, but the current user does
not have permissions to create bindings. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L551-L582 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocolV2.halt | def halt(self):
"""
Signal to consumers they should stop after finishing any messages
currently being processed, then close the connection.
Returns:
defer.Deferred: fired when all consumers have successfully stopped
and the connection is closed.
"""
if self.is_closed:
# We were asked to stop because the connection is already gone.
# There's no graceful way to stop because we can't acknowledge
# messages in the middle of being processed.
_std_log.info("Disconnect requested, but AMQP connection already gone")
self._channel = None
return
_std_log.info(
"Waiting for %d consumer(s) to finish processing before halting",
len(self._consumers),
)
pending_cancels = []
for c in list(self._consumers.values()):
pending_cancels.append(c.cancel())
yield defer.gatherResults(pending_cancels)
_std_log.info("Finished canceling %d consumers", len(self._consumers))
try:
yield self.close()
except pika.exceptions.ConnectionWrongStateError:
pass # Already closing, not a problem since that's what we want.
self._consumers = {}
self._channel = None | python | def halt(self):
"""
Signal to consumers they should stop after finishing any messages
currently being processed, then close the connection.
Returns:
defer.Deferred: fired when all consumers have successfully stopped
and the connection is closed.
"""
if self.is_closed:
# We were asked to stop because the connection is already gone.
# There's no graceful way to stop because we can't acknowledge
# messages in the middle of being processed.
_std_log.info("Disconnect requested, but AMQP connection already gone")
self._channel = None
return
_std_log.info(
"Waiting for %d consumer(s) to finish processing before halting",
len(self._consumers),
)
pending_cancels = []
for c in list(self._consumers.values()):
pending_cancels.append(c.cancel())
yield defer.gatherResults(pending_cancels)
_std_log.info("Finished canceling %d consumers", len(self._consumers))
try:
yield self.close()
except pika.exceptions.ConnectionWrongStateError:
pass # Already closing, not a problem since that's what we want.
self._consumers = {}
self._channel = None | Signal to consumers they should stop after finishing any messages
currently being processed, then close the connection.
Returns:
defer.Deferred: fired when all consumers have successfully stopped
and the connection is closed. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L585-L617 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol._read | def _read(self, queue_object, consumer):
"""
The loop that reads from the message queue and calls the consumer callback
wrapper.
queue_object (pika.adapters.twisted_connection.ClosableDeferredQueue):
The AMQP queue the consumer is bound to.
consumer (dict): A dictionary describing the consumer for the given
queue_object.
"""
while self._running:
try:
_channel, delivery_frame, properties, body = yield queue_object.get()
except (error.ConnectionDone, ChannelClosedByClient):
# This is deliberate.
_legacy_twisted_log.msg(
"Stopping the AMQP consumer with tag {tag}", tag=consumer.tag
)
break
except pika.exceptions.ChannelClosed as e:
_legacy_twisted_log.msg(
"Stopping AMQP consumer {tag} for queue {q}: {e}",
tag=consumer.tag,
q=consumer.queue,
e=str(e),
logLevel=logging.ERROR,
)
break
except pika.exceptions.ConsumerCancelled as e:
_legacy_twisted_log.msg(
"The AMQP broker canceled consumer {tag} on queue {q}: {e}",
tag=consumer.tag,
q=consumer.queue,
e=str(e),
logLevel=logging.ERROR,
)
break
except Exception:
_legacy_twisted_log.msg(
"An unexpected error occurred consuming from queue {q}",
q=consumer.queue,
logLevel=logging.ERROR,
)
break
if body:
yield self._on_message(delivery_frame, properties, body, consumer) | python | def _read(self, queue_object, consumer):
"""
The loop that reads from the message queue and calls the consumer callback
wrapper.
queue_object (pika.adapters.twisted_connection.ClosableDeferredQueue):
The AMQP queue the consumer is bound to.
consumer (dict): A dictionary describing the consumer for the given
queue_object.
"""
while self._running:
try:
_channel, delivery_frame, properties, body = yield queue_object.get()
except (error.ConnectionDone, ChannelClosedByClient):
# This is deliberate.
_legacy_twisted_log.msg(
"Stopping the AMQP consumer with tag {tag}", tag=consumer.tag
)
break
except pika.exceptions.ChannelClosed as e:
_legacy_twisted_log.msg(
"Stopping AMQP consumer {tag} for queue {q}: {e}",
tag=consumer.tag,
q=consumer.queue,
e=str(e),
logLevel=logging.ERROR,
)
break
except pika.exceptions.ConsumerCancelled as e:
_legacy_twisted_log.msg(
"The AMQP broker canceled consumer {tag} on queue {q}: {e}",
tag=consumer.tag,
q=consumer.queue,
e=str(e),
logLevel=logging.ERROR,
)
break
except Exception:
_legacy_twisted_log.msg(
"An unexpected error occurred consuming from queue {q}",
q=consumer.queue,
logLevel=logging.ERROR,
)
break
if body:
yield self._on_message(delivery_frame, properties, body, consumer) | The loop that reads from the message queue and calls the consumer callback
wrapper.
queue_object (pika.adapters.twisted_connection.ClosableDeferredQueue):
The AMQP queue the consumer is bound to.
consumer (dict): A dictionary describing the consumer for the given
queue_object. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L659-L704 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol._on_message | def _on_message(self, delivery_frame, properties, body, consumer):
"""
Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the
user callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
delivery_frame (pika.spec.Deliver): The delivery frame which
includes details about the message like content encoding and
its delivery tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
consumer (dict): A dictionary describing the consumer of the message.
Returns:
Deferred: fired when the message has been handled.
"""
_legacy_twisted_log.msg(
"Message arrived with delivery tag {tag} for {consumer}",
tag=delivery_frame.delivery_tag,
consumer=consumer,
logLevel=logging.DEBUG,
)
try:
message = get_message(delivery_frame.routing_key, properties, body)
message.queue = consumer.queue
except ValidationError:
_legacy_twisted_log.msg(
"Message id {msgid} did not pass validation; ignoring message",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=False
)
return
try:
_legacy_twisted_log.msg(
"Consuming message from topic {topic!r} (id {msgid})",
topic=message.topic,
msgid=properties.message_id,
)
yield defer.maybeDeferred(consumer.callback, message)
except Nack:
_legacy_twisted_log.msg(
"Returning message id {msgid} to the queue",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=True
)
except Drop:
_legacy_twisted_log.msg(
"Consumer requested message id {msgid} be dropped",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=False
)
except HaltConsumer:
_legacy_twisted_log.msg(
"Consumer indicated it wishes consumption to halt, shutting down"
)
yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)
yield self.cancel(consumer.queue)
except Exception:
_legacy_twisted_log.msg(
"Received unexpected exception from consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
yield consumer.channel.basic_nack(
delivery_tag=0, multiple=True, requeue=True
)
yield self.cancel(consumer.queue)
else:
yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag) | python | def _on_message(self, delivery_frame, properties, body, consumer):
"""
Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the
user callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
delivery_frame (pika.spec.Deliver): The delivery frame which
includes details about the message like content encoding and
its delivery tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
consumer (dict): A dictionary describing the consumer of the message.
Returns:
Deferred: fired when the message has been handled.
"""
_legacy_twisted_log.msg(
"Message arrived with delivery tag {tag} for {consumer}",
tag=delivery_frame.delivery_tag,
consumer=consumer,
logLevel=logging.DEBUG,
)
try:
message = get_message(delivery_frame.routing_key, properties, body)
message.queue = consumer.queue
except ValidationError:
_legacy_twisted_log.msg(
"Message id {msgid} did not pass validation; ignoring message",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=False
)
return
try:
_legacy_twisted_log.msg(
"Consuming message from topic {topic!r} (id {msgid})",
topic=message.topic,
msgid=properties.message_id,
)
yield defer.maybeDeferred(consumer.callback, message)
except Nack:
_legacy_twisted_log.msg(
"Returning message id {msgid} to the queue",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=True
)
except Drop:
_legacy_twisted_log.msg(
"Consumer requested message id {msgid} be dropped",
msgid=properties.message_id,
logLevel=logging.WARNING,
)
yield consumer.channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=False
)
except HaltConsumer:
_legacy_twisted_log.msg(
"Consumer indicated it wishes consumption to halt, shutting down"
)
yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)
yield self.cancel(consumer.queue)
except Exception:
_legacy_twisted_log.msg(
"Received unexpected exception from consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
yield consumer.channel.basic_nack(
delivery_tag=0, multiple=True, requeue=True
)
yield self.cancel(consumer.queue)
else:
yield consumer.channel.basic_ack(delivery_tag=delivery_frame.delivery_tag) | Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the
user callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
delivery_frame (pika.spec.Deliver): The delivery frame which
includes details about the message like content encoding and
its delivery tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
consumer (dict): A dictionary describing the consumer of the message.
Returns:
Deferred: fired when the message has been handled. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L707-L794 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol.consume | def consume(self, callback, queue):
"""
Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
If :meth:`resumeProducing` has not been called when this method is called,
it will be called for you.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
Returns:
fedora_messaging.twisted.protocol.Consumer: A namedtuple that
identifies this consumer.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
"""
if queue in self._consumers and self._consumers[queue].channel.is_open:
consumer = Consumer(
tag=self._consumers[queue].tag,
queue=queue,
callback=callback,
channel=self._consumers[queue].channel,
)
self._consumers[queue] = consumer
defer.returnValue(consumer)
channel = yield self._allocate_channel()
consumer = Consumer(
tag=str(uuid.uuid4()), queue=queue, callback=callback, channel=channel
)
self._consumers[queue] = consumer
if not self._running:
yield self.resumeProducing()
defer.returnValue(consumer)
queue_object, _ = yield consumer.channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer.tag
)
deferred = self._read(queue_object, consumer)
deferred.addErrback(
lambda f: _legacy_twisted_log.msg,
"_read failed on consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
_legacy_twisted_log.msg("Successfully registered AMQP consumer {c}", c=consumer)
defer.returnValue(consumer) | python | def consume(self, callback, queue):
"""
Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
If :meth:`resumeProducing` has not been called when this method is called,
it will be called for you.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
Returns:
fedora_messaging.twisted.protocol.Consumer: A namedtuple that
identifies this consumer.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection.
"""
if queue in self._consumers and self._consumers[queue].channel.is_open:
consumer = Consumer(
tag=self._consumers[queue].tag,
queue=queue,
callback=callback,
channel=self._consumers[queue].channel,
)
self._consumers[queue] = consumer
defer.returnValue(consumer)
channel = yield self._allocate_channel()
consumer = Consumer(
tag=str(uuid.uuid4()), queue=queue, callback=callback, channel=channel
)
self._consumers[queue] = consumer
if not self._running:
yield self.resumeProducing()
defer.returnValue(consumer)
queue_object, _ = yield consumer.channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer.tag
)
deferred = self._read(queue_object, consumer)
deferred.addErrback(
lambda f: _legacy_twisted_log.msg,
"_read failed on consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
_legacy_twisted_log.msg("Successfully registered AMQP consumer {c}", c=consumer)
defer.returnValue(consumer) | Register a message consumer that executes the provided callback when
messages are received.
The queue must exist prior to calling this method. If a consumer
already exists for the given queue, the callback is simply updated and
any new messages for that consumer use the new callback.
If :meth:`resumeProducing` has not been called when this method is called,
it will be called for you.
Args:
callback (callable): The callback to invoke when a message is received.
queue (str): The name of the queue to consume from.
Returns:
fedora_messaging.twisted.protocol.Consumer: A namedtuple that
identifies this consumer.
NoFreeChannels: If there are no available channels on this connection.
If this occurs, you can either reduce the number of consumers on this
connection or create an additional connection. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L797-L852 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol.cancel | def cancel(self, queue):
"""
Cancel the consumer for a queue.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred: A Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`.defer.maybeDeferred` to always receive a Deferred.
"""
try:
consumer = self._consumers[queue]
yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
except pika.exceptions.AMQPChannelError:
# Consumers are tied to channels, so if this channel is dead the
# consumer should already be canceled (and we can't get to it anyway)
pass
except KeyError:
defer.returnValue(None)
try:
yield consumer.channel.close()
except pika.exceptions.AMQPChannelError:
pass
del self._consumers[queue] | python | def cancel(self, queue):
"""
Cancel the consumer for a queue.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred: A Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`.defer.maybeDeferred` to always receive a Deferred.
"""
try:
consumer = self._consumers[queue]
yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
except pika.exceptions.AMQPChannelError:
# Consumers are tied to channels, so if this channel is dead the
# consumer should already be canceled (and we can't get to it anyway)
pass
except KeyError:
defer.returnValue(None)
try:
yield consumer.channel.close()
except pika.exceptions.AMQPChannelError:
pass
del self._consumers[queue] | Cancel the consumer for a queue.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred: A Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`.defer.maybeDeferred` to always receive a Deferred. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L855-L882 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol.resumeProducing | def resumeProducing(self):
"""
Starts or resumes the retrieval of messages from the server queue.
This method starts receiving messages from the server, they will be
passed to the consumer callback.
.. note:: This is called automatically when :meth:`.consume` is called,
so users should not need to call this unless :meth:`.pauseProducing`
has been called.
Returns:
defer.Deferred: fired when the production is ready to start
"""
# Start consuming
self._running = True
for consumer in self._consumers.values():
queue_object, _ = yield consumer.channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer.tag
)
deferred = self._read(queue_object, consumer)
deferred.addErrback(
lambda f: _legacy_twisted_log.msg,
"_read failed on consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
_legacy_twisted_log.msg("AMQP connection successfully established") | python | def resumeProducing(self):
"""
Starts or resumes the retrieval of messages from the server queue.
This method starts receiving messages from the server, they will be
passed to the consumer callback.
.. note:: This is called automatically when :meth:`.consume` is called,
so users should not need to call this unless :meth:`.pauseProducing`
has been called.
Returns:
defer.Deferred: fired when the production is ready to start
"""
# Start consuming
self._running = True
for consumer in self._consumers.values():
queue_object, _ = yield consumer.channel.basic_consume(
queue=consumer.queue, consumer_tag=consumer.tag
)
deferred = self._read(queue_object, consumer)
deferred.addErrback(
lambda f: _legacy_twisted_log.msg,
"_read failed on consumer {c}",
c=consumer,
logLevel=logging.ERROR,
)
_legacy_twisted_log.msg("AMQP connection successfully established") | Starts or resumes the retrieval of messages from the server queue.
This method starts receiving messages from the server, they will be
passed to the consumer callback.
.. note:: This is called automatically when :meth:`.consume` is called,
so users should not need to call this unless :meth:`.pauseProducing`
has been called.
Returns:
defer.Deferred: fired when the production is ready to start | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L885-L912 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol.pauseProducing | def pauseProducing(self):
"""
Pause the reception of messages by canceling all existing consumers.
This does not disconnect from the server.
Message reception can be resumed with :meth:`resumeProducing`.
Returns:
Deferred: fired when the production is paused.
"""
if not self._running:
return
# Exit the read loop and cancel the consumer on the server.
self._running = False
for consumer in self._consumers.values():
yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
_legacy_twisted_log.msg("Paused retrieval of messages for the server queue") | python | def pauseProducing(self):
"""
Pause the reception of messages by canceling all existing consumers.
This does not disconnect from the server.
Message reception can be resumed with :meth:`resumeProducing`.
Returns:
Deferred: fired when the production is paused.
"""
if not self._running:
return
# Exit the read loop and cancel the consumer on the server.
self._running = False
for consumer in self._consumers.values():
yield consumer.channel.basic_cancel(consumer_tag=consumer.tag)
_legacy_twisted_log.msg("Paused retrieval of messages for the server queue") | Pause the reception of messages by canceling all existing consumers.
This does not disconnect from the server.
Message reception can be resumed with :meth:`resumeProducing`.
Returns:
Deferred: fired when the production is paused. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L915-L931 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/protocol.py | FedoraMessagingProtocol.stopProducing | def stopProducing(self):
"""
Stop producing messages and disconnect from the server.
Returns:
Deferred: fired when the production is stopped.
"""
_legacy_twisted_log.msg("Disconnecting from the AMQP broker")
yield self.pauseProducing()
yield self.close()
self._consumers = {}
self._channel = None | python | def stopProducing(self):
"""
Stop producing messages and disconnect from the server.
Returns:
Deferred: fired when the production is stopped.
"""
_legacy_twisted_log.msg("Disconnecting from the AMQP broker")
yield self.pauseProducing()
yield self.close()
self._consumers = {}
self._channel = None | Stop producing messages and disconnect from the server.
Returns:
Deferred: fired when the production is stopped. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/protocol.py#L934-L944 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | get_class | def get_class(schema_name):
"""
Retrieve the message class associated with the schema name.
If no match is found, the default schema is returned and a warning is logged.
Args:
schema_name (six.text_type): The name of the :class:`Message` sub-class;
this is typically the Python path.
Returns:
Message: A sub-class of :class:`Message` to create the message from.
"""
global _registry_loaded
if not _registry_loaded:
load_message_classes()
try:
return _schema_name_to_class[schema_name]
except KeyError:
_log.warning(
'The schema "%s" is not in the schema registry! Either install '
"the package with its schema definition or define a schema. "
"Falling back to the default schema...",
schema_name,
)
return Message | python | def get_class(schema_name):
"""
Retrieve the message class associated with the schema name.
If no match is found, the default schema is returned and a warning is logged.
Args:
schema_name (six.text_type): The name of the :class:`Message` sub-class;
this is typically the Python path.
Returns:
Message: A sub-class of :class:`Message` to create the message from.
"""
global _registry_loaded
if not _registry_loaded:
load_message_classes()
try:
return _schema_name_to_class[schema_name]
except KeyError:
_log.warning(
'The schema "%s" is not in the schema registry! Either install '
"the package with its schema definition or define a schema. "
"Falling back to the default schema...",
schema_name,
)
return Message | Retrieve the message class associated with the schema name.
If no match is found, the default schema is returned and a warning is logged.
Args:
schema_name (six.text_type): The name of the :class:`Message` sub-class;
this is typically the Python path.
Returns:
Message: A sub-class of :class:`Message` to create the message from. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L74-L100 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | get_name | def get_name(cls):
"""
Retrieve the schema name associated with a message class.
Returns:
str: The schema name.
Raises:
TypeError: If the message class isn't registered. Check your entry point
for correctness.
"""
global _registry_loaded
if not _registry_loaded:
load_message_classes()
try:
return _class_to_schema_name[cls]
except KeyError:
raise TypeError(
"The class {} is not in the message registry, which indicates it is"
' not in the current list of entry points for "fedora_messaging".'
" Please check that the class has been added to your package's"
" entry points.".format(repr(cls))
) | python | def get_name(cls):
"""
Retrieve the schema name associated with a message class.
Returns:
str: The schema name.
Raises:
TypeError: If the message class isn't registered. Check your entry point
for correctness.
"""
global _registry_loaded
if not _registry_loaded:
load_message_classes()
try:
return _class_to_schema_name[cls]
except KeyError:
raise TypeError(
"The class {} is not in the message registry, which indicates it is"
' not in the current list of entry points for "fedora_messaging".'
" Please check that the class has been added to your package's"
" entry points.".format(repr(cls))
) | Retrieve the schema name associated with a message class.
Returns:
str: The schema name.
Raises:
TypeError: If the message class isn't registered. Check your entry point
for correctness. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L103-L126 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | load_message_classes | def load_message_classes():
"""Load the 'fedora.messages' entry points and register the message classes."""
for message in pkg_resources.iter_entry_points("fedora.messages"):
cls = message.load()
_log.info(
"Registering the '%s' key as the '%r' class in the Message "
"class registry",
message.name,
cls,
)
_schema_name_to_class[message.name] = cls
_class_to_schema_name[cls] = message.name
global _registry_loaded
_registry_loaded = True | python | def load_message_classes():
"""Load the 'fedora.messages' entry points and register the message classes."""
for message in pkg_resources.iter_entry_points("fedora.messages"):
cls = message.load()
_log.info(
"Registering the '%s' key as the '%r' class in the Message "
"class registry",
message.name,
cls,
)
_schema_name_to_class[message.name] = cls
_class_to_schema_name[cls] = message.name
global _registry_loaded
_registry_loaded = True | Load the 'fedora.messages' entry points and register the message classes. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L129-L142 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | get_message | def get_message(routing_key, properties, body):
"""
Construct a Message instance given the routing key, the properties and the
body received from the AMQP broker.
Args:
routing_key (str): The AMQP routing key (will become the message topic)
properties (pika.BasicProperties): the AMQP properties
body (bytes): The encoded message body
Raises:
ValidationError: If Message validation failed or message body
docoding/loading is impossible.
"""
if properties.headers is None:
_log.error(
"Message (body=%r) arrived without headers. " "A publisher is misbehaving!",
body,
)
properties.headers = {}
try:
MessageClass = get_class(properties.headers["fedora_messaging_schema"])
except KeyError:
_log.error(
"Message (headers=%r, body=%r) arrived without a schema header."
" A publisher is misbehaving!",
properties.headers,
body,
)
MessageClass = Message
try:
severity = properties.headers["fedora_messaging_severity"]
except KeyError:
_log.error(
"Message (headers=%r, body=%r) arrived without a severity."
" A publisher is misbehaving! Defaulting to INFO.",
properties.headers,
body,
)
severity = INFO
if properties.content_encoding is None:
_log.error("Message arrived without a content encoding")
properties.content_encoding = "utf-8"
try:
body = body.decode(properties.content_encoding)
except UnicodeDecodeError as e:
_log.error(
"Unable to decode message body %r with %s content encoding",
body,
properties.content_encoding,
)
raise ValidationError(e)
try:
body = json.loads(body)
except ValueError as e:
_log.error("Failed to load message body %r, %r", body, e)
raise ValidationError(e)
message = MessageClass(
body=body, topic=routing_key, properties=properties, severity=severity
)
try:
message.validate()
_log.debug("Successfully validated message %r", message)
except jsonschema.exceptions.ValidationError as e:
_log.error("Message validation of %r failed: %r", message, e)
raise ValidationError(e)
return message | python | def get_message(routing_key, properties, body):
"""
Construct a Message instance given the routing key, the properties and the
body received from the AMQP broker.
Args:
routing_key (str): The AMQP routing key (will become the message topic)
properties (pika.BasicProperties): the AMQP properties
body (bytes): The encoded message body
Raises:
ValidationError: If Message validation failed or message body
docoding/loading is impossible.
"""
if properties.headers is None:
_log.error(
"Message (body=%r) arrived without headers. " "A publisher is misbehaving!",
body,
)
properties.headers = {}
try:
MessageClass = get_class(properties.headers["fedora_messaging_schema"])
except KeyError:
_log.error(
"Message (headers=%r, body=%r) arrived without a schema header."
" A publisher is misbehaving!",
properties.headers,
body,
)
MessageClass = Message
try:
severity = properties.headers["fedora_messaging_severity"]
except KeyError:
_log.error(
"Message (headers=%r, body=%r) arrived without a severity."
" A publisher is misbehaving! Defaulting to INFO.",
properties.headers,
body,
)
severity = INFO
if properties.content_encoding is None:
_log.error("Message arrived without a content encoding")
properties.content_encoding = "utf-8"
try:
body = body.decode(properties.content_encoding)
except UnicodeDecodeError as e:
_log.error(
"Unable to decode message body %r with %s content encoding",
body,
properties.content_encoding,
)
raise ValidationError(e)
try:
body = json.loads(body)
except ValueError as e:
_log.error("Failed to load message body %r, %r", body, e)
raise ValidationError(e)
message = MessageClass(
body=body, topic=routing_key, properties=properties, severity=severity
)
try:
message.validate()
_log.debug("Successfully validated message %r", message)
except jsonschema.exceptions.ValidationError as e:
_log.error("Message validation of %r failed: %r", message, e)
raise ValidationError(e)
return message | Construct a Message instance given the routing key, the properties and the
body received from the AMQP broker.
Args:
routing_key (str): The AMQP routing key (will become the message topic)
properties (pika.BasicProperties): the AMQP properties
body (bytes): The encoded message body
Raises:
ValidationError: If Message validation failed or message body
docoding/loading is impossible. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L145-L216 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | dumps | def dumps(messages):
"""
Serialize messages to a JSON formatted str
Args:
messages (list): The list of messages to serialize. Each message in
the messages is subclass of Messge.
Returns:
str: Serialized messages.
Raises:
TypeError: If at least one message is not instance of Message class or subclass.
"""
serialized_messages = []
try:
for message in messages:
message_dict = message._dump()
serialized_messages.append(message_dict)
except AttributeError:
_log.error("Improper object for messages serialization.")
raise TypeError("Message have to be instance of Message class or subclass.")
return json.dumps(serialized_messages, sort_keys=True) | python | def dumps(messages):
"""
Serialize messages to a JSON formatted str
Args:
messages (list): The list of messages to serialize. Each message in
the messages is subclass of Messge.
Returns:
str: Serialized messages.
Raises:
TypeError: If at least one message is not instance of Message class or subclass.
"""
serialized_messages = []
try:
for message in messages:
message_dict = message._dump()
serialized_messages.append(message_dict)
except AttributeError:
_log.error("Improper object for messages serialization.")
raise TypeError("Message have to be instance of Message class or subclass.")
return json.dumps(serialized_messages, sort_keys=True) | Serialize messages to a JSON formatted str
Args:
messages (list): The list of messages to serialize. Each message in
the messages is subclass of Messge.
Returns:
str: Serialized messages.
Raises:
TypeError: If at least one message is not instance of Message class or subclass. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L219-L242 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | loads | def loads(serialized_messages):
"""
Deserialize messages from a JSON formatted str
Args:
serialized_messages (JSON str):
Returns:
list: Deserialized message objects.
Raises:
ValidationError: If deserialized message validation failed.
KeyError: If serialized_messages aren't properly serialized.
ValueError: If serialized_messages is not valid JSON
"""
try:
messages_dicts = json.loads(serialized_messages)
except ValueError:
_log.error("Loading serialized messages failed.")
raise
messages = []
for message_dict in messages_dicts:
try:
headers = message_dict["headers"]
except KeyError:
_log.error("Message saved without headers.")
raise
try:
MessageClass = get_class(headers["fedora_messaging_schema"])
except KeyError:
_log.error("Message (headers=%r) saved without a schema header.", headers)
raise
try:
body = message_dict["body"]
except KeyError:
_log.error("Message saved without body.")
raise
try:
id = message_dict["id"]
except KeyError:
_log.error("Message saved without id.")
raise
try:
queue = message_dict["queue"]
except KeyError:
_log.warning("Message saved without queue.")
queue = None
try:
topic = message_dict["topic"]
except KeyError:
_log.error("Message saved without topic.")
raise
try:
severity = headers["fedora_messaging_severity"]
except KeyError:
_log.error("Message saved without a severity.")
raise
message = MessageClass(
body=body, topic=topic, headers=headers, severity=severity
)
try:
message.validate()
_log.debug("Successfully validated message %r", message)
except jsonschema.exceptions.ValidationError as e:
_log.error("Message validation of %r failed: %r", message, e)
raise ValidationError(e)
message.queue = queue
message.id = id
messages.append(message)
return messages | python | def loads(serialized_messages):
"""
Deserialize messages from a JSON formatted str
Args:
serialized_messages (JSON str):
Returns:
list: Deserialized message objects.
Raises:
ValidationError: If deserialized message validation failed.
KeyError: If serialized_messages aren't properly serialized.
ValueError: If serialized_messages is not valid JSON
"""
try:
messages_dicts = json.loads(serialized_messages)
except ValueError:
_log.error("Loading serialized messages failed.")
raise
messages = []
for message_dict in messages_dicts:
try:
headers = message_dict["headers"]
except KeyError:
_log.error("Message saved without headers.")
raise
try:
MessageClass = get_class(headers["fedora_messaging_schema"])
except KeyError:
_log.error("Message (headers=%r) saved without a schema header.", headers)
raise
try:
body = message_dict["body"]
except KeyError:
_log.error("Message saved without body.")
raise
try:
id = message_dict["id"]
except KeyError:
_log.error("Message saved without id.")
raise
try:
queue = message_dict["queue"]
except KeyError:
_log.warning("Message saved without queue.")
queue = None
try:
topic = message_dict["topic"]
except KeyError:
_log.error("Message saved without topic.")
raise
try:
severity = headers["fedora_messaging_severity"]
except KeyError:
_log.error("Message saved without a severity.")
raise
message = MessageClass(
body=body, topic=topic, headers=headers, severity=severity
)
try:
message.validate()
_log.debug("Successfully validated message %r", message)
except jsonschema.exceptions.ValidationError as e:
_log.error("Message validation of %r failed: %r", message, e)
raise ValidationError(e)
message.queue = queue
message.id = id
messages.append(message)
return messages | Deserialize messages from a JSON formatted str
Args:
serialized_messages (JSON str):
Returns:
list: Deserialized message objects.
Raises:
ValidationError: If deserialized message validation failed.
KeyError: If serialized_messages aren't properly serialized.
ValueError: If serialized_messages is not valid JSON | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L245-L324 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | Message._filter_headers | def _filter_headers(self):
"""
Add headers designed for filtering messages based on objects.
Returns:
dict: Filter-related headers to be combined with the existing headers
"""
headers = {}
for user in self.usernames:
headers["fedora_messaging_user_{}".format(user)] = True
for package in self.packages:
headers["fedora_messaging_rpm_{}".format(package)] = True
for container in self.containers:
headers["fedora_messaging_container_{}".format(container)] = True
for module in self.modules:
headers["fedora_messaging_module_{}".format(module)] = True
for flatpak in self.flatpaks:
headers["fedora_messaging_flatpak_{}".format(flatpak)] = True
return headers | python | def _filter_headers(self):
"""
Add headers designed for filtering messages based on objects.
Returns:
dict: Filter-related headers to be combined with the existing headers
"""
headers = {}
for user in self.usernames:
headers["fedora_messaging_user_{}".format(user)] = True
for package in self.packages:
headers["fedora_messaging_rpm_{}".format(package)] = True
for container in self.containers:
headers["fedora_messaging_container_{}".format(container)] = True
for module in self.modules:
headers["fedora_messaging_module_{}".format(module)] = True
for flatpak in self.flatpaks:
headers["fedora_messaging_flatpak_{}".format(flatpak)] = True
return headers | Add headers designed for filtering messages based on objects.
Returns:
dict: Filter-related headers to be combined with the existing headers | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L417-L435 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | Message._encoded_routing_key | def _encoded_routing_key(self):
"""The encoded routing key used to publish the message on the broker."""
topic = self.topic
if config.conf["topic_prefix"]:
topic = ".".join((config.conf["topic_prefix"].rstrip("."), topic))
return topic.encode("utf-8") | python | def _encoded_routing_key(self):
"""The encoded routing key used to publish the message on the broker."""
topic = self.topic
if config.conf["topic_prefix"]:
topic = ".".join((config.conf["topic_prefix"].rstrip("."), topic))
return topic.encode("utf-8") | The encoded routing key used to publish the message on the broker. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L460-L465 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | Message.validate | def validate(self):
"""
Validate the headers and body with the message schema, if any.
In addition to the user-provided schema, all messages are checked against
the base schema which requires certain message headers and the that body
be a JSON object.
.. warning:: This method should not be overridden by sub-classes.
Raises:
jsonschema.ValidationError: If either the message headers or the message body
are invalid.
jsonschema.SchemaError: If either the message header schema or the message body
schema are invalid.
"""
for schema in (self.headers_schema, Message.headers_schema):
_log.debug(
'Validating message headers "%r" with schema "%r"',
self._headers,
schema,
)
jsonschema.validate(self._headers, schema)
for schema in (self.body_schema, Message.body_schema):
_log.debug(
'Validating message body "%r" with schema "%r"', self.body, schema
)
jsonschema.validate(self.body, schema) | python | def validate(self):
"""
Validate the headers and body with the message schema, if any.
In addition to the user-provided schema, all messages are checked against
the base schema which requires certain message headers and the that body
be a JSON object.
.. warning:: This method should not be overridden by sub-classes.
Raises:
jsonschema.ValidationError: If either the message headers or the message body
are invalid.
jsonschema.SchemaError: If either the message header schema or the message body
schema are invalid.
"""
for schema in (self.headers_schema, Message.headers_schema):
_log.debug(
'Validating message headers "%r" with schema "%r"',
self._headers,
schema,
)
jsonschema.validate(self._headers, schema)
for schema in (self.body_schema, Message.body_schema):
_log.debug(
'Validating message body "%r" with schema "%r"', self.body, schema
)
jsonschema.validate(self.body, schema) | Validate the headers and body with the message schema, if any.
In addition to the user-provided schema, all messages are checked against
the base schema which requires certain message headers and the that body
be a JSON object.
.. warning:: This method should not be overridden by sub-classes.
Raises:
jsonschema.ValidationError: If either the message headers or the message body
are invalid.
jsonschema.SchemaError: If either the message header schema or the message body
schema are invalid. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L513-L540 |
fedora-infra/fedora-messaging | fedora_messaging/message.py | Message._dump | def _dump(self):
"""
Dump message attributes.
Returns:
dict: A dictionary of message attributes.
"""
return {
"topic": self.topic,
"headers": self._headers,
"id": self.id,
"body": self.body,
"queue": self.queue,
} | python | def _dump(self):
"""
Dump message attributes.
Returns:
dict: A dictionary of message attributes.
"""
return {
"topic": self.topic,
"headers": self._headers,
"id": self.id,
"body": self.body,
"queue": self.queue,
} | Dump message attributes.
Returns:
dict: A dictionary of message attributes. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/message.py#L646-L659 |
fedora-infra/fedora-messaging | fedora_messaging/api.py | _check_callback | def _check_callback(callback):
"""
Turns a callback that is potentially a class into a callable object.
Args:
callback (object): An object that might be a class, method, or function.
if the object is a class, this creates an instance of it.
Raises:
ValueError: If an instance can't be created or it isn't a callable object.
TypeError: If the class requires arguments to be instantiated.
Returns:
callable: A callable object suitable for use as the consumer callback.
"""
# If the callback is a class, create an instance of it first
if inspect.isclass(callback):
callback_object = callback()
if not callable(callback_object):
raise ValueError(
"Callback must be a class that implements __call__ or a function."
)
elif callable(callback):
callback_object = callback
else:
raise ValueError(
"Callback must be a class that implements __call__ or a function."
)
return callback_object | python | def _check_callback(callback):
"""
Turns a callback that is potentially a class into a callable object.
Args:
callback (object): An object that might be a class, method, or function.
if the object is a class, this creates an instance of it.
Raises:
ValueError: If an instance can't be created or it isn't a callable object.
TypeError: If the class requires arguments to be instantiated.
Returns:
callable: A callable object suitable for use as the consumer callback.
"""
# If the callback is a class, create an instance of it first
if inspect.isclass(callback):
callback_object = callback()
if not callable(callback_object):
raise ValueError(
"Callback must be a class that implements __call__ or a function."
)
elif callable(callback):
callback_object = callback
else:
raise ValueError(
"Callback must be a class that implements __call__ or a function."
)
return callback_object | Turns a callback that is potentially a class into a callable object.
Args:
callback (object): An object that might be a class, method, or function.
if the object is a class, this creates an instance of it.
Raises:
ValueError: If an instance can't be created or it isn't a callable object.
TypeError: If the class requires arguments to be instantiated.
Returns:
callable: A callable object suitable for use as the consumer callback. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/api.py#L34-L63 |
fedora-infra/fedora-messaging | fedora_messaging/api.py | twisted_consume | def twisted_consume(callback, bindings=None, queues=None):
"""
Start a consumer using the provided callback and run it using the Twisted
event loop (reactor).
.. note:: Callbacks run in a Twisted-managed thread pool using the
:func:`twisted.internet.threads.deferToThread` API to avoid them blocking
the event loop. If you wish to use Twisted APIs in your callback you must
use the :func:`twisted.internet.threads.blockingCallFromThread` or
:class:`twisted.internet.interfaces.IReactorFromThreads` APIs.
This API expects the caller to start the reactor.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`.Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue to declare and consume from. Each key in this
dictionary should be a queue name to declare, and each value should
be a dictionary with the "durable", "auto_delete", "exclusive", and
"arguments" keys.
Returns:
twisted.internet.defer.Deferred:
A deferred that fires with the list of one or more
:class:`.Consumer` objects. Each consumer object has a
:attr:`.Consumer.result` instance variable that is a Deferred that
fires or errors when the consumer halts. Note that this API is
meant to survive network problems, so consuming will continue until
:meth:`.Consumer.cancel` is called or a fatal server error occurs.
The deferred returned by this function may error back with a
:class:`fedora_messaging.exceptions.BadDeclaration` if queues or
bindings cannot be declared on the broker, a
:class:`fedora_messaging.exceptions.PermissionException` if the user
doesn't have access to the queue, or
:class:`fedora_messaging.exceptions.ConnectionException` if the TLS
or AMQP handshake fails.
"""
if isinstance(bindings, dict):
bindings = [bindings]
callback = _check_callback(callback)
global _twisted_service
if _twisted_service is None:
_twisted_service = service.FedoraMessagingServiceV2(config.conf["amqp_url"])
reactor.callWhenRunning(_twisted_service.startService)
# Twisted is killing the underlying connection before stopService gets
# called, so we need to add it as a pre-shutdown event to gracefully
# finish up messages in progress.
reactor.addSystemEventTrigger(
"before", "shutdown", _twisted_service.stopService
)
return _twisted_service._service.factory.consume(callback, bindings, queues) | python | def twisted_consume(callback, bindings=None, queues=None):
"""
Start a consumer using the provided callback and run it using the Twisted
event loop (reactor).
.. note:: Callbacks run in a Twisted-managed thread pool using the
:func:`twisted.internet.threads.deferToThread` API to avoid them blocking
the event loop. If you wish to use Twisted APIs in your callback you must
use the :func:`twisted.internet.threads.blockingCallFromThread` or
:class:`twisted.internet.interfaces.IReactorFromThreads` APIs.
This API expects the caller to start the reactor.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`.Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue to declare and consume from. Each key in this
dictionary should be a queue name to declare, and each value should
be a dictionary with the "durable", "auto_delete", "exclusive", and
"arguments" keys.
Returns:
twisted.internet.defer.Deferred:
A deferred that fires with the list of one or more
:class:`.Consumer` objects. Each consumer object has a
:attr:`.Consumer.result` instance variable that is a Deferred that
fires or errors when the consumer halts. Note that this API is
meant to survive network problems, so consuming will continue until
:meth:`.Consumer.cancel` is called or a fatal server error occurs.
The deferred returned by this function may error back with a
:class:`fedora_messaging.exceptions.BadDeclaration` if queues or
bindings cannot be declared on the broker, a
:class:`fedora_messaging.exceptions.PermissionException` if the user
doesn't have access to the queue, or
:class:`fedora_messaging.exceptions.ConnectionException` if the TLS
or AMQP handshake fails.
"""
if isinstance(bindings, dict):
bindings = [bindings]
callback = _check_callback(callback)
global _twisted_service
if _twisted_service is None:
_twisted_service = service.FedoraMessagingServiceV2(config.conf["amqp_url"])
reactor.callWhenRunning(_twisted_service.startService)
# Twisted is killing the underlying connection before stopService gets
# called, so we need to add it as a pre-shutdown event to gracefully
# finish up messages in progress.
reactor.addSystemEventTrigger(
"before", "shutdown", _twisted_service.stopService
)
return _twisted_service._service.factory.consume(callback, bindings, queues) | Start a consumer using the provided callback and run it using the Twisted
event loop (reactor).
.. note:: Callbacks run in a Twisted-managed thread pool using the
:func:`twisted.internet.threads.deferToThread` API to avoid them blocking
the event loop. If you wish to use Twisted APIs in your callback you must
use the :func:`twisted.internet.threads.blockingCallFromThread` or
:class:`twisted.internet.interfaces.IReactorFromThreads` APIs.
This API expects the caller to start the reactor.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`.Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue to declare and consume from. Each key in this
dictionary should be a queue name to declare, and each value should
be a dictionary with the "durable", "auto_delete", "exclusive", and
"arguments" keys.
Returns:
twisted.internet.defer.Deferred:
A deferred that fires with the list of one or more
:class:`.Consumer` objects. Each consumer object has a
:attr:`.Consumer.result` instance variable that is a Deferred that
fires or errors when the consumer halts. Note that this API is
meant to survive network problems, so consuming will continue until
:meth:`.Consumer.cancel` is called or a fatal server error occurs.
The deferred returned by this function may error back with a
:class:`fedora_messaging.exceptions.BadDeclaration` if queues or
bindings cannot be declared on the broker, a
:class:`fedora_messaging.exceptions.PermissionException` if the user
doesn't have access to the queue, or
:class:`fedora_messaging.exceptions.ConnectionException` if the TLS
or AMQP handshake fails. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/api.py#L66-L121 |
fedora-infra/fedora-messaging | fedora_messaging/api.py | consume | def consume(callback, bindings=None, queues=None):
"""
Start a message consumer that executes the provided callback when messages are
received.
This API is blocking and will not return until the process receives a signal
from the operating system.
.. warning:: This API is runs the callback in the IO loop thread. This means
if your callback could run for a length of time near the heartbeat interval,
which is likely on the order of 60 seconds, the broker will kill the TCP
connection and the message will be re-delivered on start-up.
For now, use the :func:`twisted_consume` API which runs the
callback in a thread and continues to handle AMQP events while the
callback runs if you have a long-running callback.
The callback receives a single positional argument, the message:
>>> from fedora_messaging import api
>>> def my_callback(message):
... print(message)
>>> bindings = [{'exchange': 'amq.topic', 'queue': 'demo', 'routing_keys': ['#']}]
>>> queues = {
... "demo": {"durable": False, "auto_delete": True, "exclusive": True, "arguments": {}}
... }
>>> api.consume(my_callback, bindings=bindings, queues=queues)
If the bindings and queue arguments are not provided, they will be loaded from
the configuration.
For complete documentation on writing consumers, see the :ref:`consumers`
documentation.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue or queues to declare and consume from. This should be
in the same format as the :ref:`conf-queues` configuration dictionary where
each key is a queue name and each value is a dictionary of settings for that
queue.
Raises:
fedora_messaging.exceptions.HaltConsumer: If the consumer requests that
it be stopped.
ValueError: If the consumer provide callback that is not a class that
implements __call__ and is not a function, if the bindings argument
is not a dict or list of dicts with the proper keys, or if the queues
argument isn't a dict with the proper keys.
"""
if isinstance(bindings, dict):
bindings = [bindings]
if bindings is None:
bindings = config.conf["bindings"]
else:
try:
config.validate_bindings(bindings)
except exceptions.ConfigurationException as e:
raise ValueError(e.message)
if queues is None:
queues = config.conf["queues"]
else:
try:
config.validate_queues(queues)
except exceptions.ConfigurationException as e:
raise ValueError(e.message)
session = _session.ConsumerSession()
session.consume(callback, bindings=bindings, queues=queues) | python | def consume(callback, bindings=None, queues=None):
"""
Start a message consumer that executes the provided callback when messages are
received.
This API is blocking and will not return until the process receives a signal
from the operating system.
.. warning:: This API is runs the callback in the IO loop thread. This means
if your callback could run for a length of time near the heartbeat interval,
which is likely on the order of 60 seconds, the broker will kill the TCP
connection and the message will be re-delivered on start-up.
For now, use the :func:`twisted_consume` API which runs the
callback in a thread and continues to handle AMQP events while the
callback runs if you have a long-running callback.
The callback receives a single positional argument, the message:
>>> from fedora_messaging import api
>>> def my_callback(message):
... print(message)
>>> bindings = [{'exchange': 'amq.topic', 'queue': 'demo', 'routing_keys': ['#']}]
>>> queues = {
... "demo": {"durable": False, "auto_delete": True, "exclusive": True, "arguments": {}}
... }
>>> api.consume(my_callback, bindings=bindings, queues=queues)
If the bindings and queue arguments are not provided, they will be loaded from
the configuration.
For complete documentation on writing consumers, see the :ref:`consumers`
documentation.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue or queues to declare and consume from. This should be
in the same format as the :ref:`conf-queues` configuration dictionary where
each key is a queue name and each value is a dictionary of settings for that
queue.
Raises:
fedora_messaging.exceptions.HaltConsumer: If the consumer requests that
it be stopped.
ValueError: If the consumer provide callback that is not a class that
implements __call__ and is not a function, if the bindings argument
is not a dict or list of dicts with the proper keys, or if the queues
argument isn't a dict with the proper keys.
"""
if isinstance(bindings, dict):
bindings = [bindings]
if bindings is None:
bindings = config.conf["bindings"]
else:
try:
config.validate_bindings(bindings)
except exceptions.ConfigurationException as e:
raise ValueError(e.message)
if queues is None:
queues = config.conf["queues"]
else:
try:
config.validate_queues(queues)
except exceptions.ConfigurationException as e:
raise ValueError(e.message)
session = _session.ConsumerSession()
session.consume(callback, bindings=bindings, queues=queues) | Start a message consumer that executes the provided callback when messages are
received.
This API is blocking and will not return until the process receives a signal
from the operating system.
.. warning:: This API is runs the callback in the IO loop thread. This means
if your callback could run for a length of time near the heartbeat interval,
which is likely on the order of 60 seconds, the broker will kill the TCP
connection and the message will be re-delivered on start-up.
For now, use the :func:`twisted_consume` API which runs the
callback in a thread and continues to handle AMQP events while the
callback runs if you have a long-running callback.
The callback receives a single positional argument, the message:
>>> from fedora_messaging import api
>>> def my_callback(message):
... print(message)
>>> bindings = [{'exchange': 'amq.topic', 'queue': 'demo', 'routing_keys': ['#']}]
>>> queues = {
... "demo": {"durable": False, "auto_delete": True, "exclusive": True, "arguments": {}}
... }
>>> api.consume(my_callback, bindings=bindings, queues=queues)
If the bindings and queue arguments are not provided, they will be loaded from
the configuration.
For complete documentation on writing consumers, see the :ref:`consumers`
documentation.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queue or queues to declare and consume from. This should be
in the same format as the :ref:`conf-queues` configuration dictionary where
each key is a queue name and each value is a dictionary of settings for that
queue.
Raises:
fedora_messaging.exceptions.HaltConsumer: If the consumer requests that
it be stopped.
ValueError: If the consumer provide callback that is not a class that
implements __call__ and is not a function, if the bindings argument
is not a dict or list of dicts with the proper keys, or if the queues
argument isn't a dict with the proper keys. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/api.py#L124-L197 |
fedora-infra/fedora-messaging | fedora_messaging/api.py | publish | def publish(message, exchange=None):
"""
Publish a message to an exchange.
This is a synchronous call, meaning that when this function returns, an
acknowledgment has been received from the message broker and you can be
certain the message was published successfully.
There are some cases where an error occurs despite your message being
successfully published. For example, if a network partition occurs after
the message is received by the broker. Therefore, you may publish duplicate
messages. For complete details, see the :ref:`publishing` documentation.
>>> from fedora_messaging import api
>>> message = api.Message(body={'Hello': 'world'}, topic='Hi')
>>> api.publish(message)
If an attempt to publish fails because the broker rejects the message, it
is not retried. Connection attempts to the broker can be configured using
the "connection_attempts" and "retry_delay" options in the broker URL. See
:class:`pika.connection.URLParameters` for details.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults to
:ref:`conf-publish-exchange`
Raises:
fedora_messaging.exceptions.PublishReturned: Raised if the broker rejects the
message.
fedora_messaging.exceptions.ConnectionException: Raised if a connection error
occurred before the publish confirmation arrived.
fedora_messaging.exceptions.ValidationError: Raised if the message
fails validation with its JSON schema. This only depends on the
message you are trying to send, the AMQP server is not involved.
"""
pre_publish_signal.send(publish, message=message)
if exchange is None:
exchange = config.conf["publish_exchange"]
global _session_cache
if not hasattr(_session_cache, "session"):
_session_cache.session = _session.PublisherSession()
try:
_session_cache.session.publish(message, exchange=exchange)
publish_signal.send(publish, message=message)
except exceptions.PublishException as e:
publish_failed_signal.send(publish, message=message, reason=e)
raise | python | def publish(message, exchange=None):
"""
Publish a message to an exchange.
This is a synchronous call, meaning that when this function returns, an
acknowledgment has been received from the message broker and you can be
certain the message was published successfully.
There are some cases where an error occurs despite your message being
successfully published. For example, if a network partition occurs after
the message is received by the broker. Therefore, you may publish duplicate
messages. For complete details, see the :ref:`publishing` documentation.
>>> from fedora_messaging import api
>>> message = api.Message(body={'Hello': 'world'}, topic='Hi')
>>> api.publish(message)
If an attempt to publish fails because the broker rejects the message, it
is not retried. Connection attempts to the broker can be configured using
the "connection_attempts" and "retry_delay" options in the broker URL. See
:class:`pika.connection.URLParameters` for details.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults to
:ref:`conf-publish-exchange`
Raises:
fedora_messaging.exceptions.PublishReturned: Raised if the broker rejects the
message.
fedora_messaging.exceptions.ConnectionException: Raised if a connection error
occurred before the publish confirmation arrived.
fedora_messaging.exceptions.ValidationError: Raised if the message
fails validation with its JSON schema. This only depends on the
message you are trying to send, the AMQP server is not involved.
"""
pre_publish_signal.send(publish, message=message)
if exchange is None:
exchange = config.conf["publish_exchange"]
global _session_cache
if not hasattr(_session_cache, "session"):
_session_cache.session = _session.PublisherSession()
try:
_session_cache.session.publish(message, exchange=exchange)
publish_signal.send(publish, message=message)
except exceptions.PublishException as e:
publish_failed_signal.send(publish, message=message, reason=e)
raise | Publish a message to an exchange.
This is a synchronous call, meaning that when this function returns, an
acknowledgment has been received from the message broker and you can be
certain the message was published successfully.
There are some cases where an error occurs despite your message being
successfully published. For example, if a network partition occurs after
the message is received by the broker. Therefore, you may publish duplicate
messages. For complete details, see the :ref:`publishing` documentation.
>>> from fedora_messaging import api
>>> message = api.Message(body={'Hello': 'world'}, topic='Hi')
>>> api.publish(message)
If an attempt to publish fails because the broker rejects the message, it
is not retried. Connection attempts to the broker can be configured using
the "connection_attempts" and "retry_delay" options in the broker URL. See
:class:`pika.connection.URLParameters` for details.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults to
:ref:`conf-publish-exchange`
Raises:
fedora_messaging.exceptions.PublishReturned: Raised if the broker rejects the
message.
fedora_messaging.exceptions.ConnectionException: Raised if a connection error
occurred before the publish confirmation arrived.
fedora_messaging.exceptions.ValidationError: Raised if the message
fails validation with its JSON schema. This only depends on the
message you are trying to send, the AMQP server is not involved. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/api.py#L200-L250 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.buildProtocol | def buildProtocol(self, addr):
"""Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
self.resetDelay()
self.client = self.protocol(self._parameters)
self.client.factory = self
self.client.ready.addCallback(lambda _: self._on_client_ready())
return self.client | python | def buildProtocol(self, addr):
"""Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
self.resetDelay()
self.client = self.protocol(self._parameters)
self.client.factory = self
self.client.ready.addCallback(lambda _: self._on_client_ready())
return self.client | Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L99-L109 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory._on_client_ready | def _on_client_ready(self):
"""Called when the client is ready to send and receive messages."""
_legacy_twisted_log.msg("Successfully connected to the AMQP broker.")
yield self.client.resumeProducing()
yield self.client.declare_exchanges(self.exchanges)
yield self.client.declare_queues(self.queues)
yield self.client.bind_queues(self.bindings)
for queue, callback in self.consumers.items():
yield self.client.consume(callback, queue)
_legacy_twisted_log.msg("Successfully declared all AMQP objects.")
self._client_ready.callback(None) | python | def _on_client_ready(self):
"""Called when the client is ready to send and receive messages."""
_legacy_twisted_log.msg("Successfully connected to the AMQP broker.")
yield self.client.resumeProducing()
yield self.client.declare_exchanges(self.exchanges)
yield self.client.declare_queues(self.queues)
yield self.client.bind_queues(self.bindings)
for queue, callback in self.consumers.items():
yield self.client.consume(callback, queue)
_legacy_twisted_log.msg("Successfully declared all AMQP objects.")
self._client_ready.callback(None) | Called when the client is ready to send and receive messages. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L112-L124 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.clientConnectionLost | def clientConnectionLost(self, connector, reason):
"""Called when the connection to the broker has been lost.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if not isinstance(reason.value, error.ConnectionDone):
_legacy_twisted_log.msg(
"Lost connection to the AMQP broker ({reason})",
reason=reason.value,
logLevel=logging.WARNING,
)
if self._client_ready.called:
# Renew the ready deferred, it will callback when the
# next connection is ready.
self._client_ready = defer.Deferred()
protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason) | python | def clientConnectionLost(self, connector, reason):
"""Called when the connection to the broker has been lost.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if not isinstance(reason.value, error.ConnectionDone):
_legacy_twisted_log.msg(
"Lost connection to the AMQP broker ({reason})",
reason=reason.value,
logLevel=logging.WARNING,
)
if self._client_ready.called:
# Renew the ready deferred, it will callback when the
# next connection is ready.
self._client_ready = defer.Deferred()
protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason) | Called when the connection to the broker has been lost.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L126-L142 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.clientConnectionFailed | def clientConnectionFailed(self, connector, reason):
"""Called when the client has failed to connect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
_legacy_twisted_log.msg(
"Connection to the AMQP broker failed ({reason})",
reason=reason.value,
logLevel=logging.WARNING,
)
protocol.ReconnectingClientFactory.clientConnectionFailed(
self, connector, reason
) | python | def clientConnectionFailed(self, connector, reason):
"""Called when the client has failed to connect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
_legacy_twisted_log.msg(
"Connection to the AMQP broker failed ({reason})",
reason=reason.value,
logLevel=logging.WARNING,
)
protocol.ReconnectingClientFactory.clientConnectionFailed(
self, connector, reason
) | Called when the client has failed to connect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L144-L157 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.stopTrying | def stopTrying(self):
"""Stop trying to reconnect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
protocol.ReconnectingClientFactory.stopTrying(self)
if not self._client_ready.called:
self._client_ready.errback(
pika.exceptions.AMQPConnectionError(
u"Could not connect, reconnection cancelled."
)
) | python | def stopTrying(self):
"""Stop trying to reconnect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
protocol.ReconnectingClientFactory.stopTrying(self)
if not self._client_ready.called:
self._client_ready.errback(
pika.exceptions.AMQPConnectionError(
u"Could not connect, reconnection cancelled."
)
) | Stop trying to reconnect to the broker.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L159-L171 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.stopFactory | def stopFactory(self):
"""Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if self.client:
yield self.client.stopProducing()
protocol.ReconnectingClientFactory.stopFactory(self) | python | def stopFactory(self):
"""Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if self.client:
yield self.client.stopProducing()
protocol.ReconnectingClientFactory.stopFactory(self) | Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L174-L182 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.consume | def consume(self, callback, queue):
"""
Register a new consumer.
This consumer will be configured for every protocol this factory
produces so it will be reconfigured on network failures. If a connection
is already active, the consumer will be added to it.
Args:
callback (callable): The callback to invoke when a message arrives.
queue (str): The name of the queue to consume from.
"""
self.consumers[queue] = callback
if self._client_ready.called:
return self.client.consume(callback, queue) | python | def consume(self, callback, queue):
"""
Register a new consumer.
This consumer will be configured for every protocol this factory
produces so it will be reconfigured on network failures. If a connection
is already active, the consumer will be added to it.
Args:
callback (callable): The callback to invoke when a message arrives.
queue (str): The name of the queue to consume from.
"""
self.consumers[queue] = callback
if self._client_ready.called:
return self.client.consume(callback, queue) | Register a new consumer.
This consumer will be configured for every protocol this factory
produces so it will be reconfigured on network failures. If a connection
is already active, the consumer will be added to it.
Args:
callback (callable): The callback to invoke when a message arrives.
queue (str): The name of the queue to consume from. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L184-L198 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.cancel | def cancel(self, queue):
"""
Cancel the consumer for a queue.
This removes the consumer from the list of consumers to be configured for
every connection.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred or None: Either a Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`defer.maybeDeferred` to always receive a Deferred.
"""
try:
del self.consumers[queue]
except KeyError:
pass
if self.client:
return self.client.cancel(queue) | python | def cancel(self, queue):
"""
Cancel the consumer for a queue.
This removes the consumer from the list of consumers to be configured for
every connection.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred or None: Either a Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`defer.maybeDeferred` to always receive a Deferred.
"""
try:
del self.consumers[queue]
except KeyError:
pass
if self.client:
return self.client.cancel(queue) | Cancel the consumer for a queue.
This removes the consumer from the list of consumers to be configured for
every connection.
Args:
queue (str): The name of the queue the consumer is subscribed to.
Returns:
defer.Deferred or None: Either a Deferred that fires when the consumer
is canceled, or None if the consumer was already canceled. Wrap
the call in :func:`defer.maybeDeferred` to always receive a Deferred. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L200-L219 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactory.publish | def publish(self, message, exchange=None):
"""
Publish a :class:`fedora_messaging.message.Message` to an `exchange`_
on the message broker. This call will survive connection failures and try
until it succeeds or is canceled.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
returns:
defer.Deferred: A deferred that fires when the message is published.
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing. Calling
this method again will wait for the next connection and publish when it
is available.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges
"""
exchange = exchange or config.conf["publish_exchange"]
while True:
client = yield self.whenConnected()
try:
yield client.publish(message, exchange)
break
except ConnectionException:
continue | python | def publish(self, message, exchange=None):
"""
Publish a :class:`fedora_messaging.message.Message` to an `exchange`_
on the message broker. This call will survive connection failures and try
until it succeeds or is canceled.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
returns:
defer.Deferred: A deferred that fires when the message is published.
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing. Calling
this method again will wait for the next connection and publish when it
is available.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges
"""
exchange = exchange or config.conf["publish_exchange"]
while True:
client = yield self.whenConnected()
try:
yield client.publish(message, exchange)
break
except ConnectionException:
continue | Publish a :class:`fedora_messaging.message.Message` to an `exchange`_
on the message broker. This call will survive connection failures and try
until it succeeds or is canceled.
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
returns:
defer.Deferred: A deferred that fires when the message is published.
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing. Calling
this method again will wait for the next connection and publish when it
is available.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L234-L263 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactoryV2.buildProtocol | def buildProtocol(self, addr):
"""Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
self._client = self.protocol(self._parameters, confirms=self.confirms)
self._client.factory = self
@defer.inlineCallbacks
def on_ready(unused_param=None):
"""Reset the connection delay when the AMQP handshake is complete."""
_std_log.debug("AMQP handshake completed; connection ready for use")
self.resetDelay()
self._client_deferred.callback(self._client)
self._client_deferred = defer.Deferred()
# Restart any consumer from previous connections that wasn't canceled
# including queues and bindings, as the queue might not have been durable
for consumer, queue, bindings in self._consumers.values():
_std_log.info("Re-registering the %r consumer", consumer)
yield self._client.declare_queues([queue])
yield self._client.bind_queues(bindings)
yield self._client.consume(consumer.callback, consumer.queue, consumer)
def on_ready_errback(failure):
"""If opening the connection fails or is lost, this errback is called."""
if failure.check(pika.exceptions.AMQPConnectionError, error.ConnectionDone):
# In this case the connection failed to open. This will be called
# if the TLS handshake goes wrong (likely) and it may be called if
# the AMQP handshake fails. It's *probably* a problem with the
# credentials.
msg = (
"The TCP connection appears to have started, but the TLS or AMQP handshake "
"with the broker failed; check your connection and authentication "
"parameters and ensure your user has permission to access the vhost"
)
wrapped_failure = Failure(
exc_value=ConnectionException(reason=msg, original=failure),
exc_type=ConnectionException,
)
self._client_deferred.errback(wrapped_failure)
else:
# Some unexpected exception happened
_std_log.exception(
"The connection failed with an unexpected exception; please report this bug."
)
self._client.ready.addCallback(on_ready)
self._client.ready.addErrback(on_ready_errback)
return self._client | python | def buildProtocol(self, addr):
"""Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
self._client = self.protocol(self._parameters, confirms=self.confirms)
self._client.factory = self
@defer.inlineCallbacks
def on_ready(unused_param=None):
"""Reset the connection delay when the AMQP handshake is complete."""
_std_log.debug("AMQP handshake completed; connection ready for use")
self.resetDelay()
self._client_deferred.callback(self._client)
self._client_deferred = defer.Deferred()
# Restart any consumer from previous connections that wasn't canceled
# including queues and bindings, as the queue might not have been durable
for consumer, queue, bindings in self._consumers.values():
_std_log.info("Re-registering the %r consumer", consumer)
yield self._client.declare_queues([queue])
yield self._client.bind_queues(bindings)
yield self._client.consume(consumer.callback, consumer.queue, consumer)
def on_ready_errback(failure):
"""If opening the connection fails or is lost, this errback is called."""
if failure.check(pika.exceptions.AMQPConnectionError, error.ConnectionDone):
# In this case the connection failed to open. This will be called
# if the TLS handshake goes wrong (likely) and it may be called if
# the AMQP handshake fails. It's *probably* a problem with the
# credentials.
msg = (
"The TCP connection appears to have started, but the TLS or AMQP handshake "
"with the broker failed; check your connection and authentication "
"parameters and ensure your user has permission to access the vhost"
)
wrapped_failure = Failure(
exc_value=ConnectionException(reason=msg, original=failure),
exc_type=ConnectionException,
)
self._client_deferred.errback(wrapped_failure)
else:
# Some unexpected exception happened
_std_log.exception(
"The connection failed with an unexpected exception; please report this bug."
)
self._client.ready.addCallback(on_ready)
self._client.ready.addErrback(on_ready_errback)
return self._client | Create the Protocol instance.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L296-L346 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactoryV2.stopFactory | def stopFactory(self):
"""Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if self._client:
yield self._client.halt()
protocol.ReconnectingClientFactory.stopFactory(self) | python | def stopFactory(self):
"""Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details.
"""
if self._client:
yield self._client.halt()
protocol.ReconnectingClientFactory.stopFactory(self) | Stop the factory.
See the documentation of
`twisted.internet.protocol.ReconnectingClientFactory` for details. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L349-L357 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactoryV2.when_connected | def when_connected(self):
"""
Retrieve the currently-connected Protocol, or the next one to connect.
Returns:
defer.Deferred: A Deferred that fires with a connected
:class:`FedoraMessagingProtocolV2` instance. This is similar to
the whenConnected method from the Twisted endpoints APIs, which
is sadly isn't available before 16.1.0, which isn't available
in EL7.
"""
if self._client and not self._client.is_closed:
return defer.succeed(self._client)
else:
return self._client_deferred | python | def when_connected(self):
"""
Retrieve the currently-connected Protocol, or the next one to connect.
Returns:
defer.Deferred: A Deferred that fires with a connected
:class:`FedoraMessagingProtocolV2` instance. This is similar to
the whenConnected method from the Twisted endpoints APIs, which
is sadly isn't available before 16.1.0, which isn't available
in EL7.
"""
if self._client and not self._client.is_closed:
return defer.succeed(self._client)
else:
return self._client_deferred | Retrieve the currently-connected Protocol, or the next one to connect.
Returns:
defer.Deferred: A Deferred that fires with a connected
:class:`FedoraMessagingProtocolV2` instance. This is similar to
the whenConnected method from the Twisted endpoints APIs, which
is sadly isn't available before 16.1.0, which isn't available
in EL7. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L359-L373 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactoryV2.consume | def consume(self, callback, bindings, queues):
"""
Start a consumer that lasts across individual connections.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queues to declare and consume from. Each key in this
dictionary is a queue, and each value is its settings as a dictionary.
These settings dictionaries should have the "durable", "auto_delete",
"exclusive", and "arguments" keys. Refer to :ref:`conf-queues` for
details on their meanings.
Returns:
defer.Deferred:
A deferred that fires with the list of one or more
:class:`fedora_messaging.twisted.consumer.Consumer` objects.
These can be passed to the
:meth:`FedoraMessagingFactoryV2.cancel` API to halt them. Each
consumer object has a ``result`` instance variable that is a
Deferred that fires or errors when the consumer halts. The
Deferred may error back with a BadDeclaration if the user does
not have permissions to consume from the queue.
"""
expanded_bindings = collections.defaultdict(list)
for binding in bindings:
for key in binding["routing_keys"]:
b = binding.copy()
del b["routing_keys"]
b["routing_key"] = key
expanded_bindings[b["queue"]].append(b)
expanded_queues = []
for name, settings in queues.items():
q = {"queue": name}
q.update(settings)
expanded_queues.append(q)
protocol = yield self.when_connected()
consumers = []
for queue in expanded_queues:
yield protocol.declare_queues([queue])
b = expanded_bindings.get(queue["queue"], [])
yield protocol.bind_queues(b)
consumer = yield protocol.consume(callback, queue["queue"])
self._consumers[queue["queue"]] = (consumer, queue, b)
consumers.append(consumer)
defer.returnValue(consumers) | python | def consume(self, callback, bindings, queues):
"""
Start a consumer that lasts across individual connections.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queues to declare and consume from. Each key in this
dictionary is a queue, and each value is its settings as a dictionary.
These settings dictionaries should have the "durable", "auto_delete",
"exclusive", and "arguments" keys. Refer to :ref:`conf-queues` for
details on their meanings.
Returns:
defer.Deferred:
A deferred that fires with the list of one or more
:class:`fedora_messaging.twisted.consumer.Consumer` objects.
These can be passed to the
:meth:`FedoraMessagingFactoryV2.cancel` API to halt them. Each
consumer object has a ``result`` instance variable that is a
Deferred that fires or errors when the consumer halts. The
Deferred may error back with a BadDeclaration if the user does
not have permissions to consume from the queue.
"""
expanded_bindings = collections.defaultdict(list)
for binding in bindings:
for key in binding["routing_keys"]:
b = binding.copy()
del b["routing_keys"]
b["routing_key"] = key
expanded_bindings[b["queue"]].append(b)
expanded_queues = []
for name, settings in queues.items():
q = {"queue": name}
q.update(settings)
expanded_queues.append(q)
protocol = yield self.when_connected()
consumers = []
for queue in expanded_queues:
yield protocol.declare_queues([queue])
b = expanded_bindings.get(queue["queue"], [])
yield protocol.bind_queues(b)
consumer = yield protocol.consume(callback, queue["queue"])
self._consumers[queue["queue"]] = (consumer, queue, b)
consumers.append(consumer)
defer.returnValue(consumers) | Start a consumer that lasts across individual connections.
Args:
callback (callable): A callable object that accepts one positional argument,
a :class:`Message` or a class object that implements the ``__call__``
method. The class will be instantiated before use.
bindings (dict or list of dict): Bindings to declare before consuming. This
should be the same format as the :ref:`conf-bindings` configuration.
queues (dict): The queues to declare and consume from. Each key in this
dictionary is a queue, and each value is its settings as a dictionary.
These settings dictionaries should have the "durable", "auto_delete",
"exclusive", and "arguments" keys. Refer to :ref:`conf-queues` for
details on their meanings.
Returns:
defer.Deferred:
A deferred that fires with the list of one or more
:class:`fedora_messaging.twisted.consumer.Consumer` objects.
These can be passed to the
:meth:`FedoraMessagingFactoryV2.cancel` API to halt them. Each
consumer object has a ``result`` instance variable that is a
Deferred that fires or errors when the consumer halts. The
Deferred may error back with a BadDeclaration if the user does
not have permissions to consume from the queue. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L376-L428 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/factory.py | FedoraMessagingFactoryV2.cancel | def cancel(self, consumers):
"""
Cancel a consumer that was previously started with consume.
Args:
consumer (list of fedora_messaging.api.Consumer): The consumers to cancel.
"""
for consumer in consumers:
del self._consumers[consumer.queue]
protocol = yield self.when_connected()
yield protocol.cancel(consumer) | python | def cancel(self, consumers):
"""
Cancel a consumer that was previously started with consume.
Args:
consumer (list of fedora_messaging.api.Consumer): The consumers to cancel.
"""
for consumer in consumers:
del self._consumers[consumer.queue]
protocol = yield self.when_connected()
yield protocol.cancel(consumer) | Cancel a consumer that was previously started with consume.
Args:
consumer (list of fedora_messaging.api.Consumer): The consumers to cancel. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/factory.py#L431-L441 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/consumer.py | Consumer.cancel | def cancel(self):
"""
Cancel the consumer and clean up resources associated with it.
Consumers that are canceled are allowed to finish processing any
messages before halting.
Returns:
defer.Deferred: A deferred that fires when the consumer has finished
processing any message it was in the middle of and has been successfully
canceled.
"""
# Remove it from protocol and factory so it doesn't restart later.
try:
del self._protocol._consumers[self.queue]
except (KeyError, AttributeError):
pass
try:
del self._protocol.factory._consumers[self.queue]
except (KeyError, AttributeError):
pass
# Signal to the _read loop it's time to stop and wait for it to finish
# with whatever message it might be working on, then wait for the deferred
# to fire which indicates it is done.
self._running = False
yield self._read_loop
try:
yield self._channel.basic_cancel(consumer_tag=self._tag)
except pika.exceptions.AMQPChannelError:
# Consumers are tied to channels, so if this channel is dead the
# consumer should already be canceled (and we can't get to it anyway)
pass
try:
yield self._channel.close()
except pika.exceptions.AMQPChannelError:
pass
if not self.result.called:
self.result.callback(self) | python | def cancel(self):
"""
Cancel the consumer and clean up resources associated with it.
Consumers that are canceled are allowed to finish processing any
messages before halting.
Returns:
defer.Deferred: A deferred that fires when the consumer has finished
processing any message it was in the middle of and has been successfully
canceled.
"""
# Remove it from protocol and factory so it doesn't restart later.
try:
del self._protocol._consumers[self.queue]
except (KeyError, AttributeError):
pass
try:
del self._protocol.factory._consumers[self.queue]
except (KeyError, AttributeError):
pass
# Signal to the _read loop it's time to stop and wait for it to finish
# with whatever message it might be working on, then wait for the deferred
# to fire which indicates it is done.
self._running = False
yield self._read_loop
try:
yield self._channel.basic_cancel(consumer_tag=self._tag)
except pika.exceptions.AMQPChannelError:
# Consumers are tied to channels, so if this channel is dead the
# consumer should already be canceled (and we can't get to it anyway)
pass
try:
yield self._channel.close()
except pika.exceptions.AMQPChannelError:
pass
if not self.result.called:
self.result.callback(self) | Cancel the consumer and clean up resources associated with it.
Consumers that are canceled are allowed to finish processing any
messages before halting.
Returns:
defer.Deferred: A deferred that fires when the consumer has finished
processing any message it was in the middle of and has been successfully
canceled. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/consumer.py#L70-L106 |
fedora-infra/fedora-messaging | fedora_messaging/config.py | validate_bindings | def validate_bindings(bindings):
"""
Validate the bindings configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format.
"""
if not isinstance(bindings, (list, tuple)):
raise exceptions.ConfigurationException(
"bindings must be a list or tuple of dictionaries, but was a {}".format(
type(bindings)
)
)
for binding in bindings:
missing_keys = []
for key in ("queue", "exchange", "routing_keys"):
if key not in binding:
missing_keys.append(key)
if missing_keys:
raise exceptions.ConfigurationException(
"a binding is missing the following keys from its settings "
"value: {}".format(missing_keys)
)
if not isinstance(binding["routing_keys"], (list, tuple)):
raise exceptions.ConfigurationException(
"routing_keys must be a list or tuple, but was a {}".format(
type(binding["routing_keys"])
)
) | python | def validate_bindings(bindings):
"""
Validate the bindings configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format.
"""
if not isinstance(bindings, (list, tuple)):
raise exceptions.ConfigurationException(
"bindings must be a list or tuple of dictionaries, but was a {}".format(
type(bindings)
)
)
for binding in bindings:
missing_keys = []
for key in ("queue", "exchange", "routing_keys"):
if key not in binding:
missing_keys.append(key)
if missing_keys:
raise exceptions.ConfigurationException(
"a binding is missing the following keys from its settings "
"value: {}".format(missing_keys)
)
if not isinstance(binding["routing_keys"], (list, tuple)):
raise exceptions.ConfigurationException(
"routing_keys must be a list or tuple, but was a {}".format(
type(binding["routing_keys"])
)
) | Validate the bindings configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/config.py#L357-L388 |
fedora-infra/fedora-messaging | fedora_messaging/config.py | validate_queues | def validate_queues(queues):
"""
Validate the queues configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format.
"""
if not isinstance(queues, dict):
raise exceptions.ConfigurationException(
"'queues' must be a dictionary mapping queue names to settings."
)
for queue, settings in queues.items():
if not isinstance(settings, dict):
raise exceptions.ConfigurationException(
"the {} queue in the 'queues' setting has a value of type {}, but it "
"should be a dictionary of settings.".format(queue, type(settings))
)
missing_keys = []
for key in ("durable", "auto_delete", "exclusive", "arguments"):
if key not in settings:
missing_keys.append(key)
if missing_keys:
raise exceptions.ConfigurationException(
"the {} queue is missing the following keys from its settings "
"value: {}".format(queue, missing_keys)
) | python | def validate_queues(queues):
"""
Validate the queues configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format.
"""
if not isinstance(queues, dict):
raise exceptions.ConfigurationException(
"'queues' must be a dictionary mapping queue names to settings."
)
for queue, settings in queues.items():
if not isinstance(settings, dict):
raise exceptions.ConfigurationException(
"the {} queue in the 'queues' setting has a value of type {}, but it "
"should be a dictionary of settings.".format(queue, type(settings))
)
missing_keys = []
for key in ("durable", "auto_delete", "exclusive", "arguments"):
if key not in settings:
missing_keys.append(key)
if missing_keys:
raise exceptions.ConfigurationException(
"the {} queue is missing the following keys from its settings "
"value: {}".format(queue, missing_keys)
) | Validate the queues configuration.
Raises:
exceptions.ConfigurationException: If the configuration provided is of an
invalid format. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/config.py#L391-L418 |
fedora-infra/fedora-messaging | fedora_messaging/config.py | validate_client_properties | def validate_client_properties(props):
"""
Validate the client properties setting.
This will add the "version", "information", and "product" keys if they are
missing. All other keys are application-specific.
Raises:
exceptions.ConfigurationException: If any of the basic keys are overridden.
"""
for key in ("version", "information", "product"):
# Nested dictionaries are not merged so key can be missing
if key not in props:
props[key] = DEFAULTS["client_properties"][key]
# Don't let users override these as they identify this library in AMQP
if props[key] != DEFAULTS["client_properties"][key]:
raise exceptions.ConfigurationException(
'"{}" is a reserved keyword in client_properties'.format(key)
) | python | def validate_client_properties(props):
"""
Validate the client properties setting.
This will add the "version", "information", and "product" keys if they are
missing. All other keys are application-specific.
Raises:
exceptions.ConfigurationException: If any of the basic keys are overridden.
"""
for key in ("version", "information", "product"):
# Nested dictionaries are not merged so key can be missing
if key not in props:
props[key] = DEFAULTS["client_properties"][key]
# Don't let users override these as they identify this library in AMQP
if props[key] != DEFAULTS["client_properties"][key]:
raise exceptions.ConfigurationException(
'"{}" is a reserved keyword in client_properties'.format(key)
) | Validate the client properties setting.
This will add the "version", "information", and "product" keys if they are
missing. All other keys are application-specific.
Raises:
exceptions.ConfigurationException: If any of the basic keys are overridden. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/config.py#L421-L439 |
fedora-infra/fedora-messaging | fedora_messaging/config.py | LazyConfig._validate | def _validate(self):
"""
Perform checks on the configuration to assert its validity
Raises:
ConfigurationException: If the configuration is invalid.
"""
for key in self:
if key not in DEFAULTS:
raise exceptions.ConfigurationException(
'Unknown configuration key "{}"! Valid configuration keys are'
" {}".format(key, list(DEFAULTS.keys()))
)
validate_queues(self["queues"])
validate_bindings(self["bindings"])
validate_client_properties(self["client_properties"]) | python | def _validate(self):
"""
Perform checks on the configuration to assert its validity
Raises:
ConfigurationException: If the configuration is invalid.
"""
for key in self:
if key not in DEFAULTS:
raise exceptions.ConfigurationException(
'Unknown configuration key "{}"! Valid configuration keys are'
" {}".format(key, list(DEFAULTS.keys()))
)
validate_queues(self["queues"])
validate_bindings(self["bindings"])
validate_client_properties(self["client_properties"]) | Perform checks on the configuration to assert its validity
Raises:
ConfigurationException: If the configuration is invalid. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/config.py#L475-L491 |
fedora-infra/fedora-messaging | fedora_messaging/config.py | LazyConfig.load_config | def load_config(self, config_path=None):
"""
Load application configuration from a file and merge it with the default
configuration.
If the ``FEDORA_MESSAGING_CONF`` environment variable is set to a
filesystem path, the configuration will be loaded from that location.
Otherwise, the path defaults to ``/etc/fedora-messaging/config.toml``.
"""
self.loaded = True
config = copy.deepcopy(DEFAULTS)
if config_path is None:
if "FEDORA_MESSAGING_CONF" in os.environ:
config_path = os.environ["FEDORA_MESSAGING_CONF"]
else:
config_path = "/etc/fedora-messaging/config.toml"
if os.path.exists(config_path):
_log.info("Loading configuration from {}".format(config_path))
with open(config_path) as fd:
try:
file_config = toml.load(fd)
for key in file_config:
config[key.lower()] = file_config[key]
except toml.TomlDecodeError as e:
msg = "Failed to parse {}: error at line {}, column {}: {}".format(
config_path, e.lineno, e.colno, e.msg
)
raise exceptions.ConfigurationException(msg)
else:
_log.info("The configuration file, {}, does not exist.".format(config_path))
self.update(config)
self._validate()
return self | python | def load_config(self, config_path=None):
"""
Load application configuration from a file and merge it with the default
configuration.
If the ``FEDORA_MESSAGING_CONF`` environment variable is set to a
filesystem path, the configuration will be loaded from that location.
Otherwise, the path defaults to ``/etc/fedora-messaging/config.toml``.
"""
self.loaded = True
config = copy.deepcopy(DEFAULTS)
if config_path is None:
if "FEDORA_MESSAGING_CONF" in os.environ:
config_path = os.environ["FEDORA_MESSAGING_CONF"]
else:
config_path = "/etc/fedora-messaging/config.toml"
if os.path.exists(config_path):
_log.info("Loading configuration from {}".format(config_path))
with open(config_path) as fd:
try:
file_config = toml.load(fd)
for key in file_config:
config[key.lower()] = file_config[key]
except toml.TomlDecodeError as e:
msg = "Failed to parse {}: error at line {}, column {}: {}".format(
config_path, e.lineno, e.colno, e.msg
)
raise exceptions.ConfigurationException(msg)
else:
_log.info("The configuration file, {}, does not exist.".format(config_path))
self.update(config)
self._validate()
return self | Load application configuration from a file and merge it with the default
configuration.
If the ``FEDORA_MESSAGING_CONF`` environment variable is set to a
filesystem path, the configuration will be loaded from that location.
Otherwise, the path defaults to ``/etc/fedora-messaging/config.toml``. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/config.py#L493-L528 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/service.py | _ssl_context_factory | def _ssl_context_factory(parameters):
"""
Produce a Twisted SSL context object from a pika connection parameter object.
This is necessary as Twisted manages the connection, not Pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters built
from the fedora_messaging configuration.
"""
client_cert = None
ca_cert = None
key = config.conf["tls"]["keyfile"]
cert = config.conf["tls"]["certfile"]
ca_file = config.conf["tls"]["ca_cert"]
if ca_file:
with open(ca_file, "rb") as fd:
# Open it in binary mode since otherwise Twisted will immediately
# re-encode it as ASCII, which won't work if the cert bundle has
# comments that can't be encoded with ASCII.
ca_cert = ssl.Certificate.loadPEM(fd.read())
if key and cert:
# Note that _configure_tls_parameters sets the auth mode to EXTERNAL
# if both key and cert are defined, so we don't need to do that here.
with open(key) as fd:
client_keypair = fd.read()
with open(cert) as fd:
client_keypair += fd.read()
client_cert = ssl.PrivateCertificate.loadPEM(client_keypair)
hostname = parameters.host
if not isinstance(hostname, six.text_type):
# Twisted requires the hostname as decoded text, which it isn't in Python 2
# Decode with the system encoding since this came from the config file. Die,
# Python 2, die.
hostname = hostname.decode(locale.getdefaultlocale()[1])
try:
context_factory = ssl.optionsForClientTLS(
hostname,
trustRoot=ca_cert or ssl.platformTrust(),
clientCertificate=client_cert,
extraCertificateOptions={"raiseMinimumTo": ssl.TLSVersion.TLSv1_2},
)
except AttributeError:
# Twisted 12.2 path for EL7 :(
context_factory = ssl.CertificateOptions(
certificate=client_cert.original,
privateKey=client_cert.privateKey.original,
caCerts=[ca_cert.original] or ssl.platformTrust(),
verify=True,
requireCertificate=True,
verifyOnce=False,
enableSessions=False,
)
return context_factory | python | def _ssl_context_factory(parameters):
"""
Produce a Twisted SSL context object from a pika connection parameter object.
This is necessary as Twisted manages the connection, not Pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters built
from the fedora_messaging configuration.
"""
client_cert = None
ca_cert = None
key = config.conf["tls"]["keyfile"]
cert = config.conf["tls"]["certfile"]
ca_file = config.conf["tls"]["ca_cert"]
if ca_file:
with open(ca_file, "rb") as fd:
# Open it in binary mode since otherwise Twisted will immediately
# re-encode it as ASCII, which won't work if the cert bundle has
# comments that can't be encoded with ASCII.
ca_cert = ssl.Certificate.loadPEM(fd.read())
if key and cert:
# Note that _configure_tls_parameters sets the auth mode to EXTERNAL
# if both key and cert are defined, so we don't need to do that here.
with open(key) as fd:
client_keypair = fd.read()
with open(cert) as fd:
client_keypair += fd.read()
client_cert = ssl.PrivateCertificate.loadPEM(client_keypair)
hostname = parameters.host
if not isinstance(hostname, six.text_type):
# Twisted requires the hostname as decoded text, which it isn't in Python 2
# Decode with the system encoding since this came from the config file. Die,
# Python 2, die.
hostname = hostname.decode(locale.getdefaultlocale()[1])
try:
context_factory = ssl.optionsForClientTLS(
hostname,
trustRoot=ca_cert or ssl.platformTrust(),
clientCertificate=client_cert,
extraCertificateOptions={"raiseMinimumTo": ssl.TLSVersion.TLSv1_2},
)
except AttributeError:
# Twisted 12.2 path for EL7 :(
context_factory = ssl.CertificateOptions(
certificate=client_cert.original,
privateKey=client_cert.privateKey.original,
caCerts=[ca_cert.original] or ssl.platformTrust(),
verify=True,
requireCertificate=True,
verifyOnce=False,
enableSessions=False,
)
return context_factory | Produce a Twisted SSL context object from a pika connection parameter object.
This is necessary as Twisted manages the connection, not Pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters built
from the fedora_messaging configuration. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/service.py#L194-L248 |
fedora-infra/fedora-messaging | fedora_messaging/twisted/service.py | FedoraMessagingServiceV2.stopService | def stopService(self):
"""
Gracefully stop the service.
Returns:
defer.Deferred: a Deferred which is triggered when the service has
finished shutting down.
"""
self._service.factory.stopTrying()
yield self._service.factory.stopFactory()
yield service.MultiService.stopService(self) | python | def stopService(self):
"""
Gracefully stop the service.
Returns:
defer.Deferred: a Deferred which is triggered when the service has
finished shutting down.
"""
self._service.factory.stopTrying()
yield self._service.factory.stopFactory()
yield service.MultiService.stopService(self) | Gracefully stop the service.
Returns:
defer.Deferred: a Deferred which is triggered when the service has
finished shutting down. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/twisted/service.py#L181-L191 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | _configure_tls_parameters | def _configure_tls_parameters(parameters):
"""
Configure the pika connection parameters for TLS based on the configuration.
This modifies the object provided to it. This accounts for whether or not
the new API based on the standard library's SSLContext is available for
pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters to apply
TLS connection settings to.
"""
cert = config.conf["tls"]["certfile"]
key = config.conf["tls"]["keyfile"]
if cert and key:
_log.info(
"Authenticating with server using x509 (certfile: %s, keyfile: %s)",
cert,
key,
)
parameters.credentials = pika.credentials.ExternalCredentials()
else:
cert, key = None, None
if SSLOptions is None:
parameters.ssl = True
parameters.ssl_options = {
"keyfile": key,
"certfile": cert,
"ca_certs": config.conf["tls"]["ca_cert"],
"cert_reqs": ssl.CERT_REQUIRED,
"ssl_version": ssl.PROTOCOL_TLSv1_2,
}
else:
ssl_context = ssl.create_default_context()
if config.conf["tls"]["ca_cert"]:
try:
ssl_context.load_verify_locations(cafile=config.conf["tls"]["ca_cert"])
except ssl.SSLError as e:
raise ConfigurationException(
'The "ca_cert" setting in the "tls" section is invalid ({})'.format(
e
)
)
ssl_context.options |= ssl.OP_NO_SSLv2
ssl_context.options |= ssl.OP_NO_SSLv3
ssl_context.options |= ssl.OP_NO_TLSv1
ssl_context.options |= ssl.OP_NO_TLSv1_1
ssl_context.verify_mode = ssl.CERT_REQUIRED
ssl_context.check_hostname = True
if cert and key:
try:
ssl_context.load_cert_chain(cert, key)
except ssl.SSLError as e:
raise ConfigurationException(
'The "keyfile" setting in the "tls" section is invalid ({})'.format(
e
)
)
parameters.ssl_options = SSLOptions(
ssl_context, server_hostname=parameters.host
) | python | def _configure_tls_parameters(parameters):
"""
Configure the pika connection parameters for TLS based on the configuration.
This modifies the object provided to it. This accounts for whether or not
the new API based on the standard library's SSLContext is available for
pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters to apply
TLS connection settings to.
"""
cert = config.conf["tls"]["certfile"]
key = config.conf["tls"]["keyfile"]
if cert and key:
_log.info(
"Authenticating with server using x509 (certfile: %s, keyfile: %s)",
cert,
key,
)
parameters.credentials = pika.credentials.ExternalCredentials()
else:
cert, key = None, None
if SSLOptions is None:
parameters.ssl = True
parameters.ssl_options = {
"keyfile": key,
"certfile": cert,
"ca_certs": config.conf["tls"]["ca_cert"],
"cert_reqs": ssl.CERT_REQUIRED,
"ssl_version": ssl.PROTOCOL_TLSv1_2,
}
else:
ssl_context = ssl.create_default_context()
if config.conf["tls"]["ca_cert"]:
try:
ssl_context.load_verify_locations(cafile=config.conf["tls"]["ca_cert"])
except ssl.SSLError as e:
raise ConfigurationException(
'The "ca_cert" setting in the "tls" section is invalid ({})'.format(
e
)
)
ssl_context.options |= ssl.OP_NO_SSLv2
ssl_context.options |= ssl.OP_NO_SSLv3
ssl_context.options |= ssl.OP_NO_TLSv1
ssl_context.options |= ssl.OP_NO_TLSv1_1
ssl_context.verify_mode = ssl.CERT_REQUIRED
ssl_context.check_hostname = True
if cert and key:
try:
ssl_context.load_cert_chain(cert, key)
except ssl.SSLError as e:
raise ConfigurationException(
'The "keyfile" setting in the "tls" section is invalid ({})'.format(
e
)
)
parameters.ssl_options = SSLOptions(
ssl_context, server_hostname=parameters.host
) | Configure the pika connection parameters for TLS based on the configuration.
This modifies the object provided to it. This accounts for whether or not
the new API based on the standard library's SSLContext is available for
pika.
Args:
parameters (pika.ConnectionParameters): The connection parameters to apply
TLS connection settings to. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L51-L112 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | PublisherSession.publish | def publish(self, message, exchange=None):
"""
Publish a :class:`fedora_messaging.message.Message` to an `exchange`_ on
the message broker.
>>> from fedora_messaging import _session, message
>>> msg = message.Message(topic='test', body={'test':'message'})
>>> sess = session.BlockingSession()
>>> sess.publish(msg)
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges
"""
message.validate()
try:
self._connect_and_publish(exchange, message)
except (pika_errs.NackError, pika_errs.UnroutableError) as e:
_log.warning("Message was rejected by the broker (%s)", str(e))
raise PublishReturned(reason=e)
except (pika_errs.ConnectionClosed, pika_errs.AMQPChannelError):
# Because this is a blocking connection (and thus can't heartbeat)
# we might need to restart the connection.
_log.info("Resetting connection to %s", self._parameters.host)
self._connection = self._channel = None
try:
self._connect_and_publish(exchange, message)
except (pika_errs.NackError, pika_errs.UnroutableError) as e:
_log.warning("Message was rejected by the broker (%s)", str(e))
raise PublishReturned(reason=e)
except pika_errs.AMQPError as e:
_log.error(str(e))
if self._connection and self._connection.is_open:
self._connection.close()
raise ConnectionException(reason=e)
except pika_errs.AMQPError as e:
if self._connection and self._connection.is_open:
self._connection.close()
raise ConnectionException(reason=e) | python | def publish(self, message, exchange=None):
"""
Publish a :class:`fedora_messaging.message.Message` to an `exchange`_ on
the message broker.
>>> from fedora_messaging import _session, message
>>> msg = message.Message(topic='test', body={'test':'message'})
>>> sess = session.BlockingSession()
>>> sess.publish(msg)
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges
"""
message.validate()
try:
self._connect_and_publish(exchange, message)
except (pika_errs.NackError, pika_errs.UnroutableError) as e:
_log.warning("Message was rejected by the broker (%s)", str(e))
raise PublishReturned(reason=e)
except (pika_errs.ConnectionClosed, pika_errs.AMQPChannelError):
# Because this is a blocking connection (and thus can't heartbeat)
# we might need to restart the connection.
_log.info("Resetting connection to %s", self._parameters.host)
self._connection = self._channel = None
try:
self._connect_and_publish(exchange, message)
except (pika_errs.NackError, pika_errs.UnroutableError) as e:
_log.warning("Message was rejected by the broker (%s)", str(e))
raise PublishReturned(reason=e)
except pika_errs.AMQPError as e:
_log.error(str(e))
if self._connection and self._connection.is_open:
self._connection.close()
raise ConnectionException(reason=e)
except pika_errs.AMQPError as e:
if self._connection and self._connection.is_open:
self._connection.close()
raise ConnectionException(reason=e) | Publish a :class:`fedora_messaging.message.Message` to an `exchange`_ on
the message broker.
>>> from fedora_messaging import _session, message
>>> msg = message.Message(topic='test', body={'test':'message'})
>>> sess = session.BlockingSession()
>>> sess.publish(msg)
Args:
message (message.Message): The message to publish.
exchange (str): The name of the AMQP exchange to publish to; defaults
to :ref:`conf-publish-exchange`
Raises:
PublishReturned: If the published message is rejected by the broker.
ConnectionException: If a connection error occurs while publishing.
.. _exchange: https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L129-L174 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._shutdown | def _shutdown(self):
"""Gracefully shut down the consumer and exit."""
if self._channel:
_log.info("Halting %r consumer sessions", self._channel.consumer_tags)
self._running = False
if self._connection and self._connection.is_open:
self._connection.close()
# Reset the signal handler
for signum in (signal.SIGTERM, signal.SIGINT):
signal.signal(signum, signal.SIG_DFL) | python | def _shutdown(self):
"""Gracefully shut down the consumer and exit."""
if self._channel:
_log.info("Halting %r consumer sessions", self._channel.consumer_tags)
self._running = False
if self._connection and self._connection.is_open:
self._connection.close()
# Reset the signal handler
for signum in (signal.SIGTERM, signal.SIGINT):
signal.signal(signum, signal.SIG_DFL) | Gracefully shut down the consumer and exit. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L224-L233 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_cancelok | def _on_cancelok(self, cancel_frame):
"""
Called when the server acknowledges a cancel request.
Args:
cancel_frame (pika.spec.Basic.CancelOk): The cancelok frame from
the server.
"""
_log.info("Consumer canceled; returning all unprocessed messages to the queue")
self._channel.basic_nack(delivery_tag=0, multiple=True, requeue=True) | python | def _on_cancelok(self, cancel_frame):
"""
Called when the server acknowledges a cancel request.
Args:
cancel_frame (pika.spec.Basic.CancelOk): The cancelok frame from
the server.
"""
_log.info("Consumer canceled; returning all unprocessed messages to the queue")
self._channel.basic_nack(delivery_tag=0, multiple=True, requeue=True) | Called when the server acknowledges a cancel request.
Args:
cancel_frame (pika.spec.Basic.CancelOk): The cancelok frame from
the server. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L235-L244 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_channel_open | def _on_channel_open(self, channel):
"""
Callback used when a channel is opened.
This registers all the channel callbacks.
Args:
channel (pika.channel.Channel): The channel that successfully opened.
"""
channel.add_on_close_callback(self._on_channel_close)
channel.add_on_cancel_callback(self._on_cancel)
channel.basic_qos(callback=self._on_qosok, **config.conf["qos"]) | python | def _on_channel_open(self, channel):
"""
Callback used when a channel is opened.
This registers all the channel callbacks.
Args:
channel (pika.channel.Channel): The channel that successfully opened.
"""
channel.add_on_close_callback(self._on_channel_close)
channel.add_on_cancel_callback(self._on_cancel)
channel.basic_qos(callback=self._on_qosok, **config.conf["qos"]) | Callback used when a channel is opened.
This registers all the channel callbacks.
Args:
channel (pika.channel.Channel): The channel that successfully opened. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L246-L258 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_qosok | def _on_qosok(self, qosok_frame):
"""
Callback invoked when the server acknowledges the QoS settings.
Asserts or creates the exchanges and queues exist.
Args:
qosok_frame (pika.spec.Basic.Qos): The frame send from the server.
"""
for name, args in self._exchanges.items():
self._channel.exchange_declare(
exchange=name,
exchange_type=args["type"],
durable=args["durable"],
auto_delete=args["auto_delete"],
arguments=args["arguments"],
passive=config.conf["passive_declares"],
callback=self._on_exchange_declareok,
)
for name, args in self._queues.items():
self._channel.queue_declare(
queue=name,
durable=args["durable"],
auto_delete=args["auto_delete"],
exclusive=args["exclusive"],
arguments=args["arguments"],
passive=config.conf["passive_declares"],
callback=self._on_queue_declareok,
) | python | def _on_qosok(self, qosok_frame):
"""
Callback invoked when the server acknowledges the QoS settings.
Asserts or creates the exchanges and queues exist.
Args:
qosok_frame (pika.spec.Basic.Qos): The frame send from the server.
"""
for name, args in self._exchanges.items():
self._channel.exchange_declare(
exchange=name,
exchange_type=args["type"],
durable=args["durable"],
auto_delete=args["auto_delete"],
arguments=args["arguments"],
passive=config.conf["passive_declares"],
callback=self._on_exchange_declareok,
)
for name, args in self._queues.items():
self._channel.queue_declare(
queue=name,
durable=args["durable"],
auto_delete=args["auto_delete"],
exclusive=args["exclusive"],
arguments=args["arguments"],
passive=config.conf["passive_declares"],
callback=self._on_queue_declareok,
) | Callback invoked when the server acknowledges the QoS settings.
Asserts or creates the exchanges and queues exist.
Args:
qosok_frame (pika.spec.Basic.Qos): The frame send from the server. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L260-L288 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_channel_close | def _on_channel_close(self, channel, reply_code_or_reason, reply_text=None):
"""
Callback invoked when the channel is closed.
Args:
channel (pika.channel.Channel): The channel that got closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason for the channel's
closure (only in older versions of pika).
"""
if isinstance(reply_code_or_reason, pika_errs.ChannelClosed):
reply_code = reply_code_or_reason.reply_code
reply_text = reply_code_or_reason.reply_text
elif isinstance(reply_code_or_reason, int):
reply_code = reply_code_or_reason
else:
reply_code = 0
reply_text = str(reply_code_or_reason)
_log.info("Channel %r closed (%d): %s", channel, reply_code, reply_text)
self._channel = None | python | def _on_channel_close(self, channel, reply_code_or_reason, reply_text=None):
"""
Callback invoked when the channel is closed.
Args:
channel (pika.channel.Channel): The channel that got closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason for the channel's
closure (only in older versions of pika).
"""
if isinstance(reply_code_or_reason, pika_errs.ChannelClosed):
reply_code = reply_code_or_reason.reply_code
reply_text = reply_code_or_reason.reply_text
elif isinstance(reply_code_or_reason, int):
reply_code = reply_code_or_reason
else:
reply_code = 0
reply_text = str(reply_code_or_reason)
_log.info("Channel %r closed (%d): %s", channel, reply_code, reply_text)
self._channel = None | Callback invoked when the channel is closed.
Args:
channel (pika.channel.Channel): The channel that got closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason for the channel's
closure (only in older versions of pika). | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L290-L311 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_connection_open | def _on_connection_open(self, connection):
"""
Callback invoked when the connection is successfully established.
Args:
connection (pika.connection.SelectConnection): The newly-estabilished
connection.
"""
_log.info("Successfully opened connection to %s", connection.params.host)
self._channel = connection.channel(on_open_callback=self._on_channel_open) | python | def _on_connection_open(self, connection):
"""
Callback invoked when the connection is successfully established.
Args:
connection (pika.connection.SelectConnection): The newly-estabilished
connection.
"""
_log.info("Successfully opened connection to %s", connection.params.host)
self._channel = connection.channel(on_open_callback=self._on_channel_open) | Callback invoked when the connection is successfully established.
Args:
connection (pika.connection.SelectConnection): The newly-estabilished
connection. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L313-L322 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_connection_close | def _on_connection_close(self, connection, reply_code_or_reason, reply_text=None):
"""
Callback invoked when a previously-opened connection is closed.
Args:
connection (pika.connection.SelectConnection): The connection that
was just closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason the connection was
closed (only in older versions of pika)
"""
self._channel = None
if isinstance(reply_code_or_reason, pika_errs.ConnectionClosed):
reply_code = reply_code_or_reason.reply_code
reply_text = reply_code_or_reason.reply_text
elif isinstance(reply_code_or_reason, int):
reply_code = reply_code_or_reason
else:
reply_code = 0
reply_text = str(reply_code_or_reason)
if reply_code == 200:
# Normal shutdown, exit the consumer.
_log.info("Server connection closed (%s), shutting down", reply_text)
connection.ioloop.stop()
else:
_log.warning(
"Connection to %s closed unexpectedly (%d): %s",
connection.params.host,
reply_code,
reply_text,
)
self.call_later(1, self.reconnect) | python | def _on_connection_close(self, connection, reply_code_or_reason, reply_text=None):
"""
Callback invoked when a previously-opened connection is closed.
Args:
connection (pika.connection.SelectConnection): The connection that
was just closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason the connection was
closed (only in older versions of pika)
"""
self._channel = None
if isinstance(reply_code_or_reason, pika_errs.ConnectionClosed):
reply_code = reply_code_or_reason.reply_code
reply_text = reply_code_or_reason.reply_text
elif isinstance(reply_code_or_reason, int):
reply_code = reply_code_or_reason
else:
reply_code = 0
reply_text = str(reply_code_or_reason)
if reply_code == 200:
# Normal shutdown, exit the consumer.
_log.info("Server connection closed (%s), shutting down", reply_text)
connection.ioloop.stop()
else:
_log.warning(
"Connection to %s closed unexpectedly (%d): %s",
connection.params.host,
reply_code,
reply_text,
)
self.call_later(1, self.reconnect) | Callback invoked when a previously-opened connection is closed.
Args:
connection (pika.connection.SelectConnection): The connection that
was just closed.
reply_code_or_reason (int|Exception): The reason why the channel
was closed. In older versions of pika, this is the AMQP code.
reply_text (str): The human-readable reason the connection was
closed (only in older versions of pika) | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L324-L358 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_connection_error | def _on_connection_error(self, connection, error_message):
"""
Callback invoked when the connection failed to be established.
Args:
connection (pika.connection.SelectConnection): The connection that
failed to open.
error_message (str): The reason the connection couldn't be opened.
"""
self._channel = None
if isinstance(error_message, pika_errs.AMQPConnectionError):
error_message = repr(error_message.args[0])
_log.error(error_message)
self.call_later(1, self.reconnect) | python | def _on_connection_error(self, connection, error_message):
"""
Callback invoked when the connection failed to be established.
Args:
connection (pika.connection.SelectConnection): The connection that
failed to open.
error_message (str): The reason the connection couldn't be opened.
"""
self._channel = None
if isinstance(error_message, pika_errs.AMQPConnectionError):
error_message = repr(error_message.args[0])
_log.error(error_message)
self.call_later(1, self.reconnect) | Callback invoked when the connection failed to be established.
Args:
connection (pika.connection.SelectConnection): The connection that
failed to open.
error_message (str): The reason the connection couldn't be opened. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L360-L373 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_queue_declareok | def _on_queue_declareok(self, frame):
"""
Callback invoked when a queue is successfully declared.
Args:
frame (pika.frame.Method): The message sent from the server.
"""
_log.info("Successfully declared the %s queue", frame.method.queue)
for binding in self._bindings:
if binding["queue"] == frame.method.queue:
for key in binding["routing_keys"]:
_log.info(
"Asserting %s is bound to %s with the %s key",
binding["queue"],
binding["exchange"],
key,
)
self._channel.queue_bind(
callback=None,
queue=binding["queue"],
exchange=binding["exchange"],
routing_key=key,
)
bc_args = dict(queue=frame.method.queue)
if _pika_version < pkg_resources.parse_version("1.0.0b1"):
bc_args["consumer_callback"] = self._on_message
else:
bc_args["on_message_callback"] = self._on_message
tag = self._channel.basic_consume(**bc_args)
self._consumers[tag] = binding["queue"] | python | def _on_queue_declareok(self, frame):
"""
Callback invoked when a queue is successfully declared.
Args:
frame (pika.frame.Method): The message sent from the server.
"""
_log.info("Successfully declared the %s queue", frame.method.queue)
for binding in self._bindings:
if binding["queue"] == frame.method.queue:
for key in binding["routing_keys"]:
_log.info(
"Asserting %s is bound to %s with the %s key",
binding["queue"],
binding["exchange"],
key,
)
self._channel.queue_bind(
callback=None,
queue=binding["queue"],
exchange=binding["exchange"],
routing_key=key,
)
bc_args = dict(queue=frame.method.queue)
if _pika_version < pkg_resources.parse_version("1.0.0b1"):
bc_args["consumer_callback"] = self._on_message
else:
bc_args["on_message_callback"] = self._on_message
tag = self._channel.basic_consume(**bc_args)
self._consumers[tag] = binding["queue"] | Callback invoked when a queue is successfully declared.
Args:
frame (pika.frame.Method): The message sent from the server. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L388-L417 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession.call_later | def call_later(self, delay, callback):
"""Schedule a one-shot timeout given delay seconds.
This method is only useful for compatibility with older versions of pika.
Args:
delay (float): Non-negative number of seconds from now until
expiration
callback (method): The callback method, having the signature
`callback()`
"""
if hasattr(self._connection.ioloop, "call_later"):
self._connection.ioloop.call_later(delay, callback)
else:
self._connection.ioloop.add_timeout(delay, callback) | python | def call_later(self, delay, callback):
"""Schedule a one-shot timeout given delay seconds.
This method is only useful for compatibility with older versions of pika.
Args:
delay (float): Non-negative number of seconds from now until
expiration
callback (method): The callback method, having the signature
`callback()`
"""
if hasattr(self._connection.ioloop, "call_later"):
self._connection.ioloop.call_later(delay, callback)
else:
self._connection.ioloop.add_timeout(delay, callback) | Schedule a one-shot timeout given delay seconds.
This method is only useful for compatibility with older versions of pika.
Args:
delay (float): Non-negative number of seconds from now until
expiration
callback (method): The callback method, having the signature
`callback()` | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L429-L443 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession.reconnect | def reconnect(self):
"""Will be invoked by the IOLoop timer if the connection is
closed. See the _on_connection_close method.
"""
# This is the old connection instance, stop its ioloop.
self._connection.ioloop.stop()
if self._running:
# Create a new connection
self.connect()
# There is now a new connection, needs the new ioloop to run.
self._connection.ioloop.start() | python | def reconnect(self):
"""Will be invoked by the IOLoop timer if the connection is
closed. See the _on_connection_close method.
"""
# This is the old connection instance, stop its ioloop.
self._connection.ioloop.stop()
if self._running:
# Create a new connection
self.connect()
# There is now a new connection, needs the new ioloop to run.
self._connection.ioloop.start() | Will be invoked by the IOLoop timer if the connection is
closed. See the _on_connection_close method. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L454-L464 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession.consume | def consume(self, callback, bindings=None, queues=None, exchanges=None):
"""
Consume messages from a message queue.
Simply define a callable to be used as the callback when messages are
delivered and specify the queue bindings. This call blocks. The callback
signature should accept a single positional argument which is an
instance of a :class:`Message` (or a sub-class of it).
Args:
callback (callable): The callable to pass the message to when one
arrives.
bindings (list of dict): A list of dictionaries describing bindings
for queues. Refer to the :ref:`conf-bindings` configuration
documentation for the format.
queues (dict): A dictionary of queues to ensure exist. Refer to the
:ref:`conf-queues` configuration documentation for the format.
exchanges (dict): A dictionary of exchanges to ensure exist. Refer
to the :ref:`conf-exchanges` configuration documentation for the
format.
Raises:
HaltConsumer: Raised when the consumer halts.
ValueError: If the callback isn't a callable object or a class with
__call__ defined.
"""
self._bindings = bindings or config.conf["bindings"]
self._queues = queues or config.conf["queues"]
self._exchanges = exchanges or config.conf["exchanges"]
# If the callback is a class, create an instance of it first
if inspect.isclass(callback):
cb_obj = callback()
if not callable(cb_obj):
raise ValueError(
"Callback must be a class that implements __call__"
" or a function."
)
self._consumer_callback = cb_obj
elif callable(callback):
self._consumer_callback = callback
else:
raise ValueError(
"Callback must be a class that implements __call__" " or a function."
)
self._running = True
self.connect()
self._connection.ioloop.start() | python | def consume(self, callback, bindings=None, queues=None, exchanges=None):
"""
Consume messages from a message queue.
Simply define a callable to be used as the callback when messages are
delivered and specify the queue bindings. This call blocks. The callback
signature should accept a single positional argument which is an
instance of a :class:`Message` (or a sub-class of it).
Args:
callback (callable): The callable to pass the message to when one
arrives.
bindings (list of dict): A list of dictionaries describing bindings
for queues. Refer to the :ref:`conf-bindings` configuration
documentation for the format.
queues (dict): A dictionary of queues to ensure exist. Refer to the
:ref:`conf-queues` configuration documentation for the format.
exchanges (dict): A dictionary of exchanges to ensure exist. Refer
to the :ref:`conf-exchanges` configuration documentation for the
format.
Raises:
HaltConsumer: Raised when the consumer halts.
ValueError: If the callback isn't a callable object or a class with
__call__ defined.
"""
self._bindings = bindings or config.conf["bindings"]
self._queues = queues or config.conf["queues"]
self._exchanges = exchanges or config.conf["exchanges"]
# If the callback is a class, create an instance of it first
if inspect.isclass(callback):
cb_obj = callback()
if not callable(cb_obj):
raise ValueError(
"Callback must be a class that implements __call__"
" or a function."
)
self._consumer_callback = cb_obj
elif callable(callback):
self._consumer_callback = callback
else:
raise ValueError(
"Callback must be a class that implements __call__" " or a function."
)
self._running = True
self.connect()
self._connection.ioloop.start() | Consume messages from a message queue.
Simply define a callable to be used as the callback when messages are
delivered and specify the queue bindings. This call blocks. The callback
signature should accept a single positional argument which is an
instance of a :class:`Message` (or a sub-class of it).
Args:
callback (callable): The callable to pass the message to when one
arrives.
bindings (list of dict): A list of dictionaries describing bindings
for queues. Refer to the :ref:`conf-bindings` configuration
documentation for the format.
queues (dict): A dictionary of queues to ensure exist. Refer to the
:ref:`conf-queues` configuration documentation for the format.
exchanges (dict): A dictionary of exchanges to ensure exist. Refer
to the :ref:`conf-exchanges` configuration documentation for the
format.
Raises:
HaltConsumer: Raised when the consumer halts.
ValueError: If the callback isn't a callable object or a class with
__call__ defined. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L466-L513 |
fedora-infra/fedora-messaging | fedora_messaging/_session.py | ConsumerSession._on_message | def _on_message(self, channel, delivery_frame, properties, body):
"""
Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the user
callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
channel (pika.channel.Channel): The channel from which the message
was received.
delivery_frame (pika.spec.Deliver): The delivery frame which includes
details about the message like content encoding and its delivery
tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
Raises:
HaltConsumer: Raised when the consumer halts.
"""
_log.debug("Message arrived with delivery tag %s", delivery_frame.delivery_tag)
try:
message = get_message(delivery_frame.routing_key, properties, body)
message.queue = self._consumers[delivery_frame.consumer_tag]
except ValidationError:
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=False)
return
try:
_log.info(
'Consuming message from topic "%s" (id %s)',
message.topic,
properties.message_id,
)
self._consumer_callback(message)
channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)
except Nack:
_log.info("Returning message id %s to the queue", properties.message_id)
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=True)
except Drop:
_log.info("Dropping message id %s", properties.message_id)
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=False)
except HaltConsumer as e:
_log.info(
"Consumer requested halt on message id %s with requeue=%s",
properties.message_id,
e.requeue,
)
channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=e.requeue
)
self._shutdown()
if e.exit_code != 0:
raise
except Exception as e:
_log.exception("Received unexpected exception from consumer callback")
channel.basic_nack(delivery_tag=0, multiple=True, requeue=True)
self._shutdown()
raise HaltConsumer(exit_code=1, reason=e, requeue=True) | python | def _on_message(self, channel, delivery_frame, properties, body):
"""
Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the user
callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
channel (pika.channel.Channel): The channel from which the message
was received.
delivery_frame (pika.spec.Deliver): The delivery frame which includes
details about the message like content encoding and its delivery
tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
Raises:
HaltConsumer: Raised when the consumer halts.
"""
_log.debug("Message arrived with delivery tag %s", delivery_frame.delivery_tag)
try:
message = get_message(delivery_frame.routing_key, properties, body)
message.queue = self._consumers[delivery_frame.consumer_tag]
except ValidationError:
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=False)
return
try:
_log.info(
'Consuming message from topic "%s" (id %s)',
message.topic,
properties.message_id,
)
self._consumer_callback(message)
channel.basic_ack(delivery_tag=delivery_frame.delivery_tag)
except Nack:
_log.info("Returning message id %s to the queue", properties.message_id)
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=True)
except Drop:
_log.info("Dropping message id %s", properties.message_id)
channel.basic_nack(delivery_tag=delivery_frame.delivery_tag, requeue=False)
except HaltConsumer as e:
_log.info(
"Consumer requested halt on message id %s with requeue=%s",
properties.message_id,
e.requeue,
)
channel.basic_nack(
delivery_tag=delivery_frame.delivery_tag, requeue=e.requeue
)
self._shutdown()
if e.exit_code != 0:
raise
except Exception as e:
_log.exception("Received unexpected exception from consumer callback")
channel.basic_nack(delivery_tag=0, multiple=True, requeue=True)
self._shutdown()
raise HaltConsumer(exit_code=1, reason=e, requeue=True) | Callback when a message is received from the server.
This method wraps a user-registered callback for message delivery. It
decodes the message body, determines the message schema to validate the
message with, and validates the message before passing it on to the user
callback.
This also handles acking, nacking, and rejecting messages based on
exceptions raised by the consumer callback. For detailed documentation
on the user-provided callback, see the user guide on consuming.
Args:
channel (pika.channel.Channel): The channel from which the message
was received.
delivery_frame (pika.spec.Deliver): The delivery frame which includes
details about the message like content encoding and its delivery
tag.
properties (pika.spec.BasicProperties): The message properties like
the message headers.
body (bytes): The message payload.
Raises:
HaltConsumer: Raised when the consumer halts. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/_session.py#L515-L580 |
fedora-infra/fedora-messaging | docs/sample_schema_package/mailman_schema/utils.py | get_avatar | def get_avatar(from_header, size=64, default="retro"):
"""Get the avatar URL from the email's From header.
Args:
from_header (str): The email's From header. May contain the sender's full name.
Returns:
str: The URL to that sender's avatar.
"""
params = OrderedDict([("s", size), ("d", default)])
query = parse.urlencode(params)
address = email.utils.parseaddr(from_header)[1]
value_hash = sha256(address.encode("utf-8")).hexdigest()
return "https://seccdn.libravatar.org/avatar/{}?{}".format(value_hash, query) | python | def get_avatar(from_header, size=64, default="retro"):
"""Get the avatar URL from the email's From header.
Args:
from_header (str): The email's From header. May contain the sender's full name.
Returns:
str: The URL to that sender's avatar.
"""
params = OrderedDict([("s", size), ("d", default)])
query = parse.urlencode(params)
address = email.utils.parseaddr(from_header)[1]
value_hash = sha256(address.encode("utf-8")).hexdigest()
return "https://seccdn.libravatar.org/avatar/{}?{}".format(value_hash, query) | Get the avatar URL from the email's From header.
Args:
from_header (str): The email's From header. May contain the sender's full name.
Returns:
str: The URL to that sender's avatar. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/docs/sample_schema_package/mailman_schema/utils.py#L25-L38 |
fedora-infra/fedora-messaging | docs/sample_schema_package/mailman_schema/schema.py | BaseMessage.url | def url(self):
"""An URL to the email in HyperKitty
Returns:
str or None: A relevant URL.
"""
base_url = "https://lists.fedoraproject.org/archives"
archived_at = self._get_archived_at()
if archived_at and archived_at.startswith("<"):
archived_at = archived_at[1:]
if archived_at and archived_at.endswith(">"):
archived_at = archived_at[:-1]
if archived_at and archived_at.startswith("http"):
return archived_at
elif archived_at:
return base_url + archived_at
else:
return None | python | def url(self):
"""An URL to the email in HyperKitty
Returns:
str or None: A relevant URL.
"""
base_url = "https://lists.fedoraproject.org/archives"
archived_at = self._get_archived_at()
if archived_at and archived_at.startswith("<"):
archived_at = archived_at[1:]
if archived_at and archived_at.endswith(">"):
archived_at = archived_at[:-1]
if archived_at and archived_at.startswith("http"):
return archived_at
elif archived_at:
return base_url + archived_at
else:
return None | An URL to the email in HyperKitty
Returns:
str or None: A relevant URL. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/docs/sample_schema_package/mailman_schema/schema.py#L52-L69 |
fedora-infra/fedora-messaging | setup.py | get_requirements | def get_requirements(requirements_file="requirements.txt"):
"""Get the contents of a file listing the requirements.
Args:
requirements_file (str): The path to the requirements file, relative
to this file.
Returns:
list: the list of requirements, or an empty list if
``requirements_file`` could not be opened or read.
"""
with open(requirements_file) as fd:
lines = fd.readlines()
dependencies = []
for line in lines:
maybe_dep = line.strip()
if maybe_dep.startswith("#"):
# Skip pure comment lines
continue
if maybe_dep.startswith("git+"):
# VCS reference for dev purposes, expect a trailing comment
# with the normal requirement
__, __, maybe_dep = maybe_dep.rpartition("#")
else:
# Ignore any trailing comment
maybe_dep, __, __ = maybe_dep.partition("#")
# Remove any whitespace and assume non-empty results are dependencies
maybe_dep = maybe_dep.strip()
if maybe_dep:
dependencies.append(maybe_dep)
return dependencies | python | def get_requirements(requirements_file="requirements.txt"):
"""Get the contents of a file listing the requirements.
Args:
requirements_file (str): The path to the requirements file, relative
to this file.
Returns:
list: the list of requirements, or an empty list if
``requirements_file`` could not be opened or read.
"""
with open(requirements_file) as fd:
lines = fd.readlines()
dependencies = []
for line in lines:
maybe_dep = line.strip()
if maybe_dep.startswith("#"):
# Skip pure comment lines
continue
if maybe_dep.startswith("git+"):
# VCS reference for dev purposes, expect a trailing comment
# with the normal requirement
__, __, maybe_dep = maybe_dep.rpartition("#")
else:
# Ignore any trailing comment
maybe_dep, __, __ = maybe_dep.partition("#")
# Remove any whitespace and assume non-empty results are dependencies
maybe_dep = maybe_dep.strip()
if maybe_dep:
dependencies.append(maybe_dep)
return dependencies | Get the contents of a file listing the requirements.
Args:
requirements_file (str): The path to the requirements file, relative
to this file.
Returns:
list: the list of requirements, or an empty list if
``requirements_file`` could not be opened or read. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/setup.py#L18-L48 |
fedora-infra/fedora-messaging | fedora_messaging/schema_utils.py | user_avatar_url | def user_avatar_url(username, size=64, default="retro"):
"""Get the avatar URL of the provided Fedora username.
The URL is returned from the Libravatar service.
Args:
username (str): The username to get the avatar of.
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image.
"""
openid = "http://{}.id.fedoraproject.org/".format(username)
return libravatar_url(openid=openid, size=size, default=default) | python | def user_avatar_url(username, size=64, default="retro"):
"""Get the avatar URL of the provided Fedora username.
The URL is returned from the Libravatar service.
Args:
username (str): The username to get the avatar of.
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image.
"""
openid = "http://{}.id.fedoraproject.org/".format(username)
return libravatar_url(openid=openid, size=size, default=default) | Get the avatar URL of the provided Fedora username.
The URL is returned from the Libravatar service.
Args:
username (str): The username to get the avatar of.
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/schema_utils.py#L27-L40 |
fedora-infra/fedora-messaging | fedora_messaging/schema_utils.py | libravatar_url | def libravatar_url(email=None, openid=None, size=64, default="retro"):
"""Get the URL to an avatar from libravatar.
Either the user's email or openid must be provided.
If you want to use Libravatar federation (through DNS), you should install
and use the ``libravatar`` library instead. Check out the
``libravatar.libravatar_url()`` function.
Args:
email (str): The user's email
openid (str): The user's OpenID
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image.
Raises:
ValueError: If neither email nor openid are provided.
"""
# We use an OrderedDict here to make testing easier (URL strings become
# predictable).
params = collections.OrderedDict([("s", size), ("d", default)])
query = parse.urlencode(params)
if email:
value = email
elif openid:
value = openid
else:
raise ValueError("You must provide either the email or the openid.")
idhash = sha256(value.encode("utf-8")).hexdigest()
return "https://seccdn.libravatar.org/avatar/%s?%s" % (idhash, query) | python | def libravatar_url(email=None, openid=None, size=64, default="retro"):
"""Get the URL to an avatar from libravatar.
Either the user's email or openid must be provided.
If you want to use Libravatar federation (through DNS), you should install
and use the ``libravatar`` library instead. Check out the
``libravatar.libravatar_url()`` function.
Args:
email (str): The user's email
openid (str): The user's OpenID
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image.
Raises:
ValueError: If neither email nor openid are provided.
"""
# We use an OrderedDict here to make testing easier (URL strings become
# predictable).
params = collections.OrderedDict([("s", size), ("d", default)])
query = parse.urlencode(params)
if email:
value = email
elif openid:
value = openid
else:
raise ValueError("You must provide either the email or the openid.")
idhash = sha256(value.encode("utf-8")).hexdigest()
return "https://seccdn.libravatar.org/avatar/%s?%s" % (idhash, query) | Get the URL to an avatar from libravatar.
Either the user's email or openid must be provided.
If you want to use Libravatar federation (through DNS), you should install
and use the ``libravatar`` library instead. Check out the
``libravatar.libravatar_url()`` function.
Args:
email (str): The user's email
openid (str): The user's OpenID
size (int): Size of the avatar in pixels (it's a square).
default (str): Default avatar to return if not found.
Returns:
str: The URL to the avatar image.
Raises:
ValueError: If neither email nor openid are provided. | https://github.com/fedora-infra/fedora-messaging/blob/be3e88534e2b15d579bcd24f9c4b7e795cb7e0b7/fedora_messaging/schema_utils.py#L43-L73 |
sanoma/django-arctic | arctic/templatetags/arctic_tags.py | get_parameters | def get_parameters(parser, token):
"""
{% get_parameters except_field %}
"""
args = token.split_contents()
if len(args) < 2:
raise template.TemplateSyntaxError(
"get_parameters tag takes at least 1 argument"
)
return GetParametersNode(args[1].strip()) | python | def get_parameters(parser, token):
"""
{% get_parameters except_field %}
"""
args = token.split_contents()
if len(args) < 2:
raise template.TemplateSyntaxError(
"get_parameters tag takes at least 1 argument"
)
return GetParametersNode(args[1].strip()) | {% get_parameters except_field %} | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/templatetags/arctic_tags.py#L36-L45 |
sanoma/django-arctic | arctic/templatetags/arctic_tags.py | get_all_fields | def get_all_fields(obj):
"""Returns a list of all field names on the instance."""
fields = []
for f in obj._meta.fields:
fname = f.name
get_choice = "get_" + fname + "_display"
if hasattr(obj, get_choice):
value = getattr(obj, get_choice)()
else:
try:
value = getattr(obj, fname)
except Exception:
value = None
if isinstance(value, list):
value = ",".join(str(v) for v in value)
if f.editable and value and f.name:
fields.append(
{"label": f.verbose_name, "name": f.name, "value": value}
)
return fields | python | def get_all_fields(obj):
"""Returns a list of all field names on the instance."""
fields = []
for f in obj._meta.fields:
fname = f.name
get_choice = "get_" + fname + "_display"
if hasattr(obj, get_choice):
value = getattr(obj, get_choice)()
else:
try:
value = getattr(obj, fname)
except Exception:
value = None
if isinstance(value, list):
value = ",".join(str(v) for v in value)
if f.editable and value and f.name:
fields.append(
{"label": f.verbose_name, "name": f.name, "value": value}
)
return fields | Returns a list of all field names on the instance. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/templatetags/arctic_tags.py#L81-L104 |
sanoma/django-arctic | arctic/templatetags/arctic_tags.py | query_string | def query_string(context, **kwargs):
"""Add param to the given query string"""
params = context["request"].GET.copy()
for key, value in list(kwargs.items()):
params[key] = value
return "?" + params.urlencode() | python | def query_string(context, **kwargs):
"""Add param to the given query string"""
params = context["request"].GET.copy()
for key, value in list(kwargs.items()):
params[key] = value
return "?" + params.urlencode() | Add param to the given query string | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/templatetags/arctic_tags.py#L108-L115 |
sanoma/django-arctic | arctic/templatetags/arctic_tags.py | query_string_ordering | def query_string_ordering(context, value, **kwargs):
"""
Add ordering param to the given query string
:param context: template context
:param value: examples would be '-id' or 'id'. A minus indicates that the
default sorting is descending
:param kwargs: not used
:return: Adjusted query string, starting with '?'
"""
params = context["request"].GET.copy()
# if the given value is '-id', it's core value would be 'id'
core_value = value
default_order = "asc"
if core_value[0] == "-":
core_value = value[1:]
default_order = "desc"
current_value = ""
# by preference get the current ordering value from the filter
# so that even if no explicit ordering is in the URL, we still
# get the implicit ordering, the page's default
# See generics.filters.FilterSet
if "filter" in context:
current_value = context["filter"].ordered_value()
elif "ordering" in params:
current_value = params["ordering"]
# The first two clauses check if the current ordering is on the
# same field as the desired one, in which case we reverse the direction.
# If it's on another field, we use the default direction.
if current_value == core_value:
order_prefix = "-"
elif current_value == "-" + core_value:
order_prefix = ""
elif default_order == "desc":
order_prefix = "-"
else:
order_prefix = ""
params["ordering"] = order_prefix + core_value
return "?" + params.urlencode() | python | def query_string_ordering(context, value, **kwargs):
"""
Add ordering param to the given query string
:param context: template context
:param value: examples would be '-id' or 'id'. A minus indicates that the
default sorting is descending
:param kwargs: not used
:return: Adjusted query string, starting with '?'
"""
params = context["request"].GET.copy()
# if the given value is '-id', it's core value would be 'id'
core_value = value
default_order = "asc"
if core_value[0] == "-":
core_value = value[1:]
default_order = "desc"
current_value = ""
# by preference get the current ordering value from the filter
# so that even if no explicit ordering is in the URL, we still
# get the implicit ordering, the page's default
# See generics.filters.FilterSet
if "filter" in context:
current_value = context["filter"].ordered_value()
elif "ordering" in params:
current_value = params["ordering"]
# The first two clauses check if the current ordering is on the
# same field as the desired one, in which case we reverse the direction.
# If it's on another field, we use the default direction.
if current_value == core_value:
order_prefix = "-"
elif current_value == "-" + core_value:
order_prefix = ""
elif default_order == "desc":
order_prefix = "-"
else:
order_prefix = ""
params["ordering"] = order_prefix + core_value
return "?" + params.urlencode() | Add ordering param to the given query string
:param context: template context
:param value: examples would be '-id' or 'id'. A minus indicates that the
default sorting is descending
:param kwargs: not used
:return: Adjusted query string, starting with '?' | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/templatetags/arctic_tags.py#L119-L162 |
sanoma/django-arctic | arctic/templatetags/arctic_tags.py | arctic_url | def arctic_url(context, link, *args, **kwargs):
"""
Resolves links into urls with optional
arguments set in self.urls. please check get_urls method in View.
We could tie this to check_url_access() to check for permissions,
including object-level.
"""
def reverse_mutable_url_args(url_args):
mutated_url_args = []
for arg in url_args:
# listview item, and argument is a string
if "item" in context and type(arg) == str:
# try to get attribute of this object
try:
arg = getattr(context["v"], arg.split(".")[-1])
# if not found fallback to row pk, which is always first column
except Exception:
arg = context["item"][0]
mutated_url_args.append(arg)
return reverse(link, args=mutated_url_args, kwargs=None)
url_args = args
# set arguments defined in urls if provided
if type(link) in (tuple, list):
context["urls"][link[0]] = list(link[1:])
link = link[0]
if link in context["urls"]:
# for where the params directly given. e.g. ('article-detail',
# (self.object.pk,))
url_args = context["urls"][link]
# list given, which means it's mutable!
if isinstance(url_args, list):
return reverse_mutable_url_args(url_args)
return reverse(link, args=url_args, kwargs=None) | python | def arctic_url(context, link, *args, **kwargs):
"""
Resolves links into urls with optional
arguments set in self.urls. please check get_urls method in View.
We could tie this to check_url_access() to check for permissions,
including object-level.
"""
def reverse_mutable_url_args(url_args):
mutated_url_args = []
for arg in url_args:
# listview item, and argument is a string
if "item" in context and type(arg) == str:
# try to get attribute of this object
try:
arg = getattr(context["v"], arg.split(".")[-1])
# if not found fallback to row pk, which is always first column
except Exception:
arg = context["item"][0]
mutated_url_args.append(arg)
return reverse(link, args=mutated_url_args, kwargs=None)
url_args = args
# set arguments defined in urls if provided
if type(link) in (tuple, list):
context["urls"][link[0]] = list(link[1:])
link = link[0]
if link in context["urls"]:
# for where the params directly given. e.g. ('article-detail',
# (self.object.pk,))
url_args = context["urls"][link]
# list given, which means it's mutable!
if isinstance(url_args, list):
return reverse_mutable_url_args(url_args)
return reverse(link, args=url_args, kwargs=None) | Resolves links into urls with optional
arguments set in self.urls. please check get_urls method in View.
We could tie this to check_url_access() to check for permissions,
including object-level. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/templatetags/arctic_tags.py#L166-L206 |
sanoma/django-arctic | arctic/loading.py | get_role_model | def get_role_model():
"""
Returns the Role model that is active in this project.
"""
app_model = getattr(settings, "ARCTIC_ROLE_MODEL", "arctic.Role")
try:
return django_apps.get_model(app_model)
except ValueError:
raise ImproperlyConfigured(
"ARCTIC_ROLE_MODEL must be of the " "form 'app_label.model_name'"
)
except LookupError:
raise ImproperlyConfigured(
"ARCTIC_ROLE_MODEL refers to model '%s' that has not been "
"installed" % settings.ARCTIC_ROLE_MODEL
) | python | def get_role_model():
"""
Returns the Role model that is active in this project.
"""
app_model = getattr(settings, "ARCTIC_ROLE_MODEL", "arctic.Role")
try:
return django_apps.get_model(app_model)
except ValueError:
raise ImproperlyConfigured(
"ARCTIC_ROLE_MODEL must be of the " "form 'app_label.model_name'"
)
except LookupError:
raise ImproperlyConfigured(
"ARCTIC_ROLE_MODEL refers to model '%s' that has not been "
"installed" % settings.ARCTIC_ROLE_MODEL
) | Returns the Role model that is active in this project. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/loading.py#L6-L22 |
sanoma/django-arctic | arctic/loading.py | get_user_role_model | def get_user_role_model():
"""
Returns the UserRole model that is active in this project.
"""
app_model = getattr(settings, "ARCTIC_USER_ROLE_MODEL", "arctic.UserRole")
try:
return django_apps.get_model(app_model)
except ValueError:
raise ImproperlyConfigured(
"ARCTIC_USER_ROLE_MODEL must be of the "
"form 'app_label.model_name'"
)
except LookupError:
raise ImproperlyConfigured(
"ARCTIC_USER_ROLE_MODEL refers to model '%s' that has not been "
"installed" % settings.ARCTIC_USER_ROLE_MODEL
) | python | def get_user_role_model():
"""
Returns the UserRole model that is active in this project.
"""
app_model = getattr(settings, "ARCTIC_USER_ROLE_MODEL", "arctic.UserRole")
try:
return django_apps.get_model(app_model)
except ValueError:
raise ImproperlyConfigured(
"ARCTIC_USER_ROLE_MODEL must be of the "
"form 'app_label.model_name'"
)
except LookupError:
raise ImproperlyConfigured(
"ARCTIC_USER_ROLE_MODEL refers to model '%s' that has not been "
"installed" % settings.ARCTIC_USER_ROLE_MODEL
) | Returns the UserRole model that is active in this project. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/loading.py#L25-L42 |
sanoma/django-arctic | arctic/generics.py | View.dispatch | def dispatch(self, request, *args, **kwargs):
"""
Most views in a CMS require a login, so this is the default setup.
If a login is not required then the requires_login property
can be set to False to disable this.
"""
if self.requires_login:
if settings.LOGIN_URL is None or settings.LOGOUT_URL is None:
raise ImproperlyConfigured(
"LOGIN_URL and LOGOUT_URL "
"has to be defined if requires_login is True"
)
if not request.user.is_authenticated:
return redirect(
"%s?next=%s"
% (
resolve_url(settings.LOGIN_URL),
quote(request.get_full_path()),
)
)
return super(View, self).dispatch(request, *args, **kwargs) | python | def dispatch(self, request, *args, **kwargs):
"""
Most views in a CMS require a login, so this is the default setup.
If a login is not required then the requires_login property
can be set to False to disable this.
"""
if self.requires_login:
if settings.LOGIN_URL is None or settings.LOGOUT_URL is None:
raise ImproperlyConfigured(
"LOGIN_URL and LOGOUT_URL "
"has to be defined if requires_login is True"
)
if not request.user.is_authenticated:
return redirect(
"%s?next=%s"
% (
resolve_url(settings.LOGIN_URL),
quote(request.get_full_path()),
)
)
return super(View, self).dispatch(request, *args, **kwargs) | Most views in a CMS require a login, so this is the default setup.
If a login is not required then the requires_login property
can be set to False to disable this. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L76-L99 |
sanoma/django-arctic | arctic/generics.py | View.get_breadcrumbs | def get_breadcrumbs(self):
"""
Breadcrumb format: (('name', 'url'), ...) or None if not used.
"""
if not self.breadcrumbs:
return None
else:
allowed_breadcrumbs = []
for breadcrumb in self.breadcrumbs:
# check permission based on named_url
if breadcrumb[1] is not None and not view_from_url(
breadcrumb[1]
).has_permission(self.request.user):
continue
obj = self if not hasattr(self, "object") else self.object
url = (
None
if not breadcrumb[1]
else reverse_url(breadcrumb[1], obj)
)
allowed_breadcrumbs.append({"name": breadcrumb[0], "url": url})
return allowed_breadcrumbs | python | def get_breadcrumbs(self):
"""
Breadcrumb format: (('name', 'url'), ...) or None if not used.
"""
if not self.breadcrumbs:
return None
else:
allowed_breadcrumbs = []
for breadcrumb in self.breadcrumbs:
# check permission based on named_url
if breadcrumb[1] is not None and not view_from_url(
breadcrumb[1]
).has_permission(self.request.user):
continue
obj = self if not hasattr(self, "object") else self.object
url = (
None
if not breadcrumb[1]
else reverse_url(breadcrumb[1], obj)
)
allowed_breadcrumbs.append({"name": breadcrumb[0], "url": url})
return allowed_breadcrumbs | Breadcrumb format: (('name', 'url'), ...) or None if not used. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L126-L149 |
sanoma/django-arctic | arctic/generics.py | View.get_tabs | def get_tabs(self):
"""
Tabs format: (('name', 'url'), ...) or None if tabs are not used.
"""
if not self.tabs:
return None
else:
allowed_tabs = []
for tab in self.tabs:
# check permission based on named_url
if not view_from_url(tab[1]).has_permission(self.request.user):
continue
obj = self if not hasattr(self, "object") else self.object
url = reverse_url(tab[1], obj)
allowed_tabs.append(
{
"name": tab[0],
"active": self.request.path == url,
"url": self.in_modal(url),
}
)
return allowed_tabs | python | def get_tabs(self):
"""
Tabs format: (('name', 'url'), ...) or None if tabs are not used.
"""
if not self.tabs:
return None
else:
allowed_tabs = []
for tab in self.tabs:
# check permission based on named_url
if not view_from_url(tab[1]).has_permission(self.request.user):
continue
obj = self if not hasattr(self, "object") else self.object
url = reverse_url(tab[1], obj)
allowed_tabs.append(
{
"name": tab[0],
"active": self.request.path == url,
"url": self.in_modal(url),
}
)
return allowed_tabs | Tabs format: (('name', 'url'), ...) or None if tabs are not used. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L151-L174 |
sanoma/django-arctic | arctic/generics.py | View.media | def media(self):
"""
Return all media required to render this view, including forms.
"""
media = self._get_common_media()
media += self._get_view_media()
media += self.get_media_assets()
return media | python | def media(self):
"""
Return all media required to render this view, including forms.
"""
media = self._get_common_media()
media += self._get_view_media()
media += self.get_media_assets()
return media | Return all media required to render this view, including forms. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L262-L269 |
sanoma/django-arctic | arctic/generics.py | View._get_view_media | def _get_view_media(self):
"""
Gather view-level media assets
"""
try:
css = self.Media.css
except AttributeError:
css = {}
try:
js = self.Media.js
except AttributeError:
js = []
return Media(css=css, js=js) | python | def _get_view_media(self):
"""
Gather view-level media assets
"""
try:
css = self.Media.css
except AttributeError:
css = {}
try:
js = self.Media.js
except AttributeError:
js = []
return Media(css=css, js=js) | Gather view-level media assets | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L284-L296 |
sanoma/django-arctic | arctic/generics.py | ListView.get_list_header | def get_list_header(self):
"""
Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template.
"""
model = self.object_list.model
result = []
if not self.get_fields():
result.append(
{"name": "", "verbose": str(model._meta.verbose_name)}
)
else:
prefix = self.get_prefix()
ordering_fields = self.get_ordering_fields()
for field_name in self.get_fields():
item = {}
if isinstance(field_name, tuple):
# custom property that is not a field of the model
name = field_name[0]
item["label"] = field_name[1]
else:
name = field_name
try:
field_meta = find_field_meta(model, field_name)
if field_meta._verbose_name: # noqa
# explicitly set on the model, so don't change
item["label"] = field_meta._verbose_name # noqa
else:
# title-case the field name (issue #80)
item["label"] = field_meta.verbose_name.title()
except FieldDoesNotExist:
item["label"] = field_name
except AttributeError:
item["label"] = field_name
item["name"] = prefix + name
if name in ordering_fields:
item["order_url"], item[
"order_direction"
] = self.ordering_url(name)
result.append(item)
return result | python | def get_list_header(self):
"""
Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template.
"""
model = self.object_list.model
result = []
if not self.get_fields():
result.append(
{"name": "", "verbose": str(model._meta.verbose_name)}
)
else:
prefix = self.get_prefix()
ordering_fields = self.get_ordering_fields()
for field_name in self.get_fields():
item = {}
if isinstance(field_name, tuple):
# custom property that is not a field of the model
name = field_name[0]
item["label"] = field_name[1]
else:
name = field_name
try:
field_meta = find_field_meta(model, field_name)
if field_meta._verbose_name: # noqa
# explicitly set on the model, so don't change
item["label"] = field_meta._verbose_name # noqa
else:
# title-case the field name (issue #80)
item["label"] = field_meta.verbose_name.title()
except FieldDoesNotExist:
item["label"] = field_name
except AttributeError:
item["label"] = field_name
item["name"] = prefix + name
if name in ordering_fields:
item["order_url"], item[
"order_direction"
] = self.ordering_url(name)
result.append(item)
return result | Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L416-L458 |
sanoma/django-arctic | arctic/generics.py | ListView.get_ordering | def get_ordering(self):
"""Ordering used for queryset filtering (should not contain prefix)."""
if self.sorting_field:
return [self.sorting_field]
prefix = self.get_prefix()
fields = self.get_ordering_with_prefix()
if self.prefix:
fields = [f.replace(prefix, "", 1) for f in fields]
return [
f
for f in fields
if f.lstrip("-") in self.get_ordering_fields_lookups()
] | python | def get_ordering(self):
"""Ordering used for queryset filtering (should not contain prefix)."""
if self.sorting_field:
return [self.sorting_field]
prefix = self.get_prefix()
fields = self.get_ordering_with_prefix()
if self.prefix:
fields = [f.replace(prefix, "", 1) for f in fields]
return [
f
for f in fields
if f.lstrip("-") in self.get_ordering_fields_lookups()
] | Ordering used for queryset filtering (should not contain prefix). | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L563-L575 |
sanoma/django-arctic | arctic/generics.py | DataListView.get_list_header | def get_list_header(self):
"""
Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template.
"""
result = []
for field_name in self.get_fields():
item = {}
if isinstance(field_name, tuple):
# custom property that is not a field of the model
item["name"] = field_name[0]
item["label"] = field_name[1]
else:
item["name"] = field_name
item["label"] = field_name.title()
if item["name"] in self.get_ordering_fields():
item["order_url"], item["order_direction"] = self.ordering_url(
item["name"]
)
result.append(item)
return result | python | def get_list_header(self):
"""
Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template.
"""
result = []
for field_name in self.get_fields():
item = {}
if isinstance(field_name, tuple):
# custom property that is not a field of the model
item["name"] = field_name[0]
item["label"] = field_name[1]
else:
item["name"] = field_name
item["label"] = field_name.title()
if item["name"] in self.get_ordering_fields():
item["order_url"], item["order_direction"] = self.ordering_url(
item["name"]
)
result.append(item)
return result | Creates a list of dictionaries with the field names, labels,
field links, field css classes, order_url and order_direction,
this simplifies the creation of a table in a template. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L649-L671 |
sanoma/django-arctic | arctic/generics.py | DataListView.get_paginator | def get_paginator(
self,
dataset,
per_page,
orphans=0,
allow_empty_first_page=True,
**kwargs
):
"""Return an instance of the paginator for this view."""
return IndefinitePaginator(
dataset,
per_page,
orphans=orphans,
allow_empty_first_page=allow_empty_first_page,
**kwargs
) | python | def get_paginator(
self,
dataset,
per_page,
orphans=0,
allow_empty_first_page=True,
**kwargs
):
"""Return an instance of the paginator for this view."""
return IndefinitePaginator(
dataset,
per_page,
orphans=orphans,
allow_empty_first_page=allow_empty_first_page,
**kwargs
) | Return an instance of the paginator for this view. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L729-L744 |
sanoma/django-arctic | arctic/generics.py | DeleteView.get | def get(self, request, *args, **kwargs):
"""
Catch protected relations and show to user.
"""
self.object = self.get_object()
can_delete = True
protected_objects = []
collector_message = None
collector = Collector(using="default")
try:
collector.collect([self.object])
except ProtectedError as e:
collector_message = (
"Cannot delete %s because it has relations "
"that depends on it." % self.object
)
protected_objects = e.protected_objects
can_delete = False
if can_delete and self.redirect:
messages.success(request, self.get_success_message(self.object))
return self.delete(request, *args, **kwargs)
context = self.get_context_data(
object=self.object,
can_delete=can_delete,
collector_message=collector_message,
protected_objects=protected_objects,
)
return self.render_to_response(context) | python | def get(self, request, *args, **kwargs):
"""
Catch protected relations and show to user.
"""
self.object = self.get_object()
can_delete = True
protected_objects = []
collector_message = None
collector = Collector(using="default")
try:
collector.collect([self.object])
except ProtectedError as e:
collector_message = (
"Cannot delete %s because it has relations "
"that depends on it." % self.object
)
protected_objects = e.protected_objects
can_delete = False
if can_delete and self.redirect:
messages.success(request, self.get_success_message(self.object))
return self.delete(request, *args, **kwargs)
context = self.get_context_data(
object=self.object,
can_delete=can_delete,
collector_message=collector_message,
protected_objects=protected_objects,
)
return self.render_to_response(context) | Catch protected relations and show to user. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/generics.py#L855-L884 |
sanoma/django-arctic | arctic/mixins.py | ModalMixin.get_modal_link | def get_modal_link(self, url, obj={}):
"""
Returns the metadata for a link that needs to be confirmed, if it
exists, it also parses the message and title of the url to include
row field data if needed.
"""
if not (url in self.modal_links.keys()):
return None
try:
if type(obj) != dict:
obj.obj = str(obj)
obj = vars(obj)
link = self.modal_links[url]
if link["type"] == "confirm":
link["message"] = link["message"].format(**obj)
link["title"] = link["title"].format(**obj)
link["ok"] # triggers a KeyError exception if not existent
link["cancel"]
elif link["type"] == "iframe":
try:
link["size"]
except KeyError:
link["size"] = "medium"
else:
raise ImproperlyConfigured(
"modal_links type: " + link["type"] + " is unsupported"
)
return link
except KeyError as e:
raise ImproperlyConfigured(
"modal_links misses the following attribute: " + str(e)
)
except AttributeError:
return None | python | def get_modal_link(self, url, obj={}):
"""
Returns the metadata for a link that needs to be confirmed, if it
exists, it also parses the message and title of the url to include
row field data if needed.
"""
if not (url in self.modal_links.keys()):
return None
try:
if type(obj) != dict:
obj.obj = str(obj)
obj = vars(obj)
link = self.modal_links[url]
if link["type"] == "confirm":
link["message"] = link["message"].format(**obj)
link["title"] = link["title"].format(**obj)
link["ok"] # triggers a KeyError exception if not existent
link["cancel"]
elif link["type"] == "iframe":
try:
link["size"]
except KeyError:
link["size"] = "medium"
else:
raise ImproperlyConfigured(
"modal_links type: " + link["type"] + " is unsupported"
)
return link
except KeyError as e:
raise ImproperlyConfigured(
"modal_links misses the following attribute: " + str(e)
)
except AttributeError:
return None | Returns the metadata for a link that needs to be confirmed, if it
exists, it also parses the message and title of the url to include
row field data if needed. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L56-L90 |
sanoma/django-arctic | arctic/mixins.py | FormMixin.get_success_url | def get_success_url(self):
"""Return the URL to redirect to after processing a valid form."""
if not self.success_url:
if self.request.GET.get("inmodal"):
return reverse("arctic:redirect_to_parent")
raise ImproperlyConfigured(
"No URL to redirect to. Provide a success_url."
)
return self.in_modal(str(self.success_url)) | python | def get_success_url(self):
"""Return the URL to redirect to after processing a valid form."""
if not self.success_url:
if self.request.GET.get("inmodal"):
return reverse("arctic:redirect_to_parent")
raise ImproperlyConfigured(
"No URL to redirect to. Provide a success_url."
)
return self.in_modal(str(self.success_url)) | Return the URL to redirect to after processing a valid form. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L132-L140 |
sanoma/django-arctic | arctic/mixins.py | FormMixin._set_has_no_columns | def _set_has_no_columns(self, has_no_column, col_avg, col_last, fields):
"""
Regenerate has_no_column by adding the amount of columns at the end
"""
for index, field in has_no_column.items():
if index == len(has_no_column):
field_name = "{field}|{col_last}".format(
field=field, col_last=col_last
)
has_no_column[index] = self._return_field(field_name, fields)
else:
field_name = "{field}|{col_avg}".format(
field=field, col_avg=col_avg
)
has_no_column[index] = self._return_field(field_name, fields)
return has_no_column | python | def _set_has_no_columns(self, has_no_column, col_avg, col_last, fields):
"""
Regenerate has_no_column by adding the amount of columns at the end
"""
for index, field in has_no_column.items():
if index == len(has_no_column):
field_name = "{field}|{col_last}".format(
field=field, col_last=col_last
)
has_no_column[index] = self._return_field(field_name, fields)
else:
field_name = "{field}|{col_avg}".format(
field=field, col_avg=col_avg
)
has_no_column[index] = self._return_field(field_name, fields)
return has_no_column | Regenerate has_no_column by adding the amount of columns at the end | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L313-L328 |
sanoma/django-arctic | arctic/mixins.py | FormMixin._return_fieldset | def _return_fieldset(self, fieldset):
"""
This function became a bit messy, since it needs to deal with two
cases.
1) No fieldset, which is represented as an integer
2) A fieldset
"""
collapsible = None
description = None
try:
# Make sure strings with numbers work as well, do this
int(str(fieldset))
title = None
except ValueError:
if fieldset.count("|") > 1:
raise ImproperlyConfigured(
"The fieldset name does not "
"support more than one | sign. "
"It's meant to separate a "
"fieldset from its description."
)
title = fieldset
if "|" in fieldset:
title, description = fieldset.split("|")
if fieldset and (fieldset[0] in "-+"):
if fieldset[0] == "-":
collapsible = "closed"
else:
collapsible = "open"
title = title[1:]
return {
"title": title,
"description": description,
"collapsible": collapsible,
} | python | def _return_fieldset(self, fieldset):
"""
This function became a bit messy, since it needs to deal with two
cases.
1) No fieldset, which is represented as an integer
2) A fieldset
"""
collapsible = None
description = None
try:
# Make sure strings with numbers work as well, do this
int(str(fieldset))
title = None
except ValueError:
if fieldset.count("|") > 1:
raise ImproperlyConfigured(
"The fieldset name does not "
"support more than one | sign. "
"It's meant to separate a "
"fieldset from its description."
)
title = fieldset
if "|" in fieldset:
title, description = fieldset.split("|")
if fieldset and (fieldset[0] in "-+"):
if fieldset[0] == "-":
collapsible = "closed"
else:
collapsible = "open"
title = title[1:]
return {
"title": title,
"description": description,
"collapsible": collapsible,
} | This function became a bit messy, since it needs to deal with two
cases.
1) No fieldset, which is represented as an integer
2) A fieldset | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L330-L367 |
sanoma/django-arctic | arctic/mixins.py | FormMixin._calc_avg_and_last_val | def _calc_avg_and_last_val(self, has_no_column, sum_existing_columns):
"""
Calculate the average of all columns and return a rounded down number.
Store the remainder and add it to the last row. Could be implemented
better. If the enduser wants more control, he can also just add the
amount of columns. Will work fine with small number (<4) of items in a
row.
:param has_no_column:
:param sum_existing_columns:
:return: average, columns_for_last_element
"""
sum_no_columns = len(has_no_column)
columns_left = self.ALLOWED_COLUMNS - sum_existing_columns
if sum_no_columns == 0:
columns_avg = columns_left
else:
columns_avg = int(columns_left / sum_no_columns)
remainder = columns_left - (columns_avg * sum_no_columns)
columns_for_last_element = columns_avg + remainder
return columns_avg, columns_for_last_element | python | def _calc_avg_and_last_val(self, has_no_column, sum_existing_columns):
"""
Calculate the average of all columns and return a rounded down number.
Store the remainder and add it to the last row. Could be implemented
better. If the enduser wants more control, he can also just add the
amount of columns. Will work fine with small number (<4) of items in a
row.
:param has_no_column:
:param sum_existing_columns:
:return: average, columns_for_last_element
"""
sum_no_columns = len(has_no_column)
columns_left = self.ALLOWED_COLUMNS - sum_existing_columns
if sum_no_columns == 0:
columns_avg = columns_left
else:
columns_avg = int(columns_left / sum_no_columns)
remainder = columns_left - (columns_avg * sum_no_columns)
columns_for_last_element = columns_avg + remainder
return columns_avg, columns_for_last_element | Calculate the average of all columns and return a rounded down number.
Store the remainder and add it to the last row. Could be implemented
better. If the enduser wants more control, he can also just add the
amount of columns. Will work fine with small number (<4) of items in a
row.
:param has_no_column:
:param sum_existing_columns:
:return: average, columns_for_last_element | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L369-L391 |
sanoma/django-arctic | arctic/mixins.py | FormMixin._split_str | def _split_str(self, field):
"""
Split title|7 into (title, 7)
"""
field_items = field.split("|")
if len(field_items) == 2:
return field_items[0], field_items[1]
elif len(field_items) == 1:
return field_items[0], None | python | def _split_str(self, field):
"""
Split title|7 into (title, 7)
"""
field_items = field.split("|")
if len(field_items) == 2:
return field_items[0], field_items[1]
elif len(field_items) == 1:
return field_items[0], None | Split title|7 into (title, 7) | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L393-L401 |
sanoma/django-arctic | arctic/mixins.py | ListMixin.ordering_url | def ordering_url(self, field_name):
"""
Creates a url link for sorting the given field.
The direction of sorting will be either ascending, if the field is not
yet sorted, or the opposite of the current sorting if sorted.
"""
path = self.request.path
direction = ""
query_params = self.request.GET.copy()
ordering = self.request.GET.get("order", "").split(",")
field = self._get_ordering_field_lookup(field_name)
if not ordering:
ordering = self.get_default_ordering()
merged_ordering = list(ordering) # copy the list
for ordering_field in self.get_ordering_fields_lookups():
if (ordering_field.lstrip("-") not in ordering) and (
("-" + ordering_field.lstrip("-")) not in ordering
):
merged_ordering.append(ordering_field)
new_ordering = []
for item in merged_ordering:
if item.lstrip("-") == field.lstrip("-"):
if (item[0] == "-") or not (item in ordering):
if item in ordering:
direction = "desc"
new_ordering.insert(0, item.lstrip("-"))
else:
direction = "asc"
new_ordering.insert(0, "-" + item)
query_params["order"] = ",".join(new_ordering)
return (path + "?" + query_params.urlencode(safe=","), direction) | python | def ordering_url(self, field_name):
"""
Creates a url link for sorting the given field.
The direction of sorting will be either ascending, if the field is not
yet sorted, or the opposite of the current sorting if sorted.
"""
path = self.request.path
direction = ""
query_params = self.request.GET.copy()
ordering = self.request.GET.get("order", "").split(",")
field = self._get_ordering_field_lookup(field_name)
if not ordering:
ordering = self.get_default_ordering()
merged_ordering = list(ordering) # copy the list
for ordering_field in self.get_ordering_fields_lookups():
if (ordering_field.lstrip("-") not in ordering) and (
("-" + ordering_field.lstrip("-")) not in ordering
):
merged_ordering.append(ordering_field)
new_ordering = []
for item in merged_ordering:
if item.lstrip("-") == field.lstrip("-"):
if (item[0] == "-") or not (item in ordering):
if item in ordering:
direction = "desc"
new_ordering.insert(0, item.lstrip("-"))
else:
direction = "asc"
new_ordering.insert(0, "-" + item)
query_params["order"] = ",".join(new_ordering)
return (path + "?" + query_params.urlencode(safe=","), direction) | Creates a url link for sorting the given field.
The direction of sorting will be either ascending, if the field is not
yet sorted, or the opposite of the current sorting if sorted. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L561-L596 |
sanoma/django-arctic | arctic/mixins.py | ListMixin.get_fields | def get_fields(self, strip_labels=False):
"""
Hook to dynamically change the fields that will be displayed
"""
if strip_labels:
return [
f[0] if type(f) in (tuple, list) else f for f in self.fields
]
return self.fields | python | def get_fields(self, strip_labels=False):
"""
Hook to dynamically change the fields that will be displayed
"""
if strip_labels:
return [
f[0] if type(f) in (tuple, list) else f for f in self.fields
]
return self.fields | Hook to dynamically change the fields that will be displayed | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L598-L606 |
sanoma/django-arctic | arctic/mixins.py | ListMixin.get_ordering_fields_lookups | def get_ordering_fields_lookups(self):
"""
Getting real model fields to order by
"""
ordering_field = []
for field_name in self.get_ordering_fields():
ordering_field.append(self._get_ordering_field_lookup(field_name))
return ordering_field | python | def get_ordering_fields_lookups(self):
"""
Getting real model fields to order by
"""
ordering_field = []
for field_name in self.get_ordering_fields():
ordering_field.append(self._get_ordering_field_lookup(field_name))
return ordering_field | Getting real model fields to order by | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L614-L621 |
sanoma/django-arctic | arctic/mixins.py | ListMixin._get_ordering_field_lookup | def _get_ordering_field_lookup(self, field_name):
"""
get real model field to order by
"""
field = field_name
get_field = getattr(self, "get_%s_ordering_field" % field_name, None)
if get_field:
field = get_field()
return field | python | def _get_ordering_field_lookup(self, field_name):
"""
get real model field to order by
"""
field = field_name
get_field = getattr(self, "get_%s_ordering_field" % field_name, None)
if get_field:
field = get_field()
return field | get real model field to order by | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L623-L631 |
sanoma/django-arctic | arctic/mixins.py | ListMixin.get_advanced_search_form | def get_advanced_search_form(self, data):
"""
Hook to dynamically change the advanced search form
"""
if self.get_advanced_search_form_class():
self._advanced_search_form = self.get_advanced_search_form_class()(
data=data
)
return self._advanced_search_form | python | def get_advanced_search_form(self, data):
"""
Hook to dynamically change the advanced search form
"""
if self.get_advanced_search_form_class():
self._advanced_search_form = self.get_advanced_search_form_class()(
data=data
)
return self._advanced_search_form | Hook to dynamically change the advanced search form | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L792-L800 |
sanoma/django-arctic | arctic/mixins.py | RoleAuthentication.sync | def sync(cls):
"""
Save all the roles defined in the settings that are not yet in the db
this is needed to create a foreign key relation between a user and a
role. Roles that are no longer specified in settings are set as
inactive.
"""
try:
settings_roles = set(settings.ARCTIC_ROLES.keys())
except AttributeError:
settings_roles = set()
saved_roles = set(Role.objects.values_list("name", flat=True))
unsaved_roles = settings_roles - saved_roles
unused_roles = saved_roles - settings_roles - set([cls.ADMIN])
# ensure that admin is not defined in settings
if cls.ADMIN in settings_roles:
raise ImproperlyConfigured(
'"' + cls.ADMIN + '" role is reserved '
"and cannot be defined in settings"
)
# ensure that admin exists in the database
if cls.ADMIN not in saved_roles:
Role(name=cls.ADMIN, is_active=True).save()
# check if the role defined in settings already exists in the database
# and if it does ensure it is enabled.
for role in saved_roles:
if role in settings_roles:
saved_role = Role.objects.get(name=role)
if not saved_role.is_active:
saved_role.is_active = True
saved_role.save()
for role in unsaved_roles:
Role(name=role).save()
for role in unused_roles:
unused_role = Role.objects.get(name=role)
unused_role.is_active = False
unused_role.save() | python | def sync(cls):
"""
Save all the roles defined in the settings that are not yet in the db
this is needed to create a foreign key relation between a user and a
role. Roles that are no longer specified in settings are set as
inactive.
"""
try:
settings_roles = set(settings.ARCTIC_ROLES.keys())
except AttributeError:
settings_roles = set()
saved_roles = set(Role.objects.values_list("name", flat=True))
unsaved_roles = settings_roles - saved_roles
unused_roles = saved_roles - settings_roles - set([cls.ADMIN])
# ensure that admin is not defined in settings
if cls.ADMIN in settings_roles:
raise ImproperlyConfigured(
'"' + cls.ADMIN + '" role is reserved '
"and cannot be defined in settings"
)
# ensure that admin exists in the database
if cls.ADMIN not in saved_roles:
Role(name=cls.ADMIN, is_active=True).save()
# check if the role defined in settings already exists in the database
# and if it does ensure it is enabled.
for role in saved_roles:
if role in settings_roles:
saved_role = Role.objects.get(name=role)
if not saved_role.is_active:
saved_role.is_active = True
saved_role.save()
for role in unsaved_roles:
Role(name=role).save()
for role in unused_roles:
unused_role = Role.objects.get(name=role)
unused_role.is_active = False
unused_role.save() | Save all the roles defined in the settings that are not yet in the db
this is needed to create a foreign key relation between a user and a
role. Roles that are no longer specified in settings are set as
inactive. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L820-L862 |
sanoma/django-arctic | arctic/mixins.py | RoleAuthentication.get_permission_required | def get_permission_required(cls):
"""
Get permission required property.
Must return an iterable.
"""
if cls.permission_required is None:
raise ImproperlyConfigured(
"{0} is missing the permission_required attribute. "
"Define {0}.permission_required, or override "
"{0}.get_permission_required().".format(cls.__name__)
)
if isinstance(cls.permission_required, six.string_types):
if cls.permission_required != "":
perms = (cls.permission_required,)
else:
perms = ()
else:
perms = cls.permission_required
return perms | python | def get_permission_required(cls):
"""
Get permission required property.
Must return an iterable.
"""
if cls.permission_required is None:
raise ImproperlyConfigured(
"{0} is missing the permission_required attribute. "
"Define {0}.permission_required, or override "
"{0}.get_permission_required().".format(cls.__name__)
)
if isinstance(cls.permission_required, six.string_types):
if cls.permission_required != "":
perms = (cls.permission_required,)
else:
perms = ()
else:
perms = cls.permission_required
return perms | Get permission required property.
Must return an iterable. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L865-L884 |
sanoma/django-arctic | arctic/mixins.py | RoleAuthentication.has_permission | def has_permission(cls, user):
"""
We override this method to customize the way permissions are checked.
Using our roles to check permissions.
"""
# no login is needed, so its always fine
if not cls.requires_login:
return True
# if user is somehow not logged in
if not user.is_authenticated:
return False
# attribute permission_required is mandatory, returns tuple
perms = cls.get_permission_required()
# if perms are defined and empty, we skip checking
if not perms:
return True
# get role of user, skip admin role
role = user.urole.role.name
if role == cls.ADMIN:
return True
# check if at least one permissions is valid
for permission in perms:
if cls.check_permission(role, permission):
return True
# permission denied
return False | python | def has_permission(cls, user):
"""
We override this method to customize the way permissions are checked.
Using our roles to check permissions.
"""
# no login is needed, so its always fine
if not cls.requires_login:
return True
# if user is somehow not logged in
if not user.is_authenticated:
return False
# attribute permission_required is mandatory, returns tuple
perms = cls.get_permission_required()
# if perms are defined and empty, we skip checking
if not perms:
return True
# get role of user, skip admin role
role = user.urole.role.name
if role == cls.ADMIN:
return True
# check if at least one permissions is valid
for permission in perms:
if cls.check_permission(role, permission):
return True
# permission denied
return False | We override this method to customize the way permissions are checked.
Using our roles to check permissions. | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L887-L917 |
sanoma/django-arctic | arctic/mixins.py | RoleAuthentication.check_permission | def check_permission(cls, role, permission):
"""
Check if role contains permission
"""
result = permission in settings.ARCTIC_ROLES[role]
# will try to call a method with the same name as the permission
# to enable an object level permission check.
if result:
try:
return getattr(cls, permission)(role)
except AttributeError:
pass
return result | python | def check_permission(cls, role, permission):
"""
Check if role contains permission
"""
result = permission in settings.ARCTIC_ROLES[role]
# will try to call a method with the same name as the permission
# to enable an object level permission check.
if result:
try:
return getattr(cls, permission)(role)
except AttributeError:
pass
return result | Check if role contains permission | https://github.com/sanoma/django-arctic/blob/c81b092c2643ca220708bf3c586017d9175161f5/arctic/mixins.py#L920-L932 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.