async def test_client_azure_sas_credential_async(live_eventhub): # This should "just work" to validate known-good. hostname = live_eventhub['hostname'] producer_client = EventHubProducerClient.from_connection_string( live_eventhub['connection_str'], eventhub_name=live_eventhub['event_hub']) async with producer_client: batch = await producer_client.create_batch(partition_id='0') batch.add(EventData(body='A single message')) await producer_client.send_batch(batch) credential = EventHubSharedKeyCredential(live_eventhub['key_name'], live_eventhub['access_key']) auth_uri = "sb://{}/{}".format(hostname, live_eventhub['event_hub']) token = (await credential.get_token(auth_uri)).token.decode() producer_client = EventHubProducerClient( fully_qualified_namespace=hostname, eventhub_name=live_eventhub['event_hub'], credential=AzureSasCredential(token)) async with producer_client: batch = await producer_client.create_batch(partition_id='0') batch.add(EventData(body='A single message')) await producer_client.send_batch(batch)
def _get_client(self): """Get a Event Producer Client.""" if self._conn_str_client: return EventHubProducerClient.from_connection_string( **self._client_args, **ADDITIONAL_ARGS ) return EventHubProducerClient(**self._client_args, **ADDITIONAL_ARGS)
def create_async_eventhub_producer_client(): # [START create_eventhub_producer_client_from_conn_str_async] import os from azure.eventhub.aio import EventHubProducerClient event_hub_connection_str = os.environ['EVENT_HUB_CONN_STR'] event_hub = os.environ['EVENT_HUB_NAME'] producer = EventHubProducerClient.from_connection_string(conn_str=event_hub_connection_str, event_hub_path=event_hub) # [END create_eventhub_producer_client_from_conn_str_async] # [START create_eventhub_producer_client_async] import os from azure.eventhub import EventHubSharedKeyCredential from azure.eventhub.aio import EventHubProducerClient hostname = os.environ['EVENT_HUB_HOSTNAME'] event_hub = os.environ['EVENT_HUB_NAME'] shared_access_policy = os.environ['EVENT_HUB_SAS_POLICY'] shared_access_key = os.environ['EVENT_HUB_SAS_KEY'] producer = EventHubProducerClient(host=hostname, event_hub_path=event_hub, credential=EventHubSharedKeyCredential(shared_access_policy, shared_access_key)) # [END create_eventhub_producer_client_async] return producer
def example_create_async_eventhub_producer_client(): # [START create_eventhub_producer_client_from_conn_str_async] import os from azure.eventhub.aio import EventHubProducerClient event_hub_connection_str = os.environ['EVENT_HUB_CONN_STR'] eventhub_name = os.environ['EVENT_HUB_NAME'] producer = EventHubProducerClient.from_connection_string( conn_str=event_hub_connection_str, eventhub_name= eventhub_name # EventHub name should be specified if it doesn't show up in connection string. ) # [END create_eventhub_producer_client_from_conn_str_async] # [START create_eventhub_producer_client_async] import os from azure.eventhub.aio import EventHubProducerClient, EventHubSharedKeyCredential fully_qualified_namespace = os.environ['EVENT_HUB_HOSTNAME'] eventhub_name = os.environ['EVENT_HUB_NAME'] shared_access_policy = os.environ['EVENT_HUB_SAS_POLICY'] shared_access_key = os.environ['EVENT_HUB_SAS_KEY'] producer = EventHubProducerClient( fully_qualified_namespace=fully_qualified_namespace, eventhub_name=eventhub_name, credential=EventHubSharedKeyCredential(shared_access_policy, shared_access_key)) # [END create_eventhub_producer_client_async] return producer
async def test_client_azure_sas_credential_async( self, eventhub, eventhub_namespace, eventhub_namespace_key_name, eventhub_namespace_primary_key, eventhub_namespace_connection_string, **kwargs): # This should "just work" to validate known-good. hostname = "{}.servicebus.windows.net".format(eventhub_namespace.name) producer_client = EventHubProducerClient.from_connection_string( eventhub_namespace_connection_string, eventhub_name=eventhub.name) async with producer_client: batch = await producer_client.create_batch(partition_id='0') batch.add(EventData(body='A single message')) await producer_client.send_batch(batch) hostname = "{}.servicebus.windows.net".format(eventhub_namespace.name) auth_uri = "sb://{}/{}".format(hostname, eventhub.name) token = (await credential.get_token(auth_uri)).token producer_client = EventHubProducerClient( fully_qualified_namespace=hostname, eventhub_name=eventhub.name, credential=AzureSasCredential(token)) async with producer_client: batch = await producer_client.create_batch(partition_id='0') batch.add(EventData(body='A single message')) await producer_client.send_batch(batch)
async def _run(params): """ Runs the application. Args: params: A dictionary containing the following: connection_string: The event hub namespace connection string. name: The event hub name. interval: The number of seconds to wait between message sends. what_if: When true does not send the message to the event hub. Instead it prints what would have been sent. """ producer = EventHubProducerClient.from_connection_string( params["connection_string"], eventhub_name=params["name"]) async with producer: for index in count(1000): event_data = _create_event_data(index) if params["what_if"]: print(event_data) else: await _send_message(producer, event_data) _print_send_status(event_data) time.sleep(params["interval"])
async def accummulate(self): producer = EventHubProducerClient.from_connection_string(conn_str=self._config['Azure']['ConneStringEventHub'],\ eventhub_name=self._config['Azure']['eventhub_name']) async with producer: event_data_batch = await producer.create_batch() event_data_batch.add(EventData(self._json_data)) await producer.send_batch(event_data_batch)
async def test_send_batch_pid_pk_async(invalid_hostname, partition_id, partition_key): # Use invalid_hostname because this is not a live test. client = EventHubProducerClient.from_connection_string(invalid_hostname) batch = EventDataBatch(partition_id=partition_id, partition_key=partition_key) async with client: with pytest.raises(TypeError): await client.send_batch(batch, partition_id=partition_id, partition_key=partition_key)
async def test_client_secret_credential_async(aad_credential, live_eventhub): try: from azure.identity.aio import EnvironmentCredential except ImportError: pytest.skip("No azure identity library") credential = EnvironmentCredential() producer_client = EventHubProducerClient(host=live_eventhub['hostname'], event_hub_path=live_eventhub['event_hub'], credential=credential, user_agent='customized information') consumer_client = EventHubConsumerClient(host=live_eventhub['hostname'], event_hub_path=live_eventhub['event_hub'], credential=credential, user_agent='customized information') async with producer_client: await producer_client.send(EventData(body='A single message')) async def event_handler(partition_context, events): assert partition_context.partition_id == '0' assert len(events) == 1 assert list(events[0].body)[0] == 'A single message'.encode('utf-8') async with consumer_client: task = asyncio.ensure_future( consumer_client.receive(event_handler=event_handler, consumer_group='$default', partition_id='0')) await asyncio.sleep(2) task.cancel()
def client(self) -> EventHubProducerClient: """Return the client.""" return EventHubProducerClient.from_connection_string( conn_str=self.event_hub_connection_string, eventhub_name=self.event_hub_instance_name, **ADDITIONAL_ARGS, )
async def main(): # Create an Azure blob checkpoint store to store the checkpoints. checkpoint_store = BlobCheckpointStore.from_connection_string(checkpoint_conn_str, checkpoint_container_name) # Create a consumer client for the event hub. client = EventHubConsumerClient.from_connection_string(conn_str, consumer_group="$Default", eventhub_name=event_hub_name, checkpoint_store=checkpoint_store) client_future = client.receive(on_event=on_event, starting_position=-1) print('client is listening') producer = EventHubProducerClient.from_connection_string(conn_str=conn_str, eventhub_name=event_hub_name) async with producer: # Create a batch. event_data_batch = await producer.create_batch() # Add events to the batch. event_data_batch.add(EventData('First event ')) event_data_batch.add(EventData('Second event')) event_data_batch.add(EventData('Third event')) # Send the batch of events to the event hub. await producer.send_batch(event_data_batch) print('sent events') await client_future
async def example_eventhub_async_producer_send_and_close(): # [START eventhub_producer_client_close_async] import os from azure.eventhub.aio import EventHubProducerClient from azure.eventhub import EventData event_hub_connection_str = os.environ['EVENT_HUB_CONN_STR'] eventhub_name = os.environ['EVENT_HUB_NAME'] producer = EventHubProducerClient.from_connection_string( conn_str=event_hub_connection_str, eventhub_name= eventhub_name # EventHub name should be specified if it doesn't show up in connection string. ) try: event_data_batch = await producer.create_batch() while True: try: event_data_batch.add( EventData('Message inside EventBatchData')) except ValueError: # The EventDataBatch object reaches its max_size. # You can send the full EventDataBatch object and create a new one here. break await producer.send_batch(event_data_batch) finally: # Close down the producer handler. await producer.close()
async def test_send_with_invalid_policy_async(invalid_policy): client = EventHubProducerClient.from_connection_string(invalid_policy) async with client: with pytest.raises(ConnectError): batch = EventDataBatch() batch.add(EventData("test data")) await client.send_batch(batch)
async def run(text): producer = EventHubProducerClient.from_connection_string( conn_str=connection_string, eventhub_name=event_hub_name) async with producer: event_data_batch = await producer.create_batch() event_data_batch.add(EventData(text)) await producer.send_batch(event_data_batch)
def __init__(self, arguments): super().__init__(arguments) connection_string = self.get_from_env("AZURE_EVENTHUB_CONNECTION_STRING") eventhub_name = self.get_from_env("AZURE_EVENTHUB_NAME") self.async_producer = AsyncEventHubProducerClient.from_connection_string(connection_string, eventhub_name=eventhub_name) self.consumer = EventHubConsumerClient.from_connection_string(connection_string, _EventHubTest.consumer_group, eventhub_name=eventhub_name) self.async_consumer = AsyncEventHubConsumerClient.from_connection_string(connection_string, _EventHubTest.consumer_group, eventhub_name=eventhub_name)
async def test_send_connection_idle_timeout_and_reconnect_async( connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubProducerClient.from_connection_string( conn_str=connection_str, idle_timeout=10) async with client: ed = EventData('data') sender = client._create_producer(partition_id='0') async with sender: await sender._open_with_retry() time.sleep(11) sender._unsent_events = [ed.message] ed.message.on_send_complete = sender._on_outcome with pytest.raises( (uamqp.errors.ConnectionClose, uamqp.errors.MessageHandlerError, OperationTimeoutError)): # Mac may raise OperationTimeoutError or MessageHandlerError await sender._send_event_data() await sender._send_event_data_with_retry() retry = 0 while retry < 3: try: messages = receivers[0].receive_message_batch(max_batch_size=10, timeout=10000) if messages: received_ed1 = EventData._from_message(messages[0]) assert received_ed1.body_as_str() == 'data' break except compat.TimeoutException: retry += 1
async def run(): parser = argparse.ArgumentParser() parser.add_argument('--EVENTHUB_NAME', dest='EVENTHUB_NAME') parser.add_argument('--EVENTHUB_CONN_STR', dest='EVENTHUB_CONN_STR') args = parser.parse_args() #print(args) EVENTHUB_CONN_STR=args.EVENTHUB_CONN_STR EVENTHUB_NAME=args.EVENTHUB_NAME producer = EventHubProducerClient.from_connection_string(conn_str=EVENTHUB_CONN_STR, eventhub_name=EVENTHUB_NAME) async with producer: # Create a batch. event_data_batch = await producer.create_batch() terminalvoltage = round(random.uniform(93.5, 96.5), 2) #print(terminalvoltage) batterypack_timestamp = calendar.timegm(datetime.utcnow().timetuple()) batterypacks = ['Scooter4'] batterypack = random.choice(batterypacks) payload = { 'id' : 1, 'eventType' : 'battery', 'subject' : 'iot/batterysensors', 'eventTime' : str(batterypack_timestamp), 'data' : { 'Timestamp' : batterypack_timestamp, 'Battery Pack': batterypack, 'Terminal Voltage': terminalvoltage, 'Charging Current' : 0, 'Discharging Current' : 0, 'SoC' : 1.6, 'Charge Capacity' : 0, 'Charging Power' : 0, 'Discharging Power' : 0, 'Cycle Count' : 0 }, 'dataVersion': '1.0' } # Add events to the batch. event_data_batch.add(EventData(json.dumps(payload))) # Send the batch of events to the event hub. await producer.send_batch(event_data_batch)
async def test_send_multiple_partition_with_app_prop_async(connstr_receivers): connection_str, receivers = connstr_receivers app_prop_key = "raw_prop" app_prop_value = "raw_value" app_prop = {app_prop_key: app_prop_value} client = EventHubProducerClient.from_connection_string(connection_str) async with client: ed0 = EventData(b"Message 0") ed0.properties = app_prop batch = await client.create_batch(partition_id="0") batch.add(ed0) await client.send_batch(batch) ed1 = EventData(b"Message 1") ed1.properties = app_prop batch = await client.create_batch(partition_id="1") batch.add(ed1) await client.send_batch(batch) partition_0 = [EventData._from_message(x) for x in receivers[0].receive_message_batch(timeout=5000)] assert len(partition_0) == 1 assert partition_0[0].properties[b"raw_prop"] == b"raw_value" partition_1 = [EventData._from_message(x) for x in receivers[1].receive_message_batch(timeout=5000)] assert len(partition_1) == 1 assert partition_1[0].properties[b"raw_prop"] == b"raw_value"
async def create_producer(self): self.producer = \ EventHubProducerClient.from_connection_string( conn_str=self.namespace_conn_string, eventhub_name=self.topic, ) await asyncio.sleep(0.01)
async def run(self): # Create a producer client to send messages to the event hub. # Specify a connection string to your event hubs namespace and # the event hub name. producer = EventHubProducerClient.from_connection_string( conn_str=self.CONNECTION_STRING, eventhub_name=self.EVENTHUB_NAME) async with producer: # Create a batch. event_data_batch = await producer.create_batch() # Add events to the batch. event_data_batch.add( EventData( json.dumps({ 'user': self.YOUR_NAME, 'timestamp': str(datetime.now()), 'message': 'Robert,ABP' }))) event_data_batch.add( EventData( json.dumps({ 'user': self.YOUR_NAME, 'timestamp': str(datetime.now()), 'message': 'Els,ABP' }))) # Send the batch of events to the event hub. await producer.send_batch(event_data_batch)
async def test_client_secret_credential_async(live_eventhub): credential = EnvironmentCredential() producer_client = EventHubProducerClient( fully_qualified_namespace=live_eventhub['hostname'], eventhub_name=live_eventhub['event_hub'], credential=credential, user_agent='customized information') consumer_client = EventHubConsumerClient( fully_qualified_namespace=live_eventhub['hostname'], eventhub_name=live_eventhub['event_hub'], consumer_group='$default', credential=credential, user_agent='customized information') async with producer_client: batch = await producer_client.create_batch(partition_id='0') batch.add(EventData(body='A single message')) await producer_client.send_batch(batch) def on_event(partition_context, event): on_event.called = True on_event.partition_id = partition_context.partition_id on_event.event = event on_event.called = False async with consumer_client: task = asyncio.ensure_future( consumer_client.receive(on_event, partition_id='0', starting_position='-1')) await asyncio.sleep(13) await task assert on_event.called is True assert on_event.partition_id == "0" assert list(on_event.event.body)[0] == 'A single message'.encode('utf-8')
async def test_send_partition_async(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubProducerClient.from_connection_string(connection_str) async with client: batch = await client.create_batch() batch.add(EventData(b"Data")) await client.send_batch(batch) async with client: batch = await client.create_batch(partition_id="1") batch.add(EventData(b"Data")) await client.send_batch(batch) partition_0 = receivers[0].receive_message_batch(timeout=5000) partition_1 = receivers[1].receive_message_batch(timeout=5000) assert len(partition_0) + len(partition_1) == 2 async with client: batch = await client.create_batch() batch.add(EventData(b"Data")) await client.send_batch(batch) async with client: batch = await client.create_batch(partition_id="1") batch.add(EventData(b"Data")) await client.send_batch(batch) partition_0 = receivers[0].receive_message_batch(timeout=5000) partition_1 = receivers[1].receive_message_batch(timeout=5000) assert len(partition_0) + len(partition_1) == 2
async def test_send_with_partition_key_async(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubProducerClient.from_connection_string(connection_str) async with client: data_val = 0 for partition in [b"a", b"b", b"c", b"d", b"e", b"f"]: partition_key = b"test_partition_" + partition for i in range(50): batch = await client.create_batch(partition_key=partition_key) batch.add(EventData(str(data_val))) data_val += 1 await client.send_batch(batch) await client.send_batch(await client.create_batch()) found_partition_keys = {} for index, partition in enumerate(receivers): received = partition.receive_message_batch(timeout=5000) for message in received: try: event_data = EventData._from_message(message) existing = found_partition_keys[event_data.partition_key] assert existing == index except KeyError: found_partition_keys[event_data.partition_key] = index
async def main(): consumer_client = EventHubConsumerClient.from_connection_string( conn_str=CONNECTION_STR, consumer_group='$Default', eventhub_name=EVENTHUB_NAME, http_proxy=HTTP_PROXY) producer_client = EventHubProducerClient.from_connection_string( conn_str=CONNECTION_STR, eventhub_name=EVENTHUB_NAME, http_proxy=HTTP_PROXY) async with producer_client: event_data_batch = await producer_client.create_batch( max_size_in_bytes=10000) while True: try: event_data_batch.add( EventData('Message inside EventBatchData')) except ValueError: # EventDataBatch object reaches max_size. # New EventDataBatch object can be created here to send more data. break await producer_client.send_batch(event_data_batch) print('Finished sending.') async with consumer_client: await consumer_client.receive(on_event=on_event) print('Finished receiving.')
async def run(): faker = Faker() eventhub_connection_STR = os.getenv('EVENT_HUB_CONN_STR') eventhub_name = os.getenv('EVENT_HUB_NAME') print(eventhub_connection_STR) print(eventhub_name) producer = EventHubProducerClient.from_connection_string( conn_str=eventhub_connection_STR, eventhub_name=eventhub_name) async with producer: # Create a batch. event_data_batch = await producer.create_batch() # Add events to the batch. event_data_batch.add(EventData(faker.name())) event_data_batch.add(EventData(faker.name())) #event_data_batch.add(EventData(faker.simple_profile())) # Send the batch of events to the event hub. while (True): await producer.send_batch(event_data_batch)
async def test_send_null_body_async(connection_str): client = EventHubProducerClient.from_connection_string(connection_str) try: with pytest.raises(ValueError): data = EventData(None) await client.send(data) finally: await client.close()
async def test_non_existing_entity_sender_async(connection_str): client = EventHubProducerClient.from_connection_string( connection_str, eventhub_name="nemo") async with client: with pytest.raises(ConnectError): batch = EventDataBatch() batch.add(EventData("test data")) await client.send_batch(batch)
async def test_send_to_invalid_partitions_async(connection_str): partitions = ["XYZ", "-1", "1000", "-"] for p in partitions: client = EventHubProducerClient.from_connection_string(connection_str) try: with pytest.raises(ConnectError): await client.send(EventData("test data"), partition_id=p) finally: await client.close()
async def test_send_list_partition_async(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubProducerClient.from_connection_string(connection_str) payload = "A1" async with client: await client.send_batch([EventData(payload)], partition_id="0") message = receivers[0].receive_message_batch(timeout=10000)[0] received = EventData._from_message(message) assert received.body_as_str() == payload
async def test_create_batch_with_invalid_hostname_async(invalid_hostname): if sys.platform.startswith('darwin'): pytest.skip( "Skipping on OSX - it keeps reporting 'Unable to set external certificates' " "and blocking other tests") client = EventHubProducerClient.from_connection_string(invalid_hostname) async with client: with pytest.raises(ConnectError): await client.create_batch(max_size_in_bytes=300)