static async Task Main(string[] args) { // read environment vars from .env file DotNetEnv.Env.Load(); string eventHubConnectionString = System.Environment.GetEnvironmentVariable("EventHubConnectionString"); string eventHubName = System.Environment.GetEnvironmentVariable("EventHubName"); var connectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubConnectionString) { EntityPath = eventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); Console.WriteLine($"Sending {args[0]} messages to event hub stream...."); var eventList = new List <EventData>(); var uuid = Guid.NewGuid().ToString(); for (int x = 0; x < int.Parse(args[0]); x++) { var message = new { ActivityID = uuid, MessageNumber = x, PublishTime = ToRfc3339String(DateTime.UtcNow), ThrowException = x % 10 == 0 }; eventList.Add(new EventData(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)))); if (eventList.Count >= 100) { await SendEvents(eventList); eventList.Clear(); } } if (eventList.Count > 0) { await SendEvents(eventList); } }
/// <summary> /// Add a connection for sending messages to an event hub. Connect via the connection string. /// </summary> /// <param name="eventHubName">name of the event hub. </param> /// <param name="sendConnectionString">connection string for sending messages. If this includes an EntityPath, it takes precedence over the eventHubName parameter.</param> public void AddSender(string eventHubName, string sendConnectionString) { if (eventHubName == null) { throw new ArgumentNullException("eventHubName"); } if (sendConnectionString == null) { throw new ArgumentNullException("sendConnectionString"); } EventHubsConnectionStringBuilder sb = new EventHubsConnectionStringBuilder(sendConnectionString); if (string.IsNullOrWhiteSpace(sb.EntityPath)) { sb.EntityPath = eventHubName; } var client = EventHubClient.CreateFromConnectionString(sb.ToString()); AddEventHubClient(eventHubName, client); }
static async Task MainAsync(string[] args) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) // Endpoint=sb://namespace_DNS_Name;EntityPath= { EntityPath = "myeventhub", Endpoint = new Uri("sb://testingevent.servicebus.windows.net/"), SasKeyName = "iothubroutes_mytesting", SasKey = "oEQ4T5iB/tsFwbXrYc4nAxUJujXaHvqEcGBLSTV4WRo=" //Endpoint=sb://testingevent.servicebus.windows.net/;SharedAccessKeyName=iothubroutes_mytesting;SharedAccessKey=oEQ4T5iB/tsFwbXrYc4nAxUJujXaHvqEcGBLSTV4WRo=;EntityPath=myeventhub // Endpoint = new Uri("Endpoint=sb://mytesting.azure-devices.net;EntityPath=mytesting;SharedAccessKeyName=iothubowner;SharedAccessKey=4b4wUQny9H83mZ0NIh1VChWqIiEmIWt/yKFcsr3+oEM=") }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); await SendMessagesToEventHub(10); await eventHubClient.CloseAsync(); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); }
public async void StartListening(GapDetection detectionEvent) { if (gapDetectionEvent != null) { return; } try { var connectionString = new EventHubsConnectionStringBuilder( new Uri(GapConfig.EventHubsCompatibleEndpoint), GapConfig.EventHubsCompatiblePath, GapConfig.IotHubSasKeyName, GapConfig.IotHubSasKey); eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString()); // Create a PartitionReciever for each partition on the hub. var runtimeInfo = await eventHubClient.GetRuntimeInformationAsync(); var d2cPartitions = runtimeInfo.PartitionIds; // TODO: listening on partition 0 only. receivers = d2cPartitions .Select(d2c => eventHubClient.CreateReceiver("$Default", d2c, EventPosition.FromEnqueuedTime(DateTime.Now))) .ToList(); gapTimer = ThreadPoolTimer.CreatePeriodicTimer(BackgroundListen, timerPeriod); GapDetectionEvent += detectionEvent; gapDetectionEvent = detectionEvent; } catch (Exception e) { Debug.WriteLine(e.ToString()); } }
public async Task <bool> AddAsync( MessageAddOptions messageAddOptions) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(_options.ConnectionString) { EntityPath = messageAddOptions.Type }; var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); await eventHubClient.SendAsync( new EventData( Encoding.UTF8.GetBytes( JsonConvert.SerializeObject(messageAddOptions, Formatting.Indented)))); await eventHubClient.CloseAsync(); return(true); }
// === EventHub methods below private static void SendEventHubMessages(int messageCount) { Log("SendEventHubMessages: " + messageCount); var connectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubConnStr) { EntityPath = eventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); Random random = new Random(); for (int seq = 1; seq <= messageCount; seq++) { var index = random.Next(0, airportData.airports.Count); JObject airport = (JObject)airportData.airports[index]; airportData.AddRandomEvent(airport, seq); Console.WriteLine(airport); Task task = SendMessageAsync(airport); task.Wait(); } }
static void Main(string[] args) { // Create an EventHubClient instance to connect to the IoT Hub Event Hubs-compatible endpoint. var connectionString = new EventHubsConnectionStringBuilder(new Uri(s_eventHubsCompatibleEndpoint), s_eventHubsCompatiblePath, s_iotHubSasKeyName, s_iotHubSasKey); s_eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString()); // Create a PartitionReceiver for each partition on the hub. var runtimeInfo = s_eventHubClient.GetRuntimeInformationAsync().GetAwaiter().GetResult(); var d2cPartitions = runtimeInfo.PartitionIds; // Create receivers to listen for messages. var tasks = new List <Task>(); foreach (string partition in d2cPartitions) { tasks.Add(ReceiveMessagesFromDeviceAsync(partition)); } // Wait for all the PartitionReceivers to finish. Task.WaitAll(tasks.ToArray()); }
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(); }
private static async Task MainAsync(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 for the sake of this simple scenario // we are using the connection string from the namespace. var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient1 = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); var connectionStringBuilder2 = new EventHubsConnectionStringBuilder(EventHubConnectionString2) { EntityPath = EventHubName2 }; eventHubClient2 = EventHubClient.CreateFromConnectionString(connectionStringBuilder2.ToString()); //send to the event hubs in parallel Thread t1 = new Thread(async() => { await SendMessagesToEventHub1(1000); }); Thread t2 = new Thread(async() => { await SendMessagesToEventHub2(1000); }); t1.Start(); t2.Start(); //await eventHubClient.CloseAsync(); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); }
public IotHub(string iotHubConnectionString, string eventHubEndpoint, Option <Uri> proxyUri) { this.eventHubEndpoint = eventHubEndpoint; this.iotHubConnectionString = iotHubConnectionString; Option <IWebProxy> proxy = proxyUri.Map(p => new WebProxy(p) as IWebProxy); this.registryManager = new Lazy <RegistryManager>( () => { var settings = new HttpTransportSettings(); proxy.ForEach(p => settings.Proxy = p); return(RegistryManager.CreateFromConnectionString( this.iotHubConnectionString, settings)); }); this.serviceClient = new Lazy <ServiceClient>( () => { var settings = new ServiceClientTransportSettings(); proxy.ForEach(p => settings.HttpProxy = p); return(ServiceClient.CreateFromConnectionString( this.iotHubConnectionString, DeviceTransportType.Amqp_WebSocket_Only, settings)); }); this.eventHubClient = new Lazy <EventHubClient>( () => { var builder = new EventHubsConnectionStringBuilder(this.eventHubEndpoint) { TransportType = EventHubTransportType.AmqpWebSockets }; var client = EventHubClient.CreateFromConnectionString(builder.ToString()); proxy.ForEach(p => client.WebProxy = p); return(client); }); }
static async Task Main(string[] args) { Console.WriteLine("IoT Hub Quickstarts - Read device to cloud messages. Ctrl-C to exit.\n"); // Create an EventHubClient instance to connect to the // IoT Hub Event Hubs-compatible endpoint. var connectionString = new EventHubsConnectionStringBuilder(new Uri(eventHubsCompatibleEndpoint), eventHubsCompatiblePath, iotHubSasKeyName, iotHubSasKey); eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString()); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(azureStorageConnectionString); var blobClient = storageAccount.CreateCloudBlobClient(); cloudBlobContainer = blobClient.GetContainerReference("azure-webjobs-eventhub/" + eventHubHostname + "/" + eventHubsCompatiblePath + "/" + targetConsumerGroup); // Create a PartitionReciever for each partition on the hub. var runtimeInfo = await eventHubClient.GetRuntimeInformationAsync(); var d2cPartitions = runtimeInfo.PartitionIds; CancellationTokenSource cts = new CancellationTokenSource(); Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); Console.WriteLine("Exiting..."); }; var tasks = new List <Task>(); foreach (string partition in d2cPartitions) { tasks.Add(ReceiveMessagesFromDeviceAsync(partition, cts.Token)); } // Wait for all the PartitionReceivers to finsih. Task.WaitAll(tasks.ToArray()); }
public void ParseAndBuild() { var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString); // Try update settings and rebuild the connection string. csb.Endpoint = new Uri("sb://newendpoint"); csb.EntityPath = "newentitypath"; csb.OperationTimeout = TimeSpan.FromSeconds(100); csb.SasKeyName = "newsaskeyname"; csb.SasKey = "newsaskey"; var newConnectionString = csb.ToString(); // Now try creating a new ConnectionStringBuilder from modified connection string. var newCsb = new EventHubsConnectionStringBuilder(newConnectionString); // Validate modified values on the new connection string builder. Assert.Equal(new Uri("sb://newendpoint"), newCsb.Endpoint); Assert.Equal("newentitypath", newCsb.EntityPath); Assert.Equal(TimeSpan.FromSeconds(100), newCsb.OperationTimeout); Assert.Equal("newsaskeyname", newCsb.SasKeyName); Assert.Equal("newsaskey", newCsb.SasKey); }
/// <summary> /// Attempts to connect to Azure Event Hub database. /// </summary> protected override void AttemptConnection() { try { // Establish data event hub connection EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(EventHubDataClientConnectionString) { EntityPath = EventHubDataClientName }; m_eventHubDataClient = EventHubClient.CreateFromConnectionString(builder.ToString()); if (string.IsNullOrWhiteSpace(EventHubMetadataClientConnectionString)) { m_eventHubMetadataClient = m_eventHubDataClient; } else { // Establish meta-data event hub connection builder = new EventHubsConnectionStringBuilder(EventHubMetadataClientConnectionString) { EntityPath = string.IsNullOrWhiteSpace(EventHubMetadataClientName) ? EventHubDataClientName : EventHubMetadataClientName }; m_eventHubMetadataClient = EventHubClient.CreateFromConnectionString(builder.ToString()); } m_connectionResponse = "Connected"; } catch (Exception ex) { // Hang onto response for status logging m_connectionResponse = ex.Message; // Re-throw any captured exceptions, this will restart connection cycle as needed throw; } }
private static IEventHubReceiver CreateReceiver(EventHubPartitionSettings partitionSettings, string offset, ILogger logger, ITelemetryProducer telemetryProducer) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(partitionSettings.Hub.ConnectionString) { EntityPath = partitionSettings.Hub.Path }; EventHubClient client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); EventPosition eventPosition; // If we have a starting offset, read from offset if (offset != EventHubConstants.StartOfStream) { logger.Info("Starting to read from EventHub partition {0}-{1} at offset {2}", partitionSettings.Hub.Path, partitionSettings.Partition, offset); eventPosition = EventPosition.FromOffset(offset, true); } // else, if configured to start from now, start reading from most recent data else if (partitionSettings.ReceiverOptions.StartFromNow) { eventPosition = EventPosition.FromEnd(); logger.Info("Starting to read latest messages from EventHub partition {0}-{1}.", partitionSettings.Hub.Path, partitionSettings.Partition); } else // else, start reading from begining of the partition { eventPosition = EventPosition.FromStart(); logger.Info("Starting to read messages from begining of EventHub partition {0}-{1}.", partitionSettings.Hub.Path, partitionSettings.Partition); } PartitionReceiver receiver = client.CreateReceiver(partitionSettings.Hub.ConsumerGroup, partitionSettings.Partition, eventPosition); if (partitionSettings.ReceiverOptions.PrefetchCount.HasValue) { receiver.PrefetchCount = partitionSettings.ReceiverOptions.PrefetchCount.Value; } return(new EventHubReceiverProxy(receiver)); }
private static async Task MainAsync(string[] args) { // Creates an EventHubsConnectionStringBuilder object from a the connection string, and sets the EntityPath. // Typically the connection string should have the Entity Path in it, but for the sake of this simple scenario // we are using the connection string from the namespace. var connectionStringBuilder = new EventHubsConnectionStringBuilder(EhConnectionString) { EntityPath = EhEntityPath }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); var rec = eventHubClient.CreateReceiver("$Default", "0", new DateTime(2017 / 02 / 26)); await SendMessagesToEventHub(100); int idxread = 0; while (true) { var t = await rec.ReceiveAsync(100); if (t == null || t.Count() == 0) { break; } foreach (var a in t) { idxread++; Console.WriteLine("idxread:" + idxread + " *->" + Encoding.UTF8.GetString(a.Body.Array)); } } Console.WriteLine("ya sali de la cola."); await eventHubClient.CloseAsync(); Console.WriteLine("Press any key to exit."); Console.ReadLine(); }
private static async Task StartEventGenerationAsync(CancellationToken cancellationToken) { var random = new Random((int)DateTimeOffset.UtcNow.Ticks); var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; EventHubClient client = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); while (!cancellationToken.IsCancellationRequested) { try { // Simulate sending data from 100 weather sensors var devicesData = new List <EventData>(); for (int i = 0; i < 100; i++) { int scaleFactor = random.Next(0, 25); var windTurbineMeasure = GenerateTurbineMeasure("Turbine_" + i, scaleFactor); EventData evData = SerializeWindTurbineToEventData(windTurbineMeasure); devicesData.Add(evData); } Console.Write("."); await client.SendAsync(devicesData); } catch (Exception ex) { Debug.WriteLine("Error generating turbine data. Exception: {0}", ex); Console.Write("E"); } await Task.Delay(1000, cancellationToken); } }
private static async Task MainEventHubAsync(string[] args) { WriteLine("Enter your Event Hub connection string:"); var EventHubConnectionString = ReadLine(); while (EventHubConnectionString.Length == 0) { WriteLine("Try again, this value must have a length > 0"); WriteLine("Enter your Event Hub connection string:"); EventHubConnectionString = ReadLine(); } WriteLine("Enter your Event Hub name:"); var EventHubName = ReadLine(); while (EventHubName.Length == 0) { WriteLine("Try again, this value must have a length > 0"); WriteLine("Enter your Event Hub name:"); EventHubName = ReadLine(); } WriteLine("Enter number of events to add: "); int EventHubEventsToSend = 0; while (!int.TryParse(ReadLine(), out EventHubEventsToSend)) { WriteLine("Try again, this value must be numeric."); } var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); await SendMessagesToEventHub(EventHubEventsToSend); await eventHubClient.CloseAsync(); }
/// <summary> /// The most detailed method with full fragmentation /// </summary> /// <param name="endpointAddress">Endpoint address</param> /// <param name="entityPath">Entity path</param> /// <param name="sharedAccessKeyName">Shared access key name</param> /// <param name="sharedAccessKey">Shared access key value</param> /// <returns></returns> public static AzureEventHubPublisher Create(Uri endpointAddress, string entityPath, string sharedAccessKeyName, string sharedAccessKey) { if (endpointAddress == null) { throw new ArgumentNullException(nameof(endpointAddress)); } if (entityPath == null) { throw new ArgumentNullException(nameof(entityPath)); } if (sharedAccessKeyName == null) { throw new ArgumentNullException(nameof(sharedAccessKeyName)); } if (sharedAccessKey == null) { throw new ArgumentNullException(nameof(sharedAccessKey)); } var csb = new EventHubsConnectionStringBuilder(endpointAddress, entityPath, sharedAccessKeyName, sharedAccessKey); return(new AzureEventHubPublisher(csb.ToString())); }
static void ReceiveMessages(string partitionId) { var connectionStringBuilder = new EventHubsConnectionStringBuilder("[Event Hub Connection String]") { EntityPath = "number-egress" }; var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); var receiver = eventHubClient.CreateEpochReceiver("$Default", partitionId, DateTime.Now, 1); while (true) { var data = receiver.ReceiveAsync(5).Result; if (data != null) { Console.ForegroundColor = ConsoleColor.Green; foreach (var item in data) { Console.WriteLine("{0} - {2} > Data: {1}", DateTime.Now, Encoding.UTF8.GetString(item.Body.Array), partitionId); } Console.ResetColor(); } } }
static void Main(string[] args) { var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHub }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); SetTimer(); if (eventHubClient == null) { Console.WriteLine("Failed to create EventHub Client!"); //SensorTimer.Stop(); } Console.WriteLine("\nPress the Enter key to exit the application...\n"); Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now); Console.ReadLine(); //SensorTimer.Stop(); //SensorTimer.Dispose(); }
static void Main() { var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubEntityPath }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); var boiler1 = new Thermometer { DeviceName = "Boiler 01" }; while (true) { var eventDataJson = boiler1.GetTemperatureMessage(); Console.WriteLine("Sending message: " + eventDataJson); var eventData = new EventData(Encoding.UTF8.GetBytes(eventDataJson)); eventHubClient.SendAsync(eventData).Wait(); System.Threading.Thread.Sleep(500); } }
private static async Task AsyncMain() { var connectionString = new EventHubsConnectionStringBuilder(new Uri(config.EventHubsCompatibleEndpoint), config.EventHubsCompatiblePath, config.IotHubSasKeyName, config.IotHubSasKey); s_eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString()); // Let's create a PartitionReciever for each partition on the hub. var runtimeInfo = await s_eventHubClient.GetRuntimeInformationAsync(); var d2cPartitions = runtimeInfo.PartitionIds; var tasks = new List <Task>(); //let's asign each partitionreceiver to one task foreach (string partition in d2cPartitions) { tasks.Add(ReceiveMessagesFromDeviceAsync(partition)); } // Wait for all the PartitionReceivers to finsih. Task.WaitAll(tasks.ToArray()); }
public async Task NonexsistentEntity() { // Rebuild connection string with a nonexistent entity. var csb = new EventHubsConnectionStringBuilder(TestUtility.EventHubsConnectionString); csb.EntityPath = Guid.NewGuid().ToString(); var eventProcessorHost = new EventProcessorHost( string.Empty, PartitionReceiver.DefaultConsumerGroupName, csb.ToString(), TestUtility.StorageConnectionString, this.LeaseContainerName); TestUtility.Log("Calling RegisterEventProcessorAsync for a nonexistent entity."); var ex = await Assert.ThrowsAsync <EventProcessorConfigurationException>(async() => { await eventProcessorHost.RegisterEventProcessorAsync <TestEventProcessor>(); }); Assert.NotNull(ex.InnerException); Assert.IsType <MessagingEntityNotFoundException>(ex.InnerException); }
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()); var tokenSource = new CancellationTokenSource(); var ct = tokenSource.Token; Task.Run(() => ReceiveMessagesFromPartition("2", ct), ct); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); tokenSource.Cancel(); await eventHubClient.CloseAsync(); }
//public async Task MainAsync(ga_payload gap) public async Task MainAsync(Games games) { // Creates an EventHubsConnectionStringBuilder object from a the connection string, and sets the EntityPath. // Typically the connection string should have the Entity Path in it, but for the sake of this simple scenario // we are using the connection string from the namespace. var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); //await SendMessagesToEventHub(100); //await SendMessagesToEventHub(gap); //UPDATED await SendMessagesToEventHub(games); await eventHubClient.CloseAsync(); //Console.WriteLine("Press any key to exit."); //Console.ReadLine(); }
static void EventHubIngestion() { // updated with .net core var connectionStringBuilder = new EventHubsConnectionStringBuilder(connectionString) { EntityPath = eventHubName }; var eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); long counter = 0; while (true) { // https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.parallel.for?view=netcore-3.1 Parallel.For(1, numthread, (i, state) => { try { string recordString = $"MODEL_{GetRandomNumber(0, 100)}"; EventData eventData = new EventData(Encoding.UTF8.GetBytes(recordString)); eventHubClient.SendAsync(eventData); } catch (Exception exception) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("{0} > Exception: {1}", DateTime.Now, exception.Message); Console.ResetColor(); } Thread.Sleep(1000); }); counter++; Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine($"Iteration {counter} done"); } }
public Task <bool> Submit(EventHubInfo eventHubInfo) { var status = default(bool); try { if (eventHubInfo == default(EventHubInfo)) { throw new ArgumentNullException(nameof(eventHubInfo)); } var sensorReadings = faker.Generate(eventHubInfo.NoOfMessages); var ehConnectionStringBuilder = new EventHubsConnectionStringBuilder(eventHubInfo.EventHubConnectionString) { EntityPath = eventHubInfo.EventHubPath }; var eventHubClient = EventHubClient.CreateFromConnectionString(ehConnectionStringBuilder.ToString()); foreach (var reading in sensorReadings) { var jsonString = JsonConvert.SerializeObject(reading); var eventDataBytes = Encoding.ASCII.GetBytes(jsonString); var eventData = new EventData(eventDataBytes); eventHubClient.SendAsync(eventData); } status = true; } catch (Exception exceptionObject) { status = false; } return(Task.FromResult(status)); }
public static async Task <string> Run([ActivityTrigger] EventHubJobProperties ehJobProperties, ILogger log) { try { EventHubsConnectionStringBuilder connectionStringBuilder = new EventHubsConnectionStringBuilder(ehJobProperties.ConnectionString) { EntityPath = ehJobProperties.EventHub }; string connectionString = connectionStringBuilder.ToString(); EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(connectionString); int secondsPerJobBatch = Convert.ToInt16(Environment.GetEnvironmentVariable("secondsPerBatch")); int messagesInJobBatch = ehJobProperties.Frequency * secondsPerJobBatch; int messagesPerSend = 250; IEnumerable <string> messages = Messages.CreateMessages(messagesInJobBatch, ehJobProperties.MessageScheme); while (messages.Count() > 0) { var messagesToSend = messages.Take(messagesPerSend); var ehMessages = messagesToSend.Select(m => new EventData(Encoding.UTF8.GetBytes(m))); await eventHubClient.SendAsync(ehMessages); messages = messages.Skip(messagesPerSend); } await eventHubClient.CloseAsync(); log.LogInformation($"sent batch of {messagesInJobBatch} messages"); return($"finished sending {messagesInJobBatch} to {ehJobProperties.EventHub}!"); } catch (Exception exception) { log.LogInformation($"Exception: {exception.Message}"); return($"Exception: {exception.Message}"); } }
static async Task Main(string[] args) { Console.WriteLine("Read temperature messages. Ctrl-C to exit.\n"); IConfiguration config = new ConfigurationBuilder() .AddJsonFile("conf.json", true, true) .Build(); serviceClient = ServiceClient.CreateFromConnectionString(config["IotHubConnectionString"]); var connectionString = new EventHubsConnectionStringBuilder(new Uri(config["EventHubsCompatibleEndpoint"]), config["EventHubsCompatiblePath"], config["IotHubSasKeyName"], config["IotHubSasKey"]); s_eventHubClient = EventHubClient.CreateFromConnectionString(connectionString.ToString()); var runtimeInfo = await s_eventHubClient.GetRuntimeInformationAsync(); var d2cPartitions = runtimeInfo.PartitionIds; CancellationTokenSource cts = new CancellationTokenSource(); Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); }; var tasks = new List <Task>(); foreach (string partition in d2cPartitions) { tasks.Add(ReceiveMessagesFromDeviceAsync(partition, cts.Token)); } Task.WaitAll(tasks.ToArray()); Console.ReadLine(); }
static async Task <string> GetHelloWorldAsync() { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json", true, true) .AddEnvironmentVariables(); builder.AddUserSecrets <Program>(); var config = builder.Build(); var mySettings = config.GetSection("mySettings").Get <MySettings>(); Console.WriteLine($"EventHubName:{mySettings.EventHubName}"); Console.WriteLine($"EventHubConnectionString:{mySettings.EventHubConnectionString}"); EventHubName = mySettings.EventHubName; EventHubConnectionString = mySettings.EventHubConnectionString; // Creates an EventHubsConnectionStringBuilder object from a the connection string, and sets the EntityPath. // Typically the connection string should have the Entity Path in it, but for the sake of this simple scenario // we are using the connection string from the namespace. var connectionStringBuilder = new EventHubsConnectionStringBuilder(EventHubConnectionString) { EntityPath = EventHubName }; eventHubClient = EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString()); await SendMessagesToEventHub(100); await eventHubClient.CloseAsync(); Console.WriteLine("Press any key to exit."); Console.ReadLine(); return($" Hello { config["name"] } and {mySettings.Name} !"); }