def test_cloud_event_serialization_extension_bytes(self, **kwargs): data = b"cloudevent" cloud_event = CloudEvent( source="http://samplesource.dev", data=data, type="Sample.Cloud.Event", foo="bar", extensions={'e1':1, 'e2':2} ) cloud_event.subject = "subject" # to test explicit setting of prop encoded = base64.b64encode(data).decode('utf-8') internal = cloud_event._to_generated() assert internal.additional_properties is not None assert 'foo' not in internal.additional_properties assert 'e1' in internal.additional_properties json = internal.serialize() expected = { 'source':'http://samplesource.dev', 'data_base64': encoded, 'type':'Sample.Cloud.Event', 'reason_code':204, 'e1':1, 'e2':2 } self._assert_cloud_event_serialized(expected, json) assert expected['data_base64'] == json['data_base64']
def test_send_cloud_event_data_with_extensions(self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) cloud_event = CloudEvent( source = "http://samplesource.dev", data = "cloudevent", type="Sample.Cloud.Event", extensions={ 'reason_code':204, 'extension':'hello' } ) client.send([cloud_event]) internal = cloud_event._to_generated().serialize() assert 'reason_code' in internal assert 'extension' in internal assert internal['reason_code'] == 204
def test_send_cloud_event_fails_on_providing_data_and_b64(self): with pytest.raises( ValueError, match= "data and data_base64 cannot be provided at the same time*"): cloud_event = CloudEvent(source="http://samplesource.dev", data_base64=b'cloudevent', data="random data", type="Sample.Cloud.Event")
async def test_send_cloud_event_data_str(self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) cloud_event = CloudEvent( source = "http://samplesource.dev", data = "cloudevent", type="Sample.Cloud.Event" ) await client.send(cloud_event)
def test_eg_publisher_client_publish_cloud_event_data_dict( self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) cloud_event = CloudEvent(source="http://samplesource.dev", data={"sample": "cloudevent"}, type="Sample.Cloud.Event") client.send([cloud_event])
async def publish(): credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(endpoint, credential) client.send([ CloudEvent(type="Contoso.Items.ItemReceived", source="/contoso/items", data={"itemSku": "Contoso Item SKU #1"}, subject="Door1") ])
async def test_send_and_close_async_session(self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) async with client: # this throws if client can't close cloud_event = CloudEvent( source = "http://samplesource.dev", data = "cloudevent", type="Sample.Cloud.Event" ) await client.send(cloud_event)
def test_send_cloud_event_bytes_using_data_base64( self, resource_group, eventgrid_topic, eventgrid_topic_primary_key, eventgrid_topic_endpoint): akc_credential = AzureKeyCredential(eventgrid_topic_primary_key) client = EventGridPublisherClient(eventgrid_topic_endpoint, akc_credential) cloud_event = CloudEvent(source="http://samplesource.dev", data_base64=b'cloudevent', type="Sample.Cloud.Event") def callback(request): req = json.loads(request.http_request.body) assert req[0].get("data_base64") is not None assert req[0].get("data") is None client.send(cloud_event, raw_response_hook=callback)
def publish_event(): # publish events for _ in range(3): event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 3)): sample_members = sample(services, k=randint( 1, 4)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source="https://egdemo.dev/demowithsignature", data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
def publish_event(): # publish events for _ in range(10): event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 1)): sample_members = sample(team_members, k=randint( 1, 9)) # select random subset of team members data_dict = {"team": sample_members} event = CloudEvent(type="Azure.Sdk.Sample", source="https://egsample.dev/sampleevent", data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
def publish_event(): # publish events for _ in range(3): event_list = [] # list of events to publish services = ["EventGrid", "ServiceBus", "EventHubs", "Storage"] # possible values for data field # create events and append to list for j in range(randint(1, 3)): sample_members = sample(services, k=randint( 1, 4)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source=domain_name, data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
def publish_event(): # publish events for _ in range(3): event_list = [] # list of events to publish team_members = [ "Josh", "Kerri", "Kieran", "Laurent", "Lily", "Matt", "Soren", "Srikanta", "Swathi" ] # possible values for data field # create events and append to list for j in range(randint(1, 3)): sample_members = sample(team_members, k=randint( 1, 9)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source=domain_name, data={"team": sample_members}) event_list.append(event) # publish list of events client.send_events(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
from azure.core.credentials import AzureKeyCredential from azure.eventgrid import EventGridPublisherClient, CloudEvent key = os.environ.get("CLOUD_ACCESS_KEY") topic_hostname = os.environ["CLOUD_TOPIC_HOSTNAME"] # authenticate client credential = AzureKeyCredential(key) client = EventGridPublisherClient(topic_hostname, credential) team_members = ["Josh", "Kerri", "Kieran", "Laurent", "Lily", "Matt", "Soren", "Srikanta", "Swathi"] # possible values for data field # publish events while True: event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 1)): sample_members = sample(team_members, k=randint(1, 9)) # select random subset of team members data_dict = {"team": sample_members} event = CloudEvent( type="Azure.Sdk.Sample", source="https://egsample.dev/sampleevent", data={"team": sample_members} ) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
FILE: consume_cloud_events_from_storage_queue.py DESCRIPTION: These samples demonstrate receiving events from a Storage Queue. USAGE: python consume_cloud_events_from_storage_queue.py Set the environment variables with your own values before running the sample: 1) STORAGE_QUEUE_CONN_STR: The connection string to the Storage account 3) STORAGE_QUEUE_NAME: The name of the storage queue. """ from azure.eventgrid import CloudEvent from azure.storage.queue import QueueServiceClient, BinaryBase64DecodePolicy import os import json # all types of CloudEvents below produce same DeserializedEvent connection_str = os.environ['STORAGE_QUEUE_CONN_STR'] queue_name = os.environ['STORAGE_QUEUE_NAME'] with QueueServiceClient.from_connection_string(connection_str) as qsc: payload = qsc.get_queue_client( queue=queue_name, message_decode_policy=BinaryBase64DecodePolicy() ).peek_messages() ## deserialize payload into a lost of typed Events events = [CloudEvent.from_dict(json.loads(msg.content)) for msg in payload] for event in events: print(type(event)) ## CloudEvent
domain_key = os.environ["DOMAIN_ACCESS_KEY"] domain_topic_hostname = os.environ["DOMAIN_TOPIC_HOSTNAME"] domain_name = os.environ["DOMAIN_NAME"] # authenticate client credential = AzureKeyCredential(domain_key) client = EventGridPublisherClient(domain_topic_hostname, credential) # publish events while True: event_list = [] # list of events to publish team_members = [ "Josh", "Kerri", "Kieran", "Laurent", "Lily", "Matt", "Soren", "Srikanta", "Swathi" ] # possible values for data field # create events and append to list for j in range(randint(1, 3)): sample_members = sample(team_members, k=randint( 1, 9)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source=domain_name, data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))
from azure.eventgrid import EventGridPublisherClient, CloudEvent from azure.core.credentials import AzureKeyCredential topic_hostname = "<YOUR-TOPIC-NAME>.<REGION-NAME>-1.eventgrid.azure.net" topic_key = "<YOUR-TOPIC-KEY>" credential = AzureKeyCredential(topic_key) client = EventGridPublisherClient(topic_hostname, credential) client.send([ CloudEvent(type="Contoso.Items.ItemReceived", source="/contoso/items", data={"itemSku": "Contoso Item SKU #1"}, subject="Door1") ])
# Regular open telemetry usage from here, see https://github.com/open-telemetry/opentelemetry-python # for details from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor # Simple console exporter exporter = ConsoleSpanExporter() trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(exporter)) # Example with Eventgrid SDKs import os from azure.eventgrid import EventGridPublisherClient, CloudEvent from azure.core.credentials import AzureKeyCredential hostname = os.environ['CLOUD_TOPIC_HOSTNAME'] key = AzureKeyCredential(os.environ['CLOUD_ACCESS_KEY']) cloud_event = CloudEvent(source='demo', type='sdk.demo', data={'test': 'hello'}, extensions={'test': 'maybe'}) with tracer.start_as_current_span(name="MyApplication"): client = EventGridPublisherClient(hostname, key) client.send(cloud_event)
# -------------------------------------------------------------------------- """ FILE: sample_consume_custom_payload.py DESCRIPTION: These samples demonstrate consuming a raw json with a list of jsons and deserializing them into typed objects of CloudEvents. USAGE: python sample_consume_custom_payload.py """ from azure.eventgrid import CloudEvent import json # all types of CloudEvents below produce same DeserializedEvent cloud_custom_dict = """[{ "id":"de0fd76c-4ef4-4dfb-ab3a-8f24a307e033", "source":"https://egtest.dev/cloudcustomevent", "data":{ "team": "event grid squad" }, "type":"Azure.Sdk.Sample", "time":"2020-08-07T02:06:08.11969Z", "specversion":"1.0" }]""" deserialized_dict_events = [CloudEvent(**msg) for msg in json.loads(cloud_custom_dict)] for event in deserialized_dict_events: print(event.data) print(type(event))
from azure.eventgrid import CloudEvent import json # all types of CloudEvents below produce same DeserializedEvent cloud_custom_dict = """[{ "id":"de0fd76c-4ef4-4dfb-ab3a-8f24a307e033", "source":"https://egtest.dev/cloudcustomevent", "data":{ "team": "event grid squad" }, "type":"Azure.Sdk.Sample", "time":"2020-08-07T02:06:08.11969Z", "specversion":"1.0" }]""" deserialized_dict_events = [ CloudEvent(**msg) for msg in json.loads(cloud_custom_dict) ] for event in deserialized_dict_events: print(event.data) print(type(event))
signature = generate_shared_access_signature(topic_hostname, key, expiration_date_utc) # authenticate client credential = EventGridSharedAccessSignatureCredential(signature) client = EventGridPublisherClient(topic_hostname, credential) team_members = [ "Josh", "Kerri", "Kieran", "Laurent", "Lily", "Matt", "Soren", "Srikanta", "Swathi" ] # possible values for data field # publish events while True: event_list = [] # list of events to publish # create events and append to list for j in range(randint(1, 3)): sample_members = sample(team_members, k=randint( 1, 9)) # select random subset of team members event = CloudEvent(type="Azure.Sdk.Demo", source="https://egdemo.dev/demowithsignature", data={"team": sample_members}) event_list.append(event) # publish list of events client.send(event_list) print("Batch of size {} published".format(len(event_list))) time.sleep(randint(1, 5))