def receive(self, max_batch_size=None, timeout=None):
"""
Receive events from the EventHub.
:param max_batch_size: Receive a batch of events. Batch size will
be up to the maximum specified, but will return as soon as service
returns no new events. If combined with a timeout and no events are
retrieve before the time, the result will be empty. If no batch
size is supplied, the prefetch size will be the maximum.
:type max_batch_size: int
:rtype: list[~azure.eventhub.common.EventData]
"""
if self.error:
raise self.error
try:
timeout_ms = 1000 * timeout if timeout else 0
message_batch = self._handler.receive_message_batch(
max_batch_size=max_batch_size, timeout=timeout_ms)
data_batch = []
for message in message_batch:
event_data = EventData(message=message)
self.offset = event_data.offset
data_batch.append(event_data)
return data_batch
except errors.LinkDetach as detach:
error = EventHubError(str(detach))
self.close(exception=error)
raise error
except Exception as e:
error = EventHubError("Receive failed: {}".format(e))
self.close(exception=error)
raise error
def _receive(self, timeout_time=None, max_batch_size=None, **kwargs):
last_exception = kwargs.get("last_exception")
data_batch = []
self._open()
remaining_time = timeout_time - time.time()
if remaining_time <= 0.0:
if last_exception:
log.info("%r receive operation timed out. (%r)", self._name,
last_exception)
raise last_exception
return data_batch
remaining_time_ms = 1000 * remaining_time
message_batch = self._handler.receive_message_batch(
max_batch_size=max_batch_size, timeout=remaining_time_ms)
for message in message_batch:
event_data = EventData._from_message(message) # pylint:disable=protected-access
data_batch.append(event_data)
event_data._trace_link_message() # pylint:disable=protected-access
if data_batch:
self._offset = EventPosition(data_batch[-1].offset)
if self._track_last_enqueued_event_properties and data_batch:
self._last_enqueued_event_properties = data_batch[
-1]._get_last_enqueued_event_properties() # pylint:disable=protected-access
return data_batch
def __next__(self):
retried_times = 0
last_exception = None
while retried_times < self._client._config.max_retries: # pylint:disable=protected-access
try:
self._open()
if not self._messages_iter:
self._messages_iter = self._handler.receive_messages_iter()
message = next(self._messages_iter)
event_data = EventData._from_message(message) # pylint:disable=protected-access
event_data._trace_link_message() # pylint:disable=protected-access
self._offset = EventPosition(event_data.offset,
inclusive=False)
retried_times = 0
if self._track_last_enqueued_event_properties:
self._last_enqueued_event_properties = event_data._get_last_enqueued_event_properties(
) # pylint:disable=protected-access
return event_data
except Exception as exception: # pylint:disable=broad-except
last_exception = self._handle_exception(exception)
self._client._try_delay(
retried_times=retried_times,
last_exception=last_exception, # pylint:disable=protected-access
entity_name=self._name)
retried_times += 1
log.info("%r operation has exhausted retry. Last exception: %r.",
self._name, last_exception)
raise last_exception
def receive(self, max_batch_size=None, timeout=None):
"""
Receive events from the EventHub.
:param max_batch_size: Receive a batch of events. Batch size will
be up to the maximum specified, but will return as soon as service
returns no new events. If combined with a timeout and no events are
retrieve before the time, the result will be empty. If no batch
size is supplied, the prefetch size will be the maximum.
:type max_batch_size: int
:rtype: list[~azure.eventhub.common.EventData]
"""
if self.error:
raise self.error
if not self.running:
raise ValueError("Unable to receive until client has been started.")
data_batch = []
try:
timeout_ms = 1000 * timeout if timeout else 0
message_batch = self._handler.receive_message_batch(
max_batch_size=max_batch_size,
timeout=timeout_ms)
for message in message_batch:
event_data = EventData(message=message)
self.offset = event_data.offset
data_batch.append(event_data)
return data_batch
except (errors.TokenExpired, errors.AuthenticationException):
log.info("Receiver disconnected due to token error. Attempting reconnect.")
self.reconnect()
return data_batch
except (errors.LinkDetach, errors.ConnectionClose) as shutdown:
if shutdown.action.retry and self.auto_reconnect:
log.info("Receiver detached. Attempting reconnect.")
self.reconnect()
return data_batch
log.info("Receiver detached. Shutting down.")
error = EventHubError(str(shutdown), shutdown)
self.close(exception=error)
raise error
except errors.MessageHandlerError as shutdown:
if self.auto_reconnect:
log.info("Receiver detached. Attempting reconnect.")
self.reconnect()
return data_batch
log.info("Receiver detached. Shutting down.")
error = EventHubError(str(shutdown), shutdown)
self.close(exception=error)
raise error
except Exception as e:
log.info("Unexpected error occurred (%r). Shutting down.", e)
error = EventHubError("Receive failed: {}".format(e))
self.close(exception=error)
raise error
def __next__(self):
max_retries = self.client.config.max_retries
retry_count = 0
while True:
try:
self._open()
if not self.messages_iter:
self.messages_iter = self._handler.receive_messages_iter()
message = next(self.messages_iter)
event_data = EventData._from_message(message)
self.offset = EventPosition(event_data.offset, inclusive=False)
retry_count = 0
return event_data
except Exception as exception:
self._handle_exception(exception, retry_count, max_retries)
retry_count += 1
def __next__(self):
max_retries = self.client.config.max_retries
retry_count = 0
while True:
try:
self._open()
if not self.messages_iter:
self.messages_iter = self._handler.receive_messages_iter()
message = next(self.messages_iter)
event_data = EventData._from_message(message) # pylint:disable=protected-access
self.offset = EventPosition(event_data.offset, inclusive=False)
retry_count = 0
return event_data
except Exception as exception: # pylint:disable=broad-except
self._handle_exception(exception,
retry_count,
max_retries,
timeout_time=None)
retry_count += 1
def _receive(self, timeout_time=None, max_batch_size=None, **kwargs):
last_exception = kwargs.get("last_exception")
data_batch = kwargs.get("data_batch")
self._open(timeout_time)
remaining_time = timeout_time - time.time()
if remaining_time <= 0.0:
if last_exception:
log.info("%r receive operation timed out. (%r)", self.name,
last_exception)
raise last_exception
return data_batch
remaining_time_ms = 1000 * remaining_time
message_batch = self._handler.receive_message_batch(
max_batch_size=max_batch_size -
(len(data_batch) if data_batch else 0),
timeout=remaining_time_ms)
for message in message_batch:
event_data = EventData._from_message(message) # pylint:disable=protected-access
self.offset = EventPosition(event_data.offset)
data_batch.append(event_data)
return data_batch
def receive(self, max_batch_size=None, timeout=None):
# type:(int, float) -> List[EventData]
"""
Receive events from the EventHub.
:param max_batch_size: Receive a batch of events. Batch size will
be up to the maximum specified, but will return as soon as service
returns no new events. If combined with a timeout and no events are
retrieve before the time, the result will be empty. If no batch
size is supplied, the prefetch size will be the maximum.
:type max_batch_size: int
:param timeout: The maximum wait time to build up the requested message count for the batch.
If not specified, the default wait time specified when the consumer was created will be used.
:type timeout: float
:rtype: list[~azure.eventhub.common.EventData]
:raises: ~azure.eventhub.AuthenticationError, ~azure.eventhub.ConnectError, ~azure.eventhub.ConnectionLostError,
~azure.eventhub.EventHubError
Example:
.. literalinclude:: ../examples/test_examples_eventhub.py
:start-after: [START eventhub_client_sync_receive]
:end-before: [END eventhub_client_sync_receive]
:language: python
:dedent: 4
:caption: Receive events from the EventHub.
"""
self._check_closed()
self._open()
max_batch_size = min(
self.client.config.max_batch_size,
self.prefetch) if max_batch_size is None else max_batch_size
timeout = self.client.config.receive_timeout if timeout is None else timeout
data_batch = [] # type: List[EventData]
max_retries = self.client.config.max_retries
connecting_count = 0
while True:
connecting_count += 1
try:
timeout_ms = 1000 * timeout if timeout else 0
message_batch = self._handler.receive_message_batch(
max_batch_size=max_batch_size -
(len(data_batch) if data_batch else 0),
timeout=timeout_ms)
for message in message_batch:
event_data = EventData(message=message)
self.offset = EventPosition(event_data.offset)
data_batch.append(event_data)
return data_batch
except errors.AuthenticationException as auth_error:
if connecting_count < max_retries:
log.info(
"EventHubConsumer disconnected due to token error. Attempting reconnect."
)
self._reconnect()
else:
log.info(
"EventHubConsumer authentication failed. Shutting down."
)
error = AuthenticationError(str(auth_error), auth_error)
self.close(auth_error)
raise error
except (errors.LinkDetach, errors.ConnectionClose) as shutdown:
if shutdown.action.retry and self.auto_reconnect:
log.info(
"EventHubConsumer detached. Attempting reconnect.")
self._reconnect()
else:
log.info("EventHubConsumer detached. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(exception=error)
raise error
except errors.MessageHandlerError as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer detached. Attempting reconnect.")
self._reconnect()
else:
log.info("EventHubConsumer detached. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(error)
raise error
except errors.AMQPConnectionError as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer connection lost. Attempting reconnect."
)
self._reconnect()
else:
log.info(
"EventHubConsumer connection lost. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(error)
raise error
except compat.TimeoutException as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer timed out receiving event data. Attempting reconnect."
)
self._reconnect()
else:
log.info("EventHubConsumer timed out. Shutting down.")
self.close(shutdown)
raise ConnectionLostError(str(shutdown), shutdown)
except KeyboardInterrupt:
log.info("EventHubConsumer stops due to keyboard interrupt")
self.close()
raise
except Exception as e:
log.error("Unexpected error occurred (%r). Shutting down.", e)
error = EventHubError("Receive failed: {}".format(e), e)
self.close(exception=error)
raise error
def __next__(self):
self._open()
max_retries = self.client.config.max_retries
connecting_count = 0
while True:
connecting_count += 1
try:
if not self.messages_iter:
self.messages_iter = self._handler.receive_messages_iter()
message = next(self.messages_iter)
event_data = EventData(message=message)
self.offset = EventPosition(event_data.offset, inclusive=False)
return event_data
except errors.AuthenticationException as auth_error:
if connecting_count < max_retries:
log.info(
"EventHubConsumer disconnected due to token error. Attempting reconnect."
)
self._reconnect()
else:
log.info(
"EventHubConsumer authentication failed. Shutting down."
)
error = AuthenticationError(str(auth_error), auth_error)
self.close(auth_error)
raise error
except (errors.LinkDetach, errors.ConnectionClose) as shutdown:
if shutdown.action.retry and self.auto_reconnect:
log.info(
"EventHubConsumer detached. Attempting reconnect.")
self._reconnect()
else:
log.info("EventHubConsumer detached. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(exception=error)
raise error
except errors.MessageHandlerError as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer detached. Attempting reconnect.")
self._reconnect()
else:
log.info("EventHubConsumer detached. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(error)
raise error
except errors.AMQPConnectionError as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer connection lost. Attempting reconnect."
)
self._reconnect()
else:
log.info(
"EventHubConsumer connection lost. Shutting down.")
error = ConnectionLostError(str(shutdown), shutdown)
self.close(error)
raise error
except compat.TimeoutException as shutdown:
if connecting_count < max_retries:
log.info(
"EventHubConsumer timed out receiving event data. Attempting reconnect."
)
self._reconnect()
else:
log.info("EventHubConsumer timed out. Shutting down.")
self.close(shutdown)
raise ConnectionLostError(str(shutdown), shutdown)
except StopIteration:
raise
except KeyboardInterrupt:
log.info("EventHubConsumer stops due to keyboard interrupt")
self.close()
raise
except Exception as e:
log.error("Unexpected error occurred (%r). Shutting down.", e)
error = EventHubError("Receive failed: {}".format(e), e)
self.close(exception=error)
raise error