/// <inheritdoc /> protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { Tracer.Info(context, $"Initializing Event Hub-based content location event store with epoch '{_configuration.Epoch}'."); var baseInitializeResult = await base.StartupCoreAsync(context); if (!baseInitializeResult) { return(baseInitializeResult); } var connectionStringBuilder = new EventHubsConnectionStringBuilder(_configuration.EventHubConnectionString) { EntityPath = _configuration.EventHubName, }; _currentEventProcessor = new Processor(context, this); // Retry behavior in the Azure Event Hubs Client Library is controlled by the RetryPolicy property on the EventHubClient class. // The default policy retries with exponential backoff when Azure Event Hub returns a transient EventHubsException or an OperationCanceledException. _eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); _partitionSender = _eventHubClient.CreatePartitionSender(PartitionId); return(BoolResult.Success); }
public RequestSender(uint processId, EventHubsConnections connections, ILogger logger, DataContractSerializer payloadSerializer, FunctionsHostConfiguration configuration) : base(processId, connections, logger, payloadSerializer, configuration) { this.processId = processId; doorbell = connections.GetDoorbellSender(processId); }
async Task NonexistentEntity() { // Rebuild connection string with a nonexistent entity. var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString); csb.EntityPath = Guid.NewGuid().ToString(); var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); // GetRuntimeInformationAsync on a nonexistent entity. await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { TestUtility.Log("Getting entity information from a nonexistent entity."); await ehClient.GetRuntimeInformationAsync(); throw new InvalidOperationException("GetRuntimeInformation call should have failed"); }); // GetPartitionRuntimeInformationAsync on a nonexistent entity. await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { TestUtility.Log("Getting partition information from a nonexistent entity."); await ehClient.GetPartitionRuntimeInformationAsync("0"); throw new InvalidOperationException("GetPartitionRuntimeInformation call should have failed"); }); // Try sending. PartitionSender sender = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { TestUtility.Log("Sending an event to nonexistent entity."); sender = ehClient.CreatePartitionSender("0"); await sender.SendAsync(new EventData(Encoding.UTF8.GetBytes("this send should fail."))); throw new InvalidOperationException("Send call should have failed"); }); await sender.CloseAsync(); // Try receiving. PartitionReceiver receiver = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { TestUtility.Log("Receiving from nonexistent entity."); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive call should have failed"); }); await receiver.CloseAsync(); // Try receiving on an nonexistent consumer group. ehClient = EventHubClient.CreateFromConnectionString(TestUtility.EventHubsConnectionString); await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { TestUtility.Log("Receiving from nonexistent consumer group."); receiver = ehClient.CreateReceiver(Guid.NewGuid().ToString(), "0", EventPosition.FromStart()); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive call should have failed"); }); await receiver.CloseAsync(); }
async Task GetEventHubPartitionRuntimeInformation() { var cbs = new EventHubsConnectionStringBuilder(EventHubsConnectionString); Log("Getting EventHubPartitionRuntimeInformation on each partition in parallel"); var tasks = this.PartitionIds.Select(async(pid) => { // Send some messages so we can have meaningful data returned from service call. PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(pid); Log($"Sending single event to partition {pid}"); var eDataToSend = new EventData(new byte[1]); await partitionSender.SendAsync(eDataToSend); Log($"Getting partition runtime information on partition {pid}"); var p = await this.EventHubClient.GetPartitionRuntimeInformationAsync(pid); Log($"Path:{p.Path} PartitionId:{p.PartitionId} BeginSequenceNumber:{p.BeginSequenceNumber} LastEnqueuedOffset:{p.LastEnqueuedOffset} LastEnqueuedTimeUtc:{p.LastEnqueuedTimeUtc} LastEnqueuedSequenceNumber:{p.LastEnqueuedSequenceNumber}"); // Validations. Assert.True(p.Path == cbs.EntityPath, $"Returned path {p.Path} is different than {cbs.EntityPath}"); Assert.True(p.PartitionId == pid, $"Returned partition id {p.PartitionId} is different than {pid}"); Assert.True(p.LastEnqueuedOffset != null, "Returned LastEnqueuedOffset is null"); Assert.True(p.LastEnqueuedTimeUtc != null, "Returned LastEnqueuedTimeUtc is null"); // Validate returned data regarding recently sent event. // Account 60 seconds of max clock skew. Assert.True(p.LastEnqueuedOffset != "-1", $"Returned LastEnqueuedOffset is {p.LastEnqueuedOffset}"); Assert.True(p.BeginSequenceNumber >= 0, $"Returned BeginSequenceNumber is {p.BeginSequenceNumber}"); Assert.True(p.LastEnqueuedSequenceNumber >= 0, $"Returned LastEnqueuedSequenceNumber is {p.LastEnqueuedSequenceNumber}"); Assert.True(p.LastEnqueuedTimeUtc >= DateTime.UtcNow.AddSeconds(-60), $"Returned LastEnqueuedTimeUtc is {p.LastEnqueuedTimeUtc}"); }); await Task.WhenAll(tasks); }
public RemoteSender(uint processId, uint destination, EventHubsConnections connections, ILogger logger, DataContractSerializer payloadSerializer, FunctionsHostConfiguration configuration, DateTime deploymentTimestamp) : base(destination, connections, logger, payloadSerializer, configuration) { this.processId = processId; this.deploymentTimestamp = deploymentTimestamp; doorbell = connections.GetDoorbellSender(destination); }
async Task PartitionReceiverSetReceiveHandler() { Log("Receiving Events via PartitionReceiver.SetReceiveHandler()"); string partitionId = "1"; PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10)); PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); try { string uniqueEventId = Guid.NewGuid().ToString(); Log($"Sending an event to Partition {partitionId} with custom property EventId {uniqueEventId}"); var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); sendEvent.Properties = new Dictionary <string, object> { ["EventId"] = uniqueEventId }; await partitionSender.SendAsync(sendEvent); EventWaitHandle dataReceivedEvent = new EventWaitHandle(false, EventResetMode.ManualReset); var handler = new TestPartitionReceiveHandler(); handler.ErrorReceived += (s, e) => Log($"TestPartitionReceiveHandler.ProcessError {e.GetType().Name}: {e.Message}"); handler.EventsReceived += (s, eventDatas) => { int count = eventDatas != null?eventDatas.Count() : 0; Log($"Received {count} event(s):"); foreach (var eventData in eventDatas) { object objectValue; if (eventData.Properties != null && eventData.Properties.TryGetValue("EventId", out objectValue)) { Log($"Received message with EventId {objectValue}"); string receivedId = objectValue.ToString(); if (receivedId == uniqueEventId) { Log("Success"); dataReceivedEvent.Set(); break; } } } }; partitionReceiver.SetReceiveHandler(handler); if (!dataReceivedEvent.WaitOne(TimeSpan.FromSeconds(20))) { throw new InvalidOperationException("Data Received Event was not signaled."); } } finally { await partitionSender.CloseAsync(); await partitionReceiver.CloseAsync(); } }
readonly MemoryStream stream = new MemoryStream(); // reused for all packets public EventHubsSender(TransportAbstraction.IHost host, byte[] taskHubGuid, PartitionSender sender, EventHubsTraceHelper traceHelper) : base(nameof(EventHubsSender <T>), false, 2000, CancellationToken.None) { this.host = host; this.taskHubGuid = taskHubGuid; this.sender = sender; this.traceHelper = traceHelper; this.eventHubName = this.sender.EventHubClient.EventHubName; this.eventHubPartition = this.sender.PartitionId; }
public BatchSender(uint destination, EventHubsConnections connections, ILogger logger, DataContractSerializer payloadSerializer, FunctionsHostConfiguration configuration, PartitionSender sender) { this.destination = destination; this.connections = connections; this.payloadSerializer = payloadSerializer; this.configuration = configuration; this.logger = new LoggerWrapper(logger, $" [sender{destination:d3}] "); this.sender = sender; }
// Send and receive given event on given partition. protected async Task <EventData> SendAndReceiveEventAsync(string partitionId, EventData sendEvent, EventHubClient client) { PartitionSender partitionSender = client.CreatePartitionSender(partitionId); PartitionReceiver partitionReceiver = client.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromEnqueuedTime(DateTime.UtcNow.AddMinutes(-10))); EventData receivedEvent = null; try { string uniqueEventId = Guid.NewGuid().ToString(); TestUtility.Log($"Sending event to Partition {partitionId} with custom property EventId {uniqueEventId}"); sendEvent.Properties["EventId"] = uniqueEventId; await partitionSender.SendAsync(sendEvent); bool expectedEventReceived = false; do { IEnumerable <EventData> eventDatas = await partitionReceiver.ReceiveAsync(10); if (eventDatas == null) { break; } TestUtility.Log($"Received a batch of {eventDatas.Count()} events:"); foreach (var eventData in eventDatas) { object objectValue; if (eventData.Properties != null && eventData.Properties.TryGetValue("EventId", out objectValue)) { TestUtility.Log($"Received message with EventId {objectValue}"); string receivedId = objectValue.ToString(); if (receivedId == uniqueEventId) { TestUtility.Log("Success"); receivedEvent = eventData; expectedEventReceived = true; break; } } } }while (!expectedEventReceived); Assert.True(expectedEventReceived, $"Did not receive expected event with EventId {uniqueEventId}"); } finally { await Task.WhenAll( partitionReceiver.CloseAsync(), partitionSender.CloseAsync()); } return(receivedEvent); }
async Task PartitionReceiverReceive() { Log("Receiving Events via PartitionReceiver.ReceiveAsync"); const string partitionId = "1"; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10)); try { string uniqueEventId = Guid.NewGuid().ToString(); Log($"Sending an event to Partition {partitionId} with custom property EventId {uniqueEventId}"); var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); sendEvent.Properties = new Dictionary <string, object> { ["EventId"] = uniqueEventId }; await partitionSender.SendAsync(sendEvent); bool expectedEventReceived = false; do { IEnumerable <EventData> eventDatas = await partitionReceiver.ReceiveAsync(10); if (eventDatas == null) { break; } Log($"Received a batch of {eventDatas.Count()} events:"); foreach (var eventData in eventDatas) { object objectValue; if (eventData.Properties != null && eventData.Properties.TryGetValue("EventId", out objectValue)) { Log($"Received message with EventId {objectValue}"); string receivedId = objectValue.ToString(); if (receivedId == uniqueEventId) { Log("Success"); expectedEventReceived = true; break; } } } }while (!expectedEventReceived); Assert.True(expectedEventReceived, $"Did not receive expected event with EventId {uniqueEventId}"); } finally { await Task.WhenAll( partitionReceiver.CloseAsync(), partitionSender.CloseAsync()); } }
public async Task GetEventHubPartitionRuntimeInformation() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); var partitions = await this.GetPartitionsAsync(ehClient); try { TestUtility.Log("Getting EventHubPartitionRuntimeInformation on each partition in parallel"); var tasks = partitions.Select(async(pid) => { // Send some messages so we can have meaningful data returned from service call. PartitionSender partitionSender = ehClient.CreatePartitionSender(pid); try { TestUtility.Log($"Sending single event to partition {pid}"); var eDataToSend = new EventData(new byte[1]); await partitionSender.SendAsync(eDataToSend); TestUtility.Log($"Getting partition runtime information on partition {pid}"); var partition = await ehClient.GetPartitionRuntimeInformationAsync(pid); TestUtility.Log($"Path:{partition.Path} PartitionId:{partition.PartitionId} BeginSequenceNumber:{partition.BeginSequenceNumber} LastEnqueuedOffset:{partition.LastEnqueuedOffset} LastEnqueuedTimeUtc:{partition.LastEnqueuedTimeUtc} LastEnqueuedSequenceNumber:{partition.LastEnqueuedSequenceNumber}"); // Validations. Assert.True(partition.Path == csb.EntityPath, $"Returned path {partition.Path} is different than {csb.EntityPath}"); Assert.True(partition.PartitionId == pid, $"Returned partition id {partition.PartitionId} is different than {pid}"); Assert.True(partition.LastEnqueuedOffset != null, "Returned LastEnqueuedOffset is null"); Assert.True(partition.LastEnqueuedTimeUtc != null, "Returned LastEnqueuedTimeUtc is null"); // Validate returned data regarding recently sent event. // Account 60 seconds of max clock skew. Assert.True(partition.LastEnqueuedOffset != "-1", $"Returned LastEnqueuedOffset is {partition.LastEnqueuedOffset}"); Assert.True(partition.BeginSequenceNumber >= 0, $"Returned BeginSequenceNumber is {partition.BeginSequenceNumber}"); Assert.True(partition.LastEnqueuedSequenceNumber >= 0, $"Returned LastEnqueuedSequenceNumber is {partition.LastEnqueuedSequenceNumber}"); Assert.True(partition.LastEnqueuedTimeUtc >= DateTime.UtcNow.AddSeconds(-60), $"Returned LastEnqueuedTimeUtc is {partition.LastEnqueuedTimeUtc}"); } finally { await partitionSender.CloseAsync(); } }); await Task.WhenAll(tasks); } finally { await ehClient.CloseAsync(); } } }
// Sends single message to given partition and returns it after receiving. async Task <EventData> SendAndReceiveSingleEvent(string partitionId) { var eDataToSend = new EventData(new byte[1]); // Stamp this message so we can recognize it when received. var stampValue = Guid.NewGuid().ToString(); var sendEvent = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); eDataToSend.Properties = new Dictionary <string, object> { { "stamp", stampValue } }; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); Log($"Sending single event to partition {partitionId} with stamp {stampValue}"); await partitionSender.SendAsync(eDataToSend); Log($"Receiving all messages from partition {partitionId}"); PartitionReceiver receiver = null; try { receiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, PartitionReceiver.StartOfStream); while (true) { var receivedEvents = await receiver.ReceiveAsync(100); if (receivedEvents == null || receivedEvents.Count() == 0) { throw new Exception("Not able to receive stamped message!"); } Log($"Received {receivedEvents.Count()} event(s) in batch where last event is sent on {receivedEvents.Last().SystemProperties.EnqueuedTimeUtc}"); // Continue until we locate stamped message. foreach (var receivedEvent in receivedEvents) { if (receivedEvent.Properties != null && receivedEvent.Properties.ContainsKey("stamp") && receivedEvent.Properties["stamp"].ToString() == eDataToSend.Properties["stamp"].ToString()) { return(receivedEvent); } } } } finally { await receiver.CloseAsync(); } }
public async Task SendToInvalidPartition() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); PartitionSender sender = null; try { // Some invalid partition values. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = ehClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); }); await sender.CloseAsync(); } // Some other invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { "", " ", null }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentNullException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = ehClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); }); await sender.CloseAsync(); } } finally { await ehClient.CloseAsync(); } } }
async Task PartitionSenderSend() { Log("Sending single Event via PartitionSender.SendAsync(EventData)"); PartitionSender partitionSender1 = this.EventHubClient.CreatePartitionSender("1"); try { var eventData = new EventData(Encoding.UTF8.GetBytes("Hello again EventHub Partition 1!")); await partitionSender1.SendAsync(eventData); } finally { await partitionSender1.CloseAsync(); } }
/// <summary> /// Performs the tasks needed to initialize and set up the environment for the test scenario. /// When multiple instances are run in parallel, the setup will take place once, prior to the /// execution of the first test instance. /// </summary> /// public async override Task GlobalSetupAsync() { await base.GlobalSetupAsync().ConfigureAwait(false); s_scope = await EventHubScope.CreateAsync(4).ConfigureAwait(false); s_client = EventHubClient.CreateFromConnectionString(TestUtility.BuildEventHubsConnectionString(s_scope.EventHubName)); s_eventBody = EventGenerator.CreateRandomBody(Options.Size); var partition = (await s_client.GetRuntimeInformationAsync().ConfigureAwait(false)).PartitionIds[0]; s_sender = s_client.CreatePartitionSender(partition); // Publish an empty event to force the connection and link to be established. await s_sender.SendAsync(new[] { new EventData(Array.Empty <byte>()) }).ConfigureAwait(false); }
async Task PartitionSenderSendBatch() { Log("Sending single Event via PartitionSender.SendAsync(IEnumerable<EventData>)"); PartitionSender partitionSender1 = this.EventHubClient.CreatePartitionSender("1"); try { var eventData1 = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); var eventData2 = new EventData(Encoding.UTF8.GetBytes("This is another message in the batch!")); eventData2.Properties["ContosoEventType"] = "some value here"; await partitionSender1.SendAsync(new[] { eventData1, eventData2 }); } finally { await partitionSender1.CloseAsync(); } }
public async Task PublishToSpecificPartition() { await using var scope = await EventHubScope.CreateAsync(1); #region Snippet:EventHubs_Migrate_T1_PublishToSpecificPartition #if SNIPPET var connectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; #else var connectionString = TestUtility.EventHubsConnectionString; var eventHubName = scope.EventHubName; #endif var builder = new EventHubsConnectionStringBuilder(connectionString); builder.EntityPath = eventHubName; EventHubClient client = EventHubClient.CreateFromConnectionString(builder.ToString()); PartitionSender sender = default; try { using var eventBatch = client.CreateBatch(); for (var index = 0; index < 5; ++index) { var eventData = new EventData(Encoding.UTF8.GetBytes($"Event #{ index }")); if (!eventBatch.TryAdd(eventData)) { throw new Exception($"The event at { index } could not be added"); } } string firstPartition = (await client.GetRuntimeInformationAsync()).PartitionIds.First(); sender = client.CreatePartitionSender(firstPartition); await sender.SendAsync(eventBatch); } finally { sender?.Close(); client.Close(); } #endregion }
async Task PartitionReceiverReceiveBatch() { const int MaxBatchSize = 5; TestUtility.Log("Receiving Events via PartitionReceiver.ReceiveAsync(BatchSize)"); const string partitionId = "0"; PartitionSender partitionSender = this.EventHubClient.CreatePartitionSender(partitionId); PartitionReceiver partitionReceiver = this.EventHubClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, DateTime.UtcNow.AddMinutes(-10)); try { int eventCount = 20; TestUtility.Log($"Sending {eventCount} events to Partition {partitionId}"); var sendEvents = new List <EventData>(eventCount); for (int i = 0; i < eventCount; i++) { sendEvents.Add(new EventData(Encoding.UTF8.GetBytes($"Hello EventHub! Message {i}"))); } await partitionSender.SendAsync(sendEvents); int maxReceivedBatchSize = 0; while (true) { IEnumerable <EventData> partition1Events = await partitionReceiver.ReceiveAsync(MaxBatchSize); int receivedEventCount = partition1Events != null?partition1Events.Count() : 0; TestUtility.Log($"Received {receivedEventCount} event(s)"); if (partition1Events == null) { break; } maxReceivedBatchSize = Math.Max(maxReceivedBatchSize, receivedEventCount); } Assert.True(maxReceivedBatchSize == MaxBatchSize, $"A max batch size of {MaxBatchSize} events was not honored! Actual {maxReceivedBatchSize}."); } finally { await partitionReceiver.CloseAsync(); await partitionSender.CloseAsync(); } }
/// <inheritdoc /> protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { await base.StartupCoreAsync(context).ThrowIfFailure(); var connectionStringBuilder = new EventHubsConnectionStringBuilder(_configuration.EventHubConnectionString) { EntityPath = _configuration.EventHubName, }; // Retry behavior in the Azure Event Hubs Client Library is controlled by the RetryPolicy property on the EventHubClient class. // The default policy retries with exponential backoff when Azure Event Hub returns a transient EventHubsException or an OperationCanceledException. _eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); _partitionSender = _eventHubClient.CreatePartitionSender(PartitionId); return(BoolResult.Success); }
async Task SendReceiveNonexistentEntity() { // Rebuild connection string with a nonexistent entity. var csb = new EventHubsConnectionStringBuilder(this.connectionString); csb.EntityPath = Guid.NewGuid().ToString(); var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); // Try sending. PartitionSender sender = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Sending an event to nonexistent entity."); sender = ehClient.CreatePartitionSender("0"); await sender.SendAsync(new EventData(Encoding.UTF8.GetBytes("this send should fail."))); throw new InvalidOperationException("Send should have failed"); }); await sender.CloseAsync(); // Try receiving. PartitionReceiver receiver = null; await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Receiving from nonexistent entity."); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", PartitionReceiver.StartOfStream); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive should have failed"); }); await receiver.CloseAsync(); // Try receiving on an nonexistent consumer group. ehClient = EventHubClient.CreateFromConnectionString(this.connectionString); await Assert.ThrowsAsync <MessagingEntityNotFoundException>(async() => { Log("Receiving from nonexistent consumer group."); receiver = ehClient.CreateReceiver(Guid.NewGuid().ToString(), "0", PartitionReceiver.StartOfStream); await receiver.ReceiveAsync(1); throw new InvalidOperationException("Receive should have failed"); }); await receiver.CloseAsync(); }
async Task SendToInvalidPartition() { PartitionSender sender = null; // Some invalid partition values. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = this.EventHubClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); throw new InvalidOperationException("Send call should have failed"); }); await sender.CloseAsync(); } // Some other invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { "", " ", null }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = this.EventHubClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); throw new InvalidOperationException("Send call should have failed"); }); await sender.CloseAsync(); } }
public async Task SendAndReceive() { string targetPartitionId = "0"; TestUtility.Log("Creating Event Hub client"); await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(GetWebSocketConnectionString(connectionString)); PartitionSender sender = null; try { // Send single message TestUtility.Log("Sending single event"); sender = ehClient.CreatePartitionSender(targetPartitionId); var eventData = new EventData(Encoding.UTF8.GetBytes("This event will be transported via web-sockets")); await sender.SendAsync(eventData); } finally { await sender?.CloseAsync(); } PartitionReceiver receiver = null; try { // Receive single message. TestUtility.Log("Receiving single event"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, targetPartitionId, EventPosition.FromStart()); var msg = await receiver.ReceiveAsync(1); Assert.True(msg != null, $"Failed to receive single event from partition {targetPartitionId}"); } finally { await receiver?.CloseAsync(); } } }
static async Task Main(string[] args) { // Creates an EventHubsConnectionStringBuilder object from the connection string, and sets the EntityPath. // Typically, the connection string should have the entity path in it, but this simple scenario // uses the connection string from the namespace. var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); // Specify a specific partition Id to send the messages to. partitionSender = eventHubClient.CreatePartitionSender("2"); await SendEventsToEventHub(100); await eventHubClient.CloseAsync(); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); }
async Task SendAndReceive() { string targetPartitionId = "0"; // Create new client with updated connection string. TestUtility.Log("Creating Event Hub client"); var ehClient = EventHubClient.CreateFromConnectionString(webSocketConnString); PartitionSender sender = null; try { // Send single message TestUtility.Log("Sending single event"); sender = ehClient.CreatePartitionSender(targetPartitionId); var eventData = new EventData(Encoding.UTF8.GetBytes("This event will be transported via web-sockets")); await sender.SendAsync(eventData); } finally { await sender?.CloseAsync(); } PartitionReceiver receiver = null; try { // Receive single message. TestUtility.Log("Receiving single event"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, targetPartitionId, PartitionReceiver.StartOfStream); var msg = await receiver.ReceiveAsync(1); Assert.True(msg != null, $"Failed to receive single event from partition {targetPartitionId}"); } finally { await receiver?.CloseAsync(); } }
/// <summary> /// Performs the tasks needed to initialize and set up the environment for the test scenario. /// When multiple instances are run in parallel, the setup will take place once, prior to the /// execution of the first test instance. /// </summary> /// public async override Task GlobalSetupAsync() { await base.GlobalSetupAsync().ConfigureAwait(false); s_scope = await EventHubScope.CreateAsync(4).ConfigureAwait(false); s_client = EventHubClient.CreateFromConnectionString(TestUtility.BuildEventHubsConnectionString(s_scope.EventHubName)); s_eventBody = EventGenerator.CreateRandomBody(Options.Size); var partition = (await s_client.GetRuntimeInformationAsync().ConfigureAwait(false)).PartitionIds[0]; s_sender = s_client.CreatePartitionSender(partition); // Publish an empty event to force the connection and link to be established. using var batch = s_sender.CreateBatch(); if (!batch.TryAdd(new EventData(Array.Empty <byte>()))) { throw new InvalidOperationException("The empty event could not be added to the batch during global setup."); } await s_sender.SendAsync(batch).ConfigureAwait(false); }
public DefaultPartitionSender(PartitionSender sender) { _sender = sender; }
private static SenderInfo CreatePartitionSender(double n, StreamOptions x, string id, PartitionSender sender) { var si = new SenderInfo() { PartitionId = id, }; si.Thread = new Thread(() => { Console.WriteLine($"Thread started to send to {id}, sending {n} events..."); var epoch = DateTime.UtcNow; var sessionId = Guid.NewGuid(); var deviceId = Guid.NewGuid(); EventDataBatch batch = null; while (n >= 0) { if (batch == null) { batch = sender.CreateBatch(new BatchOptions()); } var e = GenerateEvent(epoch, si.SendCount, sessionId, deviceId); if (!batch.TryAdd(e)) { // flush sender.SendAsync(batch).Wait(); batch = null; // and go to continue, because we need to resend the event that failed continue; } // looks like that went through, yay epoch = epoch.AddMilliseconds(x.Interval); Thread.Sleep(x.Pause); n--; si.SendCount++; } if (batch != null) { sender.SendAsync(batch).Wait(); } si.Event.Set(); }); si.Thread.Start(); return(si); }