async def test_receive_with_invalid_param_async(live_eventhub_config,
invalid_place):
eventhub_config = live_eventhub_config.copy()
if invalid_place != "partition":
eventhub_config[invalid_place] = "invalid " + invalid_place
conn_str = live_eventhub_config["connection_str"].format(
eventhub_config['hostname'], eventhub_config['key_name'],
eventhub_config['access_key'], eventhub_config['event_hub'])
client = EventHubConsumerClient.from_connection_string(
conn_str, consumer_group='$default', retry_total=0)
async def on_event(partition_context, event):
pass
async with client:
if invalid_place == "partition":
task = asyncio.ensure_future(
client.receive(on_event,
partition_id=invalid_place,
initial_event_position=EventPosition("-1")))
else:
task = asyncio.ensure_future(
client.receive(on_event,
partition_id="0",
initial_event_position=EventPosition("-1")))
await asyncio.sleep(10)
assert len(client._event_processors) == 1
await task
def test_receive_with_datetime_sync(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str)
partitions = client.get_properties()
assert partitions["partition_ids"] == ["0", "1"]
receiver = client._create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
with receiver:
more_partitions = client.get_properties()
assert more_partitions["partition_ids"] == ["0", "1"]
received = receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
received = receiver.receive(timeout=5)
assert len(received) == 1
offset = received[0].enqueued_time
assert list(received[0].body) == [b'Data']
assert received[0].body_as_str() == "Data"
offset_receiver = client._create_consumer(
consumer_group="$default",
partition_id="0",
event_position=EventPosition(offset))
with offset_receiver:
received = offset_receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Message after timestamp"))
received = offset_receiver.receive(timeout=5)
assert len(received) == 1
client.close()
def test_receive_with_offset_sync(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str,
network_tracing=False)
partitions = client.get_properties()
assert partitions["partition_ids"] == ["0", "1"]
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
with receiver:
more_partitions = client.get_properties()
assert more_partitions["partition_ids"] == ["0", "1"]
received = receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
received = receiver.receive(timeout=5)
assert len(received) == 1
offset = received[0].offset
assert list(received[0].body) == [b'Data']
assert received[0].body_as_str() == "Data"
offset_receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition(
offset, inclusive=False))
with offset_receiver:
received = offset_receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Message after offset"))
received = offset_receiver.receive(timeout=5)
assert len(received) == 1
def test_receive_with_inclusive_offset(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
with receiver:
received = receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
time.sleep(1)
received = receiver.receive(timeout=5)
assert len(received) == 1
offset = received[0].offset
assert list(received[0].body) == [b'Data']
assert received[0].body_as_str() == "Data"
offset_receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition(
offset, inclusive=True))
with offset_receiver:
received = offset_receiver.receive(timeout=5)
assert len(received) == 1
async def test_exclusive_receiver_after_non_exclusive_receiver_async(
connstr_senders):
connection_str, senders = connstr_senders
senders[0].send(EventData(b"Receiving only a single event"))
client = EventHubClient.from_connection_string(connection_str)
receiver1 = client._create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"),
prefetch=10)
receiver2 = client._create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"),
owner_level=15,
prefetch=10)
try:
await pump(receiver1)
output2 = await pump(receiver2)
with pytest.raises(ConnectionLostError):
await receiver1.receive(timeout=3)
assert output2 == 1
finally:
await receiver1.close()
await receiver2.close()
await client.close()
async def __anext__(self):
retried_times = 0
last_exception = None
while retried_times < self._client._config.max_retries: # pylint:disable=protected-access
try:
await self._open()
if not self._messages_iter:
self._messages_iter = self._handler.receive_messages_iter_async(
)
message = await self._messages_iter.__anext__()
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 = await self._handle_exception(exception)
await 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
async def test_receive_with_offset_async(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
async with receiver:
received = await receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
time.sleep(1)
received = await receiver.receive(timeout=3)
assert len(received) == 1
offset = received[0].offset
offset_receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition(
offset, inclusive=False))
async with offset_receiver:
received = await offset_receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Message after offset"))
received = await offset_receiver.receive(timeout=5)
assert len(received) == 1
def test_receive_with_sequence_no(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
with receiver:
received = receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
time.sleep(1)
received = receiver.receive(timeout=5)
assert len(received) == 1
offset = received[0].sequence_number
offset_receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition(
offset, False))
with offset_receiver:
received = offset_receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Message next in sequence"))
time.sleep(1)
received = offset_receiver.receive(timeout=5)
assert len(received) == 1
async def _receive(self, timeout_time=None, max_batch_size=None, **kwargs):
last_exception = kwargs.get("last_exception")
data_batch = []
await 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 = await self._handler.receive_message_batch_async(
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
async def test_receive_with_datetime_async(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str)
receiver = client._create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'))
async with receiver:
received = await receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Data"))
received = await receiver.receive(timeout=5)
assert len(received) == 1
offset = received[0].enqueued_time
offset_receiver = client._create_consumer(
consumer_group="$default",
partition_id="0",
event_position=EventPosition(offset))
async with offset_receiver:
received = await offset_receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(EventData(b"Message after timestamp"))
time.sleep(1)
received = await offset_receiver.receive(timeout=5)
assert len(received) == 1
await client.close()
def get_init_event_position(self, partition_id, checkpoint):
checkpoint_offset = checkpoint.get("offset") if checkpoint else None
if checkpoint_offset:
initial_event_position = EventPosition(checkpoint_offset)
elif isinstance(self._initial_event_position, EventPosition):
initial_event_position = self._initial_event_position
elif isinstance(self._initial_event_position, dict):
initial_event_position = self._initial_event_position.get(
partition_id, EventPosition("-1"))
else:
initial_event_position = EventPosition(
self._initial_event_position)
return initial_event_position
async def test_receive_over_websocket_async(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(
connection_str,
transport_type=TransportType.AmqpOverWebsocket,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition('@latest'),
prefetch=500)
event_list = []
for i in range(20):
event_list.append(EventData("Event Number {}".format(i)))
async with receiver:
received = await receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(event_list)
time.sleep(1)
received = await receiver.receive(max_batch_size=50, timeout=5)
assert len(received) == 20
async def open_clients_async(self):
"""
Responsible for establishing connection to event hub client
throws EventHubsException, IOException, InterruptedException, ExecutionException.
"""
await self.partition_context.get_initial_offset_async()
# Create event hub client and receive handler and set options
hostname = "{}.{}".format(self.host.eh_config.sb_name,
self.host.eh_config.namespace_suffix)
event_hub_path = self.host.eh_config.eh_name
shared_key_cred = EventHubSharedKeyCredential(
self.host.eh_config.policy, self.host.eh_config.sas_key)
self.eh_client = EventHubClient(
hostname,
event_hub_path,
shared_key_cred,
network_tracing=self.host.eph_options.debug_trace,
http_proxy=self.host.eph_options.http_proxy)
self.partition_receive_handler = self.eh_client.create_consumer(
partition_id=self.partition_context.partition_id,
consumer_group=self.partition_context.consumer_group_name,
event_position=EventPosition(self.partition_context.offset),
prefetch=self.host.eph_options.prefetch_count,
loop=self.loop)
self.partition_receiver = PartitionReceiver(self)
def __init__(
self, eventhub_client, consumer_group_name: str,
event_handler: Callable[[PartitionContext, List[EventData]], None],
*,
partition_id: str = None,
partition_manager: PartitionManager = None,
initial_event_position=EventPosition("-1"), polling_interval: float = 10.0,
owner_level=None, prefetch=None, track_last_enqueued_event_properties=False,
error_handler,
partition_initialize_handler,
partition_close_handler
):
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._partition_id = partition_id
self._event_handler = event_handler
self._error_handler = error_handler
self._partition_initialize_handler = partition_initialize_handler
self._partition_close_handler = partition_close_handler
self._partition_manager = partition_manager
self._initial_event_position = initial_event_position # will be replaced by reset event position in preview 4
self._polling_interval = polling_interval
self._ownership_timeout = self._polling_interval * 2
self._tasks = {} # type: Dict[str, asyncio.Task]
self._partition_contexts = {} # type: Dict[str, PartitionContext]
self._owner_level = owner_level
self._prefetch = prefetch
self._track_last_enqueued_event_properties = track_last_enqueued_event_properties
self._last_enqueued_event_properties = {} # type: Dict[str, Dict[str, Any]]
self._id = str(uuid.uuid4())
self._running = False
self._consumers = {}
async def run_async(self):
method_name = self.args.method
logger = get_logger("{}.log".format(method_name),
method_name,
level=logging.INFO,
print_console=self.args.print_console)
test_method = globals()[method_name]
client = self.create_client(EventHubClientAsync)
self.running = True
if self.args.partitions.lower() != "all":
partitions = self.args.partitions.split(",")
else:
partitions = await client.get_partition_ids()
tasks = []
for pid in partitions:
if "receive" in method_name:
worker = client.create_consumer(
consumer_group=self.args.consumer,
partition_id=pid,
event_position=EventPosition(self.args.offset),
prefetch=300)
else: # "send" in method_name
worker = client.create_producer(partition_id=pid)
task = self.run_test_method_async(test_method, worker, logger)
tasks.append(task)
await asyncio.gather(*tasks)
def test_client_secret_credential(aad_credential, live_eventhub):
try:
from azure.identity import ClientSecretCredential
except ImportError:
pytest.skip("No azure identity library")
client_id, secret, tenant_id = aad_credential
credential = ClientSecretCredential(client_id=client_id,
secret=secret,
tenant_id=tenant_id)
client = EventHubClient(host=live_eventhub['hostname'],
event_hub_path=live_eventhub['event_hub'],
credential=credential,
user_agent='customized information')
sender = client.create_producer(partition_id='0')
receiver = client.create_consumer(consumer_group="$default",
partition_id='0',
event_position=EventPosition("@latest"))
with receiver:
received = receiver.receive(timeout=1)
assert len(received) == 0
with sender:
event = EventData(body='A single message')
sender.send(event)
time.sleep(1)
received = receiver.receive(timeout=1)
assert len(received) == 1
assert list(received[0].body)[0] == 'A single message'.encode('utf-8')
def test_receive_with_custom_datetime_sync(connstr_senders):
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str,
network_tracing=False)
for i in range(5):
senders[0].send(EventData(b"Message before timestamp"))
time.sleep(65)
now = datetime.datetime.utcnow()
offset = datetime.datetime(now.year, now.month, now.day, now.hour,
now.minute)
for i in range(5):
senders[0].send(EventData(b"Message after timestamp"))
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition(offset))
with receiver:
all_received = []
received = receiver.receive(timeout=1)
while received:
all_received.extend(received)
received = receiver.receive(timeout=1)
assert len(all_received) == 5
for received_event in all_received:
assert received_event.body_as_str() == "Message after timestamp"
assert received_event.enqueued_time > offset
def getEvents(lastOffset):
try:
client = EventHubClient.from_connection_string(cfg.connection_str)
EVENT_POSITION = EventPosition(lastOffset)
#for a vanilla eventhub replace "custom" consumer_group by "$default"
consumer = client.create_consumer(consumer_group="custom", partition_id=PARTITION, event_position=EVENT_POSITION, prefetch=100000)
total=0
last_offset = -1
with consumer:
batched_events = consumer.receive(max_batch_size=100000)
for event_data in batched_events:
last_offset = event_data.offset
last_sn = event_data.sequence_number
total += 1
print("Partition {}, Received {}, sn={} offset={}".format(
PARTITION,
total,
last_sn,
last_offset))
print (event_data)
getEvents(last_offset)
client.stop()
except:
print('got all events for now')
finally:
print('got all events for now')
client.stop()
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()
self._consumers = {}
def send_and_receive_events(self, partitionID):
with self.client.create_consumer(
consumer_group="$default",
partition_id=partitionID,
event_position=EventPosition(datetime.utcnow()),
) as consumer:
print("Sending events...")
with self.client.create_producer(
partition_id=partitionID) as producer:
event_list = [
EventData(b"Test Event 1 in Python"),
EventData(b"Test Event 2 in Python"),
EventData(b"Test Event 3 in Python"),
]
producer.send(event_list)
print("\tdone")
print("Receiving events...")
received = consumer.receive(max_batch_size=len(event_list),
timeout=3)
for event_data in received:
print("\tEvent Received: " + event_data.body_as_str())
print("\tdone")
if len(received) != len(event_list):
raise Exception(
"Error, expecting {0} events, but {1} were received.".
format(str(len(event_list)), str(len(received))))
def run_sync(self):
method_name = self.args.method
logger = get_logger("{}.log".format(method_name),
method_name,
level=logging.INFO,
print_console=self.args.print_console)
test_method = globals()[method_name]
client = self.create_client(EventHubClient)
self.running = True
if self.args.partitions.lower() != "all":
partitions = self.args.partitions.split(",")
else:
partitions = client.get_partition_ids()
threads = []
for pid in partitions:
if "receive" in method_name:
worker = client.create_consumer(
consumer_group=self.args.consumer,
partition_id=pid,
event_position=EventPosition(self.args.offset),
prefetch=300)
else: # "send" in method_name
worker = client.create_producer(partition_id=pid)
thread = threading.Thread(target=self.run_test_method,
args=(test_method, worker, logger))
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
def _from_iothub_connection_string(cls, conn_str, **kwargs):
address, policy, key, _ = _parse_conn_str(conn_str)
hub_name = address.split('.')[0]
username = "******".format(policy, hub_name)
password = _generate_sas_token(address, policy, key)
left_slash_pos = address.find("//")
if left_slash_pos != -1:
host = address[left_slash_pos + 2:]
else:
host = address
client = cls(host, "", EventHubSharedKeyCredential(username, password),
**kwargs)
client._auth_config = { # pylint: disable=protected-access
'iot_username': policy,
'iot_password': key,
'username': username,
'password': password
}
client._is_iothub = True # pylint: disable=protected-access
client._redirect_consumer = client.create_consumer(
consumer_group='$default', # pylint: disable=protected-access, no-member
partition_id='0',
event_position=EventPosition('-1'),
operation='/messages/events')
return client
async def test_multiple_receiver_async(connstr_senders):
connection_str, senders = connstr_senders
senders[0].send(EventData(b"Receiving only a single event"))
client = EventHubClient.from_connection_string(connection_str)
partitions = await client.get_properties()
assert partitions["partition_ids"] == ["0", "1"]
receivers = []
for i in range(2):
receivers.append(
client._create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"),
prefetch=10))
try:
more_partitions = await client.get_properties()
assert more_partitions["partition_ids"] == ["0", "1"]
outputs = [0, 0]
outputs[0] = await pump(receivers[0])
outputs[1] = await pump(receivers[1])
assert isinstance(outputs[0], int) and outputs[0] == 1
assert isinstance(outputs[1], int) and outputs[1] == 1
finally:
for r in receivers:
await r.close()
await client.close()
async def test_receive_run_time_metric_async(connstr_senders):
from uamqp import __version__ as uamqp_version
from distutils.version import StrictVersion
if StrictVersion(uamqp_version) < StrictVersion('1.2.3'):
pytest.skip("Disabled for uamqp 1.2.2. Will enable after uamqp 1.2.3 is released.")
connection_str, senders = connstr_senders
client = EventHubClient.from_connection_string(connection_str, transport_type=TransportType.AmqpOverWebsocket,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default", partition_id="0",
event_position=EventPosition('@latest'), prefetch=500,
track_last_enqueued_event_properties=True)
event_list = []
for i in range(20):
event_list.append(EventData("Event Number {}".format(i)))
async with receiver:
received = await receiver.receive(timeout=5)
assert len(received) == 0
senders[0].send(event_list)
await asyncio.sleep(1)
received = await receiver.receive(max_batch_size=50, timeout=5)
assert len(received) == 20
assert receiver.last_enqueued_event_properties
assert receiver.last_enqueued_event_properties.get('sequence_number', None)
assert receiver.last_enqueued_event_properties.get('offset', None)
assert receiver.last_enqueued_event_properties.get('enqueued_time', None)
assert receiver.last_enqueued_event_properties.get('retrieval_time', None)
async def test_receive_with_invalid_policy_async(invalid_policy):
client = EventHubClient.from_connection_string(invalid_policy,
network_tracing=False)
sender = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"))
with pytest.raises(AuthenticationError):
await sender._open()
async def test_long_running_receive_async(connection_str):
parser = argparse.ArgumentParser()
parser.add_argument("--duration",
help="Duration in seconds of the test",
type=int,
default=30)
parser.add_argument("--consumer",
help="Consumer group name",
default="$default")
parser.add_argument("--partitions", help="Comma seperated partition IDs")
parser.add_argument("--offset", help="Starting offset", default="-1")
parser.add_argument("--conn-str",
help="EventHub connection string",
default=connection_str)
parser.add_argument("--eventhub", help="Name of EventHub")
parser.add_argument("--address", help="Address URI to the EventHub entity")
parser.add_argument(
"--sas-policy",
help="Name of the shared access policy to authenticate with")
parser.add_argument("--sas-key", help="Shared access key")
loop = asyncio.get_event_loop()
args, _ = parser.parse_known_args()
if args.conn_str:
client = EventHubClient.from_connection_string(
args.conn_str,
event_hub_path=args.eventhub,
auth_timeout=240,
network_tracing=False)
elif args.address:
client = EventHubClient(host=args.address,
event_hub_path=args.eventhub,
credential=EventHubSharedKeyCredential(
args.sas_policy, args.sas_key),
auth_timeout=240,
network_tracing=False)
else:
try:
import pytest
pytest.skip("Must specify either '--conn-str' or '--address'")
except ImportError:
raise ValueError("Must specify either '--conn-str' or '--address'")
if not args.partitions:
partitions = await client.get_partition_ids()
else:
partitions = args.partitions.split(",")
pumps = []
for pid in partitions:
receiver = client.create_consumer(consumer_group="$default",
partition_id=pid,
event_position=EventPosition(
args.offset),
prefetch=300,
loop=loop)
pumps.append(pump(pid, receiver, args, args.duration))
await asyncio.gather(*pumps)
def test_receive_with_event_position_sync(connstr_senders, position, inclusive,
expected_result):
def on_event(partition_context, event):
assert event.last_enqueued_event_properties.get(
'sequence_number') == event.sequence_number
assert event.last_enqueued_event_properties.get(
'offset') == event.offset
assert event.last_enqueued_event_properties.get(
'enqueued_time') == event.enqueued_time
assert event.last_enqueued_event_properties.get(
'retrieval_time') is not None
if position == "offset":
on_event.event_position = event.offset
elif position == "sequence":
on_event.event_position = event.sequence_number
else:
on_event.event_position = event.enqueued_time
on_event.event = event
on_event.event_position = None
connection_str, senders = connstr_senders
senders[0].send(EventData(b"Inclusive"))
senders[1].send(EventData(b"Inclusive"))
client = EventHubConsumerClient.from_connection_string(
connection_str, consumer_group='$default')
with client:
thread = threading.Thread(target=client.receive,
args=(on_event, ),
kwargs={
"initial_event_position": "-1",
"track_last_enqueued_event_properties":
True
})
thread.daemon = True
thread.start()
time.sleep(10)
assert on_event.event_position is not None
thread.join()
senders[0].send(EventData(expected_result))
senders[1].send(EventData(expected_result))
client2 = EventHubConsumerClient.from_connection_string(
connection_str, consumer_group='$default')
with client2:
thread = threading.Thread(target=client2.receive,
args=(on_event, ),
kwargs={
"initial_event_position":
EventPosition(on_event.event_position,
inclusive),
"track_last_enqueued_event_properties":
True
})
thread.daemon = True
thread.start()
time.sleep(10)
assert on_event.event.body_as_str() == expected_result
thread.join()
async def __anext__(self):
max_retries = self.client.config.max_retries
retry_count = 0
while True:
try:
await self._open()
if not self.messages_iter:
self.messages_iter = self._handler.receive_messages_iter_async(
)
message = await self.messages_iter.__anext__()
event_data = EventData._from_message(message)
self.offset = EventPosition(event_data.offset, inclusive=False)
retry_count = 0
return event_data
except Exception as exception:
await self._handle_exception(exception, retry_count,
max_retries)
retry_count += 1
async def test_receive_with_invalid_key_async(invalid_key):
client = EventHubClient.from_connection_string(invalid_key,
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"))
with pytest.raises(AuthenticationError):
await receiver.receive(timeout=3)
await receiver.close()
async def test_non_existing_entity_receiver_async(connection_str):
client = EventHubClient.from_connection_string(connection_str,
event_hub_path="nemo",
network_tracing=False)
receiver = client.create_consumer(consumer_group="$default",
partition_id="0",
event_position=EventPosition("-1"))
with pytest.raises(AuthenticationError):
await receiver._open()
