private async void MonitorEventHubAsync(DateTime startTime, CancellationToken ct, string consumerGroupName) { EventHubClient eventHubClient = null; EventHubReceiver eventHubReceiver = null; try { eventHubClient = EventHubClient.CreateFromConnectionString(activeIoTHubConnectionString, "messages/events"); eventHubTextBox.Text = String.Format("Receiving events...\r\n"); eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount; string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceIDsComboBoxForEvent.SelectedItem.ToString(), eventHubPartitionsCount); eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(partition, startTime); while (true) { ct.ThrowIfCancellationRequested(); EventData eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(1)); if (eventData != null) { string data = Encoding.UTF8.GetString(eventData.GetBytes()); DateTime enqueuedTime = eventData.EnqueuedTimeUtc.ToLocalTime(); eventHubTextBox.Text += String.Format("{0}> Data:[{1}]", enqueuedTime, data); if (eventData.Properties.Count > 0) { eventHubTextBox.Text += "Properties:\r\n"; foreach (var property in eventData.Properties) { eventHubTextBox.Text += String.Format("'{0}': '{1}'\r\n", property.Key, property.Value); } } eventHubTextBox.Text += "\r\n"; } } } catch (Exception ex) { if (ct.IsCancellationRequested) { eventHubTextBox.Text += String.Format("Stopped Monitoring events. {0}\r\n", ex.Message); } else { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); eventHubTextBox.Text += String.Format("Stopped Monitoring events. {0}\r\n", ex.Message); } if (eventHubReceiver != null) { eventHubReceiver.Close(); } if (eventHubClient != null) { eventHubClient.Close(); } dataMonitorButton.Enabled = true; deviceIDsComboBoxForEvent.Enabled = true; cancelMonitoringButton.Enabled = false; } }
static void Main(string[] args) { EventHubClient client = null; try { if (File.Exists(_fileName)) { string auditData = File.ReadAllText(_fileName); JArray auditDataJson = JArray.Parse(auditData); client = EventHubClient.CreateFromConnectionString(_connectionString, _eventHubName); foreach (JObject auditEvent in auditDataJson) { client.Send(new EventData(Encoding.UTF8.GetBytes(auditEvent.ToString()))); } } else { Console.WriteLine(string.Format("Input file {0} not found.", _fileName)); } } catch (Exception ex) { Console.WriteLine(string.Format("Upload of Azure AD Audit Data to Event Hub failed with the following error: {0}", ex.Message)); } finally { if (client != null) { client.Close(); } } }
static int Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Proton-DotNet.exe connection_string"); return(2); } try { EventHubClient ehc = EventHubClient.CreateFromConnectionString(args[0]); EventHubReceiver receiver = ehc.GetDefaultConsumerGroup().CreateReceiver("0"); while (true) { EventData data = receiver.Receive(); if (data == null) { break; } string text = Encoding.UTF8.GetString(data.GetBytes()); Console.WriteLine(data.SequenceNumber + ":" + text); } ehc.Close(); return(0); } catch (Exception exception) { Console.WriteLine(exception.ToString()); } return(1); }
public void Dispose() { if (_eventHubClient != null) { _eventHubClient.Close(); } }
public async Task ClientCannotRetrieveMetadataWhenClosed(bool sync) { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName); await using (var client = new EventHubClient(connectionString)) { var partition = (await client.GetPartitionIdsAsync()).First(); Assert.That(async() => await client.GetPropertiesAsync(), Throws.Nothing); Assert.That(async() => await client.GetPartitionPropertiesAsync(partition), Throws.Nothing); if (sync) { client.Close(); } else { await client.CloseAsync(); } await Task.Delay(TimeSpan.FromSeconds(5)); Assert.That(async() => await client.GetPartitionIdsAsync(), Throws.TypeOf <ObjectDisposedException>()); Assert.That(async() => await client.GetPropertiesAsync(), Throws.TypeOf <ObjectDisposedException>()); Assert.That(async() => await client.GetPartitionPropertiesAsync(partition), Throws.TypeOf <ObjectDisposedException>()); } } }
public async Task ReceiveDataFromCloud() { startingDateTimeUtc = DateTime.UtcNow - TimeSpan.FromHours(24); factory = MessagingFactory.CreateFromConnectionString(ConnectionString); client = factory.CreateEventHubClient(eventHubEntity); group = client.GetDefaultConsumerGroup(); receiver = group.CreateReceiver(partitionId.ToString(), startingDateTimeUtc); try { while (true) { EventData data = receiver.Receive(); if (data != null) { var receiveddata = Encoding.UTF8.GetString(data.GetBytes()); Debug.WriteLine("{0} {1} {2}", data.SequenceNumber, data.EnqueuedTimeUtc.ToLocalTime(), receiveddata); } } } catch (Exception ex) { Debug.WriteLine("Exception {0}", ex); } receiver.Close(); client.Close(); factory.Close(); }
public void Dispose() { if (_closeOnDispose) { _eventHubClient.Close(); } }
//code adapted from tutorial https://paolopatierno.wordpress.com/2015/11/02/azure-iot-hub-get-telemetry-data-using-amqp-stack-and-azure-sb-lite/ public static string GetMessage(string partitionId) { string result = null; ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(ConnectionString); builder.TransportType = TransportType.Amqp; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ConnectionString); EventHubClient client = factory.CreateEventHubClient(eventHubEntity); EventHubConsumerGroup group = client.GetDefaultConsumerGroup(); var startingDateTimeUtc = DateTime.Now; EventHubReceiver receiver = group.CreateReceiver(partitionId, startingDateTimeUtc); EventData data = receiver.Receive(); receiver.Close(); client.Close(); factory.Close(); if (data != null) { result = Encoding.UTF8.GetString(data.GetBytes()); return(result); } else { return(null); } }
public void Scenario4_EventHubSendToPublisherWithToken(string sbnamespace, string eventHubEntity, string publisher, string sharedAccessKeyName, string sharedAccessKey) { string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature( new Uri(sbnamespace), eventHubEntity, publisher, sharedAccessKeyName, sharedAccessKey, new TimeSpan(0, 20, 0)); string connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature( new Uri(sbnamespace), eventHubEntity, publisher, token); MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString); EventHubClient client = factory.CreateEventHubClient(eventHubEntity); EventHubSender sender = client.CreateSender(publisher); EventData data = new EventData(Encoding.UTF8.GetBytes("Body")); data.Properties["time"] = DateTime.UtcNow; sender.Send(data); sender.Close(); client.Close(); factory.Close(); }
/// <summary> /// Method to run Health Check for Azure Event hub /// </summary> /// <param name="serviceKey"></param> /// <param name="value"></param> /// <returns></returns> public override LightHealth.HealthCheck HealthCheck(string serviceKey, string value) { try { if (config == null) { this.GetConnection(string.Empty); } foreach (var item in _eventCache) { if (!string.IsNullOrEmpty(item.Value.HubName)) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(config.ConnectionString) { EntityPath = item.Value.HubName }; EventHubClient eventHub = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); var a = eventHub.GetRuntimeInformationAsync(); eventHub.Close(); } } return(LightHealth.HealthCheck.Healthy); } catch { return(LightHealth.HealthCheck.Unhealthy); } }
protected void btnSend_Click(object sender, EventArgs e) { EventHubClient ehClient = EventHubClient.CreateWithManagedIdentity(new Uri($"sb://{txtNamespace.Text}.servicebus.windows.net/"), txtEventHub.Text); ehClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(txtData.Text))).GetAwaiter().GetResult(); txtOutput.Text = $"{DateTime.Now} - SENT{Environment.NewLine}" + txtOutput.Text; ehClient.Close(); }
public Task CloseAsync(PartitionContext context, CloseReason reason) { _logger.LogInformation($"Processor Shutting Down. Partition '{context.PartitionId}', Reason: '{reason}'."); // close the eventhub client eventHubClient.Close(); return(Task.CompletedTask); }
public static void Stop() { cts.Cancel(); receiverList.ForEach(r => r.Close()); client.Close(); factory.Close(); }
protected override void Dispose(bool disposing) { if (disposing) { _eventHubClient.Close(); _messsagingFactory.Close(); } }
/// <summary> /// Attempts to disconnect from Azure Event Hub. /// </summary> protected override void AttemptDisconnection() { m_eventHubDataClient.Close(); if (m_eventHubDataClient != m_eventHubMetadataClient) { m_eventHubMetadataClient.Close(); } }
private async void MonitorEventHubAsync(DateTime startTime, CancellationToken ct, string consumerGroupName) { EventHubClient eventHubClient = null; EventHubReceiver eventHubReceiver = null; try { eventHubClient = EventHubClient.CreateFromConnectionString(activeIoTHubConnectionString, "messages/events"); int eventHubPartitionsCount = eventHubClient.GetRuntimeInformation().PartitionCount; string partition = EventHubPartitionKeyResolver.ResolveToPartition(deviceID, eventHubPartitionsCount); eventHubReceiver = eventHubClient.GetConsumerGroup(consumerGroupName).CreateReceiver(partition, startTime); //receive the events from startTime until current time in a single call and process them var events = await eventHubReceiver.ReceiveAsync(int.MaxValue, TimeSpan.FromSeconds(20)); foreach (var eventData in events) { byte[] rxbuff = eventData.GetBytes(); makeCommDataForLogData("Rx", rxbuff); } //having already received past events, monitor current events in a loop while (true) { ct.ThrowIfCancellationRequested(); var eventData = await eventHubReceiver.ReceiveAsync(TimeSpan.FromSeconds(0.5)); if (eventData != null) { byte[] rxbuff = eventData.GetBytes(); makeCommDataForLogData("Rx", rxbuff); } } } catch (Exception ex) { if (ct.IsCancellationRequested) { //Stopped Monitoring events by user action. } else { //Something happen. } if (eventHubReceiver != null) { eventHubReceiver.Close(); } if (eventHubClient != null) { eventHubClient.Close(); } } }
private void btn_closeEventHub_Click(object sender, EventArgs e) { if (ehClient != null) { ehClient.Close(); } btn_closeEventHub.Enabled = false; btn_connectEventHub.Enabled = true; }
protected virtual void Dispose(bool disposing) { if (disposing) { GC.SuppressFinalize(this); } Client.TryDispose(); Client = default(T); NotificationHub.Close(); NotificationHub = null; }
protected virtual void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { handle.Dispose(); _client.Close(); } disposed = true; }
static void Main(string[] args) { Console.WriteLine($"Backend App for C2D scenarios, targeting to simulated device {TargetDeviceId}."); Console.WriteLine("Please choose actions you'd like take:"); Console.WriteLine("1. Send C2D messages"); Console.WriteLine("2. Receive D2C messages"); Console.WriteLine("3. Receive file upload notification"); Console.WriteLine("4. Invoke direct method"); var input = Console.ReadLine(); switch (input) { case "1": MyServiceClient = ServiceClient.CreateFromConnectionString(IoTHubConnectionString); ReceiveC2dFeedbackAsync(); SendCloudToDeviceMessagesAsync(); Console.WriteLine("Start to send messages... Press Enter to stop and exit!"); Console.ReadLine(); MyServiceClient.CloseAsync().Wait(); break; case "2": MyEventHubClient = EventHubClient.CreateFromConnectionString(EventHubCompatibleConnectionString); ReceiveDeviceToCloudMessagesAsync(); Console.WriteLine("Start to receive messages... Press Enter to stop and exit!"); Console.ReadLine(); MyEventHubClient.Close(); break; case "3": MyServiceClient = ServiceClient.CreateFromConnectionString(IoTHubConnectionString); ReceiveFileUploadNotificationAsync(); Console.WriteLine("Start to receive file upload notification... Press Enter to stop and exit!"); Console.ReadLine(); MyServiceClient.CloseAsync().Wait(); break; case "4": MyServiceClient = ServiceClient.CreateFromConnectionString(IoTHubConnectionString); InvokeDirectMethodAsync(); Console.WriteLine("Start to invoke direct method... Press Enter to stop and exit!"); Console.ReadLine(); MyServiceClient.CloseAsync().Wait(); break; default: Console.WriteLine("Wrong input! Please just input actions index provided above!"); break; } }
/// <summary> /// Method to run Health Check for Azure Event hub /// </summary> /// <param name="serviceKey"></param> /// <param name="value"></param> /// <returns></returns> public LightHealth.HealthCheck HealthCheck(string serviceKey, string value) { try { EventHubClient eventHub = EventHubClient.CreateFromConnectionString(config.ConnectionString); var a = eventHub.GetRuntimeInformationAsync(); eventHub.Close(); return(LightHealth.HealthCheck.Healthy); } catch { return(LightHealth.HealthCheck.Unhealthy); } }
public override void StopListening() { try { receivers.ForEach(r => r.Close()); eventHubClient.Close(); eventHubClient = null; listenerTimer?.Cancel(); } catch (Exception e) { Debug.WriteLine($"Gap Detection: {e.Message}"); } }
public async Task ProducerCanSendWhenClientIsClosed() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName); await using (var client = new EventHubClient(connectionString)) await using (var producer = client.CreateProducer()) { client.Close(); var events = new EventData(Encoding.UTF8.GetBytes("Do not delete me!")); Assert.That(async() => await producer.SendAsync(events), Throws.Nothing); } } }
// Protected implementation of Dispose pattern. protected virtual void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { eventHubClient.Close(); } // Free any unmanaged objects here. // disposed = true; }
public static async Task Main(string[] args) { try { _eventHubClient = CreateEventHubClient(); await ReceiveData(); } catch (Exception exception) { Console.WriteLine(exception); } Console.WriteLine("-- Press Key --"); Console.ReadKey(); _eventHubClient.Close(); }
static void Main(string[] args) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); SendMessagesToEventHub(500).Wait(); eventHubClient.Close(); Console.WriteLine("Press any key to continue ..."); Console.ReadKey(); }
public async Task PublishWithAPartitionKey() { await using var scope = await EventHubScope.CreateAsync(1); #region Snippet:EventHubs_Migrate_T1_PublishWithAPartitionKey #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()); try { var batchOptions = new BatchOptions { PartitionKey = "Any Value Will Do..." }; using var eventBatch = client.CreateBatch(batchOptions); 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"); } } await client.SendAsync(eventBatch); } finally { client.Close(); } #endregion }
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 }
protected void btnSend_Click(object sender, EventArgs e) { MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.EventHubsAudience), TransportType = TransportType.Amqp }; MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}.servicebus.windows.net/", messagingFactorySettings); EventHubClient ehClient = messagingFactory.CreateEventHubClient(txtEventHub.Text); ehClient.Send(new EventData(Encoding.UTF8.GetBytes(txtData.Text))); ehClient.Close(); messagingFactory.Close(); }
static void Main(string[] args) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); SendMessagesToEventHub(500).Wait(); eventHubClient.Close(); //File.WriteAllText("SEN01.json", JsonConvert.SerializeObject(messages)); Console.WriteLine("Press any key to continue ..."); Console.ReadKey(); }