private static async Task <EventGridEdgeClient> GetEventGridClientAsync(GridConfiguration gridConfig) { string[] urlTokens = gridConfig.Url.Split(":"); if (urlTokens.Length != 3) { throw new Exception($"URL should be of the form '<protocol>://<moduleName>:<portNo>' "); } string baseUrl = urlTokens[0] + ":" + urlTokens[1]; int port = int.Parse(urlTokens[2], CultureInfo.InvariantCulture); if (gridConfig.ClientAuth.Source.Equals("IoTEdge", StringComparison.OrdinalIgnoreCase)) { SecurityDaemonClient iotSecurity = new SecurityDaemonClient(); (X509Certificate2 identityCertificate, IEnumerable <X509Certificate2> chain) = await iotSecurity.GetIdentityCertificateAsync(); return(new EventGridEdgeClient(baseUrl, port, new CustomHttpClientFactory(chain.First(), identityCertificate))); } else if (gridConfig.ClientAuth.Source.Equals("BearerToken", StringComparison.OrdinalIgnoreCase)) { EventGridEdgeClient egClient = new EventGridEdgeClient(baseUrl, port); HttpRequestHeaders defaultMgmtRequestHeaders = egClient.HttpClient.DefaultRequestHeaders; defaultMgmtRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", $"{gridConfig.ClientAuth.Token1}"); HttpRequestHeaders defaultRuntimeRequestHeaders = egClient.HttpClient.DefaultRequestHeaders; defaultRuntimeRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", $"{gridConfig.ClientAuth.Token1}"); } throw new Exception("Cannot create eventgrid client!"); }
public static async Task Main() { Console.WriteLine($"[INFO] - Wait a few minutes for Event Grid module to come up..."); Thread.Sleep(initialDelay); Console.WriteLine($"[INFO] - EventGrid URL: {eventGridURL}"); EventGridEdgeClient egClient = new EventGridEdgeClient(eventGridBaseAddress, eventGridHTTPPort); Console.WriteLine($"[INFO] - Check if topic '{topicName}' exists..."); var createdTopic = await egClient.Topics.GetTopicAsync(topicName : topicName, CancellationToken.None).ConfigureAwait(false); if (createdTopic == null) { Console.WriteLine($"[ERROR] - Failed to retrieve topic '{topicName}'. Exiting."); return; } Console.WriteLine($"[ERROR] - Successfully retrieved topic '{topicName}'."); Console.WriteLine($"[INFO] - Start publishing events to topic '{topicName}'"); while (true) { EventGridEvent evt = GetEvent(); egClient.Events.PublishAsync(topicName: topicName, new List <EventGridEvent>() { evt }, CancellationToken.None).GetAwaiter().GetResult(); Console.WriteLine($"\n[INFO] - Published event: {JsonConvert.SerializeObject(evt)}"); } }
public static async Task Main() { var resetEvent = new ManualResetEventSlim(); // signals to long running components when to power down (either due to a Ctrl+C, or Ctrl-Break, or SIGTERM, or SIGKILL) CancellationTokenSource lifetimeCts = SetupGracefulShutdown(resetEvent); SubscriberHost host = SetupSubscriberHostAsync(lifetimeCts).GetAwaiter().GetResult(); IConfigurationSection hostConfigurationSection = GetHostConfigurationSection(); if (ShouldAutoCreateSubscription()) { GridConfiguration gridConfig = GetGridConfiguration(); EventGridEdgeClient egClient = GetEventGridClientAsync(gridConfig).GetAwaiter().GetResult(); // certificate issued by IoT Edge takes a while to be current so will wait for a bit Thread.Sleep(120 * 1000); // wait for topic to exist await WaitUntilEventGridModuleIsUpAndTopicExistsAsync(egClient, gridConfig.Topic.Name).ConfigureAwait(false); // register subscription await RegisterSubscriptionAsync(egClient, gridConfig).ConfigureAwait(false); } // wait until shutdown await host.WaitForShutdownAsync().ConfigureAwait(false); // signal to gracefully shutdown resetEvent.Set(); }
public static async Task Main() { Console.WriteLine($"\nWaiting a few minute(s) to create topic '{topicName}' ...\n"); Thread.Sleep(initialDelay); Console.WriteLine($"EventGrid Module's URL: {eventGridBaseAddress}:{eventGridPort}"); EventGridEdgeClient egClient = new EventGridEdgeClient(eventGridBaseAddress, eventGridPort); // create topic Topic topic = new Topic() { Name = topicName, Properties = new TopicProperties() { InputSchema = topicSchema } }; var createdTopic = await egClient.Topics.PutTopicAsync(topicName : topicName, topic : topic, CancellationToken.None).ConfigureAwait(false); Console.WriteLine($"Created topic with Name: {topic.Name}, Schema: {topic.Properties.InputSchema} ..."); // the recommendation is to create subscribers from subscription modules or a "management" module. for the purposes of quickstart we are creating it here. EventSubscription eventSubscription = new EventSubscription() { Name = subscriptionName, Properties = new EventSubscriptionProperties { Topic = topicName, EventDeliverySchema = deliverySchema, Destination = new WebHookEventSubscriptionDestination() { EndpointType = "Webhook", Properties = new WebHookEventSubscriptionDestinationProperties() { EndpointUrl = subscriberUrl, } } } }; var createdSubscription = await egClient.Subscriptions.PutSubscriptionAsync(topicName : topicName, subscriptionName : subscriptionName, eventSubscription : eventSubscription, CancellationToken.None).ConfigureAwait(false); Console.WriteLine($"Created subscription with Name: {createdSubscription.Name}, Schema: {topic.Properties.InputSchema}, EndpointUrl: {subscriberUrl} for topic: {topic.Name} ..."); Console.WriteLine($"\nWaiting a few minute(s) before publishing events ...\n"); Thread.Sleep(initialDelay); // keep publishing events while (true) { EventGridEvent evt = GetEvent(); Console.WriteLine($"\nPublishing event: {JsonConvert.SerializeObject(evt)}"); egClient.Events.PublishJsonAsync(topicName: topicName, (new List <EventGridEvent>() { evt }), ApplicationJsonMTHV, CancellationToken.None).GetAwaiter().GetResult(); } }
private static async Task RegisterSubscriptionAsync(EventGridEdgeClient egClient, GridConfiguration gridConfig) { string topicName = gridConfig.Topic.Name; // create subscription EventSubscription eventSubscription = CreateEventSubscription(gridConfig); using (CancellationTokenSource cts = new CancellationTokenSource(30 * 1000)) { await egClient.Subscriptions.PutSubscriptionAsync(topicName : topicName, subscriptionName : eventSubscription.Name, eventSubscription : eventSubscription, cts.Token).ConfigureAwait(false); Console.WriteLine($"Successfully created subscription {JsonConvert.SerializeObject(eventSubscription)} for topic {topicName}"); } }
private static async Task WaitUntilEventGridModuleIsUpAndTopicExistsAsync( GridConfiguration gridConfig, EventGridEdgeClient egClient, CancellationToken cancellationToken) { InputSchema inputSchema = GetTopicInputSchema(gridConfig); Topic topic = new Topic { Name = gridConfig.Topic.Name, Properties = new TopicProperties() { InputSchema = inputSchema, }, }; while (true) { if (cancellationToken.IsCancellationRequested) { break; } try { using (CancellationTokenSource cts = new CancellationTokenSource(30 * 1000)) { var createdTopic = await egClient.Topics.PutTopicAsync(topicName : topic.Name, topic : topic, cts.Token).ConfigureAwait(false); Console.WriteLine($"Successfully created topic with name {topic.Name} so event grid must be up..."); break; } } catch (EventGridApiException e) { LogAndBackoff(topic.Name, e); } catch (HttpRequestException e) { LogAndBackoff(topic.Name, e); } } }
public static async Task Main() { var resetEvent = new ManualResetEventSlim(); // signals to long running components when to power down (either due to a Ctrl+C, or Ctrl-Break, or SIGTERM, or SIGKILL) CancellationTokenSource lifetimeCts = SetupGracefulShutdown(resetEvent); GridConfiguration gridConfig = GetGridConfiguration(); EventGridEdgeClient egClient = GetEventGridClientAsync(gridConfig).GetAwaiter().GetResult(); // certificate issued by IoT Edge takes a while to be current so will wait for a bit int delay = gridConfig.InitialDelayInSeconds * 1000; Thread.Sleep(delay); // wait for eventgrid module to come up await WaitUntilEventGridModuleIsUpAndTopicExistsAsync(gridConfig, egClient, lifetimeCts.Token).ConfigureAwait(false); // setup eventgrid topic and publish await PublishEventsAsync(gridConfig, egClient, lifetimeCts.Token).ConfigureAwait(false); resetEvent.Set(); }
private static async Task PublishEventsAsync( GridConfiguration gridConfig, EventGridEdgeClient egClient, CancellationToken cancellationToken) { Console.WriteLine($"Will publish events every {gridConfig.PublishIntervalInSeconds} seconds"); string topicName = gridConfig.Topic.Name; InputSchema inputSchema = GetTopicInputSchema(gridConfig); int publishIntervalInSeconds = gridConfig.PublishIntervalInSeconds; while (true) { if (cancellationToken.IsCancellationRequested) { break; } try { using (CancellationTokenSource cts = new CancellationTokenSource(30 * 1000)) { EventGridEvent evtPayload = (EventGridEvent)CreateEvent(topicName, inputSchema); await egClient.Events.PublishJsonAsync(topicName : topicName, evtPayload.Id, payload : evtPayload, contentType : ApplicationJsonMTHV, cts.Token).ConfigureAwait(false); Console.WriteLine($"Published event {JsonConvert.SerializeObject(evtPayload)} to eventgrid module ..."); Console.WriteLine(); } } catch (Exception e) { Console.WriteLine($"Failed to publish event to topic {topicName}. Reason: {e.ToString()}"); } Thread.Sleep(publishIntervalInSeconds * 1000); } }
private static async Task WaitUntilEventGridModuleIsUpAndTopicExistsAsync(EventGridEdgeClient egClient, string topicName) { while (true) { try { using (CancellationTokenSource cts = new CancellationTokenSource(30 * 1000)) { var topic = await egClient.Topics.GetTopicAsync(topicName : topicName, cts.Token).ConfigureAwait(false); Console.WriteLine($"Successfully retrieved topic with name {topicName} so event grid must be up..."); break; } } catch (EventGridApiException e) { LogAndBackoff(topicName, e); } catch (HttpRequestException e) { LogAndBackoff(topicName, e); } } }