def __init__(self, client: "EventHubConsumerClient", source: str,
**kwargs) -> None:
super().__init__()
event_position = kwargs.get("event_position", None)
prefetch = kwargs.get("prefetch", 300)
owner_level = kwargs.get("owner_level", None)
keep_alive = kwargs.get("keep_alive", None)
auto_reconnect = kwargs.get("auto_reconnect", True)
track_last_enqueued_event_properties = kwargs.get(
"track_last_enqueued_event_properties", False)
idle_timeout = kwargs.get("idle_timeout", None)
loop = kwargs.get("loop", None)
self.running = False
self.closed = False
self._on_event_received = kwargs[
"on_event_received"] # type: Callable[[EventData], Awaitable[None]]
self._loop = loop or get_running_loop()
self._client = client
self._source = source
self._offset = event_position
self._offset_inclusive = kwargs.get("event_position_inclusive", False)
self._prefetch = prefetch
self._owner_level = owner_level
self._keep_alive = keep_alive
self._auto_reconnect = auto_reconnect
self._retry_policy = errors.ErrorPolicy(
max_retries=self._client._config.max_retries,
on_error=_error_handler # pylint:disable=protected-access
)
self._reconnect_backoff = 1
self._timeout = 0
self._idle_timeout = (idle_timeout * 1000) if idle_timeout else None
self._link_properties = {
} # type: Dict[types.AMQPType, types.AMQPType]
partition = self._source.split("/")[-1]
self._partition = partition
self._name = "EHReceiver-{}-partition{}".format(
uuid.uuid4(), partition)
if owner_level:
self._link_properties[types.AMQPSymbol(
EPOCH_SYMBOL)] = types.AMQPLong(int(owner_level))
link_property_timeout_ms = (
self._client._config.receive_timeout or self._timeout # pylint:disable=protected-access
) * 1000
self._link_properties[types.AMQPSymbol(
TIMEOUT_SYMBOL)] = types.AMQPLong(int(link_property_timeout_ms))
self._handler = None # type: Optional[ReceiveClientAsync]
self._track_last_enqueued_event_properties = (
track_last_enqueued_event_properties)
self._event_queue = queue.Queue()
self._last_received_event = None # type: Optional[EventData]
def __init__(self, eventhub_client, consumer_group_name, on_event,
**kwargs):
self._consumer_group_name = consumer_group_name
self._eventhub_client = eventhub_client
self._namespace = eventhub_client._address.hostname # pylint: disable=protected-access
self._eventhub_name = eventhub_client.eh_name
self._event_handler = on_event
self._partition_id = kwargs.get("partition_id", None)
self._error_handler = kwargs.get("on_error", None)
self._partition_initialize_handler = kwargs.get(
"on_partition_initialize", None)
self._partition_close_handler = kwargs.get("on_partition_close", None)
self._partition_manager = kwargs.get("partition_manager", None)
self._initial_event_position = kwargs.get("initial_event_position",
EventPosition("-1"))
self._polling_interval = kwargs.get("polling_interval", 10.0)
self._ownership_timeout = self._polling_interval * 2
self._partition_contexts = {}
# Receive parameters
self._owner_level = kwargs.get("owner_level", None)
self._prefetch = kwargs.get("prefetch", None)
self._track_last_enqueued_event_properties = kwargs.get(
"track_last_enqueued_event_properties", False)
self._last_enqueued_event_properties = {}
self._id = str(uuid.uuid4())
self._running = False
self._lock = threading.RLock()
# Each partition consumer is working in its own thread
self._working_threads = {} # type: Dict[str, threading.Thread]
self._threads_stop_flags = {} # type: Dict[str, bool]
self._callback_queue = queue.Queue(
maxsize=100) # Right now the limitation of receiving speed is ~10k
def __init__( # pylint: disable=super-init-not-called
self, client, source, **kwargs):
"""
Instantiate an async consumer. EventHubConsumer should be instantiated by calling the `create_consumer` method
in EventHubClient.
:param client: The parent EventHubClientAsync.
:type client: ~azure.eventhub.aio.EventHubClientAsync
:param source: The source EventHub from which to receive events.
:type source: ~uamqp.address.Source
:param event_position: The position from which to start receiving.
:type event_position: ~azure.eventhub.common.EventPosition
:param prefetch: The number of events to prefetch from the service
for processing. Default is 300.
:type prefetch: int
:param owner_level: The priority of the exclusive consumer. An exclusive
consumer will be created if owner_level is set.
:type owner_level: int
:param track_last_enqueued_event_properties: Indicates whether or not the consumer should request information
on the last enqueued event on its associated partition, and track that information as events are received.
When information about the partition's last enqueued event is being tracked, each event received from the
Event Hubs service will carry metadata about the partition. This results in a small amount of additional
network bandwidth consumption that is generally a favorable trade-off when considered against periodically
making requests for partition properties using the Event Hub client.
It is set to `False` by default.
:type track_last_enqueued_event_properties: bool
:param loop: An event loop.
"""
event_position = kwargs.get("event_position", None)
prefetch = kwargs.get("prefetch", 300)
owner_level = kwargs.get("owner_level", None)
keep_alive = kwargs.get("keep_alive", None)
auto_reconnect = kwargs.get("auto_reconnect", True)
track_last_enqueued_event_properties = kwargs.get(
"track_last_enqueued_event_properties", False)
loop = kwargs.get("loop", None)
self.running = False
self.closed = False
self._on_event_received = kwargs.get("on_event_received")
self._loop = loop or asyncio.get_event_loop()
self._client = client
self._source = source
self._offset = event_position
self._prefetch = prefetch
self._owner_level = owner_level
self._keep_alive = keep_alive
self._auto_reconnect = auto_reconnect
self._retry_policy = errors.ErrorPolicy(
max_retries=self._client._config.max_retries,
on_error=_error_handler) # pylint:disable=protected-access
self._reconnect_backoff = 1
self._timeout = 0
self._link_properties = {}
partition = self._source.split('/')[-1]
self._partition = partition
self._name = "EHReceiver-{}-partition{}".format(
uuid.uuid4(), partition)
if owner_level:
self._link_properties[types.AMQPSymbol(
EPOCH_SYMBOL)] = types.AMQPLong(int(owner_level))
link_property_timeout_ms = (self._client._config.receive_timeout
or self._timeout) * 1000 # pylint:disable=protected-access
self._link_properties[types.AMQPSymbol(
TIMEOUT_SYMBOL)] = types.AMQPLong(int(link_property_timeout_ms))
self._handler = None
self._track_last_enqueued_event_properties = track_last_enqueued_event_properties
self._last_enqueued_event_properties = {}
self._event_queue = queue.Queue()
self._last_received_event = None