static async Task Main(string[] args) { Logger.LogInformation($"Starting Relayer with the following settings: \r\n{Settings.Current}"); ModuleClient moduleClient = null; try { moduleClient = await ModuleUtil.CreateModuleClientAsync( Settings.Current.TransportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); // Receive a message and call ProcessAndSendMessageAsync to send it on its way await moduleClient.SetInputMessageHandlerAsync(Settings.Current.InputName, ProcessAndSendMessageAsync, moduleClient); await cts.Token.WhenCanceled(); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); Logger.LogInformation("Relayer Main() finished."); } catch (Exception ex) { Logger.LogError(ex, "Error occurred during Relayer."); } finally { moduleClient?.CloseAsync(); moduleClient?.Dispose(); } }
private void InitializeClient() { // If the client reports Connected status, it is already in operational state. if (s_connectionStatus != ConnectionStatus.Connected && _moduleConnectionStrings.Any()) { lock (_initLock) { _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}"); // If the module client instance has been previously initialized, then dispose it. // The s_wasEverConnected variable is required to store if the client ever reported Connected status. if (s_wasEverConnected && s_connectionStatus == ConnectionStatus.Disconnected) { s_moduleClient?.Dispose(); s_wasEverConnected = false; } s_moduleClient = ModuleClient.CreateFromConnectionString(_moduleConnectionStrings.First(), _transportType); s_moduleClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler); s_moduleClient.OperationTimeoutInMilliseconds = (uint)s_operationTimeout.TotalMilliseconds; } try { // Force connection now s_moduleClient.OpenAsync().GetAwaiter().GetResult(); _logger.LogDebug($"Initialized the client instance."); } catch (UnauthorizedException) { // Handled by the ConnectionStatusChangeHandler } } }
static async Task Main() { Logger.LogInformation($"Starting load gen with the following settings:\r\n{Settings.Current}"); ModuleClient moduleClient = null; try { (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); Guid batchId = Guid.NewGuid(); Logger.LogInformation($"Batch Id={batchId}"); ClientOptions options = new ClientOptions(); Settings.Current.ModelId.ForEach(m => options.ModelId = m); moduleClient = await ModuleUtil.CreateModuleClientAsync( Settings.Current.TransportType, options, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); Logger.LogInformation($"Load gen delay start for {Settings.Current.TestStartDelay}."); await Task.Delay(Settings.Current.TestStartDelay); LoadGenSenderBase sender; switch (Settings.Current.SenderType) { case LoadGenSenderType.PriorityMessageSender: sender = new PriorityMessageSender(Logger, moduleClient, batchId, Settings.Current.TrackingId); break; case LoadGenSenderType.DefaultSender: default: sender = new DefaultMessageSender(Logger, moduleClient, batchId, Settings.Current.TrackingId); break; } DateTime testStartAt = DateTime.UtcNow; await sender.RunAsync(cts, testStartAt); Logger.LogInformation("Finish sending messages."); await cts.Token.WhenCanceled(); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); } catch (Exception ex) { Logger.LogError(ex, "Error occurred during load gen."); } finally { Logger.LogInformation("Closing connection to Edge Hub."); moduleClient?.CloseAsync(); moduleClient?.Dispose(); } Logger.LogInformation("Load Gen complete. Exiting."); }
static async Task Main() { Logger.LogInformation($"Starting load gen with the following settings:\r\n{Settings.Current}"); ModuleClient moduleClient = null; try { (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); Guid batchId = Guid.NewGuid(); Logger.LogInformation($"Batch Id={batchId}"); moduleClient = await ModuleUtil.CreateModuleClientAsync( Settings.Current.TransportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); Logger.LogInformation($"Load gen delay start for {Settings.Current.TestStartDelay}."); await Task.Delay(Settings.Current.TestStartDelay); DateTime testStartAt = DateTime.UtcNow; long messageIdCounter = 1; while (!cts.IsCancellationRequested && (Settings.Current.TestDuration == TimeSpan.Zero || DateTime.UtcNow - testStartAt < Settings.Current.TestDuration)) { try { await SendEventAsync(moduleClient, batchId, Settings.Current.TrackingId, messageIdCounter); messageIdCounter++; await Task.Delay(Settings.Current.MessageFrequency); if (messageIdCounter % 1000 == 0) { Logger.LogInformation($"Sent {messageIdCounter} messages."); } } catch (Exception ex) { Logger.LogError(ex, $"[SendEventAsync] Sequence number {messageIdCounter}, BatchId: {batchId.ToString()};"); } } Logger.LogInformation("Closing connection to Edge Hub."); await moduleClient.CloseAsync(); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); } catch (Exception ex) { Logger.LogError(ex, "Error occurred during load gen."); moduleClient?.Dispose(); } Logger.LogInformation("Load Gen complete. Exiting."); }
public Task StopAsync(CancellationToken cancellationToken) { logger.LogInformation("Stopping"); ctSource.Cancel(); moduleClient?.Dispose(); return(Task.CompletedTask); }
/// <summary> /// Invalidate all game modules. /// </summary> private void InvalidateModules() { ModuleEngine?.Dispose(); ModuleEngine = default; ModuleClient?.Dispose(); ModuleClient = default; Process?.Dispose(); Process = default; }
static async Task <int> MainAsync() { (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); Logger.LogInformation($"Starting metrics collector with the following settings:\r\n{Settings.Current}"); MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); ITransportSettings[] transportSettings = { mqttSetting }; ModuleClient moduleClient = null; try { moduleClient = await ModuleClient.CreateFromEnvironmentAsync(transportSettings); Dictionary <string, string> additionalTags = await GetAdditionalTagsFromTwin(moduleClient); MetricsScraper scraper = new MetricsScraper(Settings.Current.Endpoints); IMetricsPublisher publisher; if (Settings.Current.UploadTarget == UploadTarget.AzureLogAnalytics) { publisher = new LogAnalyticsUpload(Settings.Current.LogAnalyticsWorkspaceId, Settings.Current.LogAnalyticsWorkspaceKey, Settings.Current.LogAnalyticsLogType); } else { publisher = new EventHubMetricsUpload(moduleClient); } using (MetricsScrapeAndUpload metricsScrapeAndUpload = new MetricsScrapeAndUpload(scraper, publisher, additionalTags)) { TimeSpan scrapeAndUploadInterval = TimeSpan.FromSeconds(Settings.Current.ScrapeFrequencySecs); metricsScrapeAndUpload.Start(scrapeAndUploadInterval); await cts.Token.WhenCanceled(); } } catch (Exception e) { Logger.LogError(e, "Error occurred during metrics collection setup."); } finally { moduleClient?.Dispose(); } completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); Logger.LogInformation("MetricsCollector Main() finished."); return(0); }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } // Dispose of managed resources here. if (disposing) { _moduleClient?.Dispose(); } // Dispose of any unmanaged resources not wrapped in safe handles. _disposed = true; }
private async Task SendMessageModuleMuxedOverAmqp( Client.TransportType transport, int poolSize, int devicesCount, bool useSameDevice = false) { var transportSettings = new ITransportSettings[] { new AmqpTransportSettings(transport) { AmqpConnectionPoolSettings = new AmqpConnectionPoolSettings() { MaxPoolSize = unchecked ((uint)poolSize), Pooling = true } } }; ICollection <ModuleClient> moduleClients = new List <ModuleClient>(); Dictionary <ModuleClient, int> moduleClientConnectionStatusChangeCount = new Dictionary <ModuleClient, int>(); try { _log.WriteLine($"{nameof(MessageSendE2EMultiplexingTests)}: Starting the test execution for {devicesCount} modules"); for (int i = 0; i < devicesCount; i++) { ConnectionStatus? lastConnectionStatus = null; ConnectionStatusChangeReason?lastConnectionStatusChangeReason = null; int setConnectionStatusChangesHandlerCount = 0; string devicePrefix = useSameDevice ? DevicePrefix : $"{DevicePrefix}_{i}_"; string modulePrefix = useSameDevice ? $"{ModulePrefix}_{i}_" : ModulePrefix; TestModule testModule = await TestModule.GetTestModuleAsync(devicePrefix, modulePrefix).ConfigureAwait(false); ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings); moduleClients.Add(moduleClient); moduleClient.SetConnectionStatusChangesHandler((status, statusChangeReason) => { setConnectionStatusChangesHandlerCount++; lastConnectionStatus = status; lastConnectionStatusChangeReason = statusChangeReason; _log.WriteLine($"{nameof(MessageSendE2EMultiplexingTests)}.{nameof(ConnectionStatusChangesHandler)}: status={status} statusChangeReason={statusChangeReason} count={setConnectionStatusChangesHandlerCount}"); moduleClientConnectionStatusChangeCount[moduleClient] = setConnectionStatusChangesHandlerCount; }); _log.WriteLine($"{nameof(MessageSendE2EMultiplexingTests)}: Preparing to send message for module {i}"); await moduleClient.OpenAsync().ConfigureAwait(false); await MessageSend.SendSingleMessageModuleAndVerifyAsync(moduleClient, testModule.DeviceId).ConfigureAwait(false); } } finally { // Close and dispose all of the module client instances here foreach (ModuleClient moduleClient in moduleClients) { await moduleClient.CloseAsync().ConfigureAwait(false); // The connection status change count should be 2: connect (open) and disabled (close) Assert.IsTrue(moduleClientConnectionStatusChangeCount[moduleClient] == 2, $"Connection status change count for deviceClient {TestLogging.GetHashCode(moduleClient)} is {moduleClientConnectionStatusChangeCount[moduleClient]}"); _log.WriteLine($"{nameof(MessageSendE2EMultiplexingTests)}: Disposing moduleClient {TestLogging.GetHashCode(moduleClient)}"); moduleClient.Dispose(); } } }
static async Task Main() { Logger.LogInformation($"Starting load gen with the following settings:\r\n{Settings.Current}"); ModuleClient moduleClient = null; try { (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); Guid batchId = Guid.NewGuid(); Logger.LogInformation($"Batch Id={batchId}"); moduleClient = await ModuleUtil.CreateModuleClientAsync( Settings.Current.TransportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); Logger.LogInformation($"Load gen delay start for {Settings.Current.TestStartDelay}."); await Task.Delay(Settings.Current.TestStartDelay); DateTime testStartAt = DateTime.UtcNow; long messageIdCounter = 1; while (!cts.IsCancellationRequested && (Settings.Current.TestDuration == TimeSpan.Zero || DateTime.UtcNow - testStartAt < Settings.Current.TestDuration)) { try { await SendEventAsync(moduleClient, batchId, Settings.Current.TrackingId, messageIdCounter); // Report sending message successfully to Test Result Coordinator await Settings.Current.TestResultCoordinatorUrl.ForEachAsync( async trcUrl => { Uri testResultCoordinatorUrl = new Uri( trcUrl, UriKind.Absolute); TestResultCoordinatorClient trcClient = new TestResultCoordinatorClient { BaseUrl = testResultCoordinatorUrl.AbsoluteUri }; await ModuleUtil.ReportStatus( trcClient, Logger, Settings.Current.ModuleId + ".send", ModuleUtil.FormatMessagesTestResultValue( Settings.Current.TrackingId, batchId.ToString(), messageIdCounter.ToString()), TestOperationResultType.Messages.ToString()); }); if (messageIdCounter % 1000 == 0) { Logger.LogInformation($"Sent {messageIdCounter} messages."); } await Task.Delay(Settings.Current.MessageFrequency); messageIdCounter++; } catch (Exception ex) { Logger.LogError(ex, $"[SendEventAsync] Sequence number {messageIdCounter}, BatchId: {batchId.ToString()};"); } } Logger.LogInformation("Finish sending messages."); await cts.Token.WhenCanceled(); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); } catch (Exception ex) { Logger.LogError(ex, "Error occurred during load gen."); } finally { Logger.LogInformation("Closing connection to Edge Hub."); moduleClient?.CloseAsync(); moduleClient?.Dispose(); } Logger.LogInformation("Load Gen complete. Exiting."); }
public static async Task <int> MainAsync() { Logger.LogInformation($"Starting DirectMethodSender with the following settings:\r\n{Settings.Current}"); (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger); DirectMethodSenderBase directMethodClient = null; ModuleClient reportClient = null; Option <Uri> analyzerUrl = Settings.Current.AnalyzerUrl; Option <Uri> testReportCoordinatorUrl = Settings.Current.TestResultCoordinatorUrl; try { Guid batchId = Guid.NewGuid(); Logger.LogInformation($"Batch Id={batchId}"); directMethodClient = await CreateClientAsync(Settings.Current.InvocationSource); reportClient = await ModuleUtil.CreateModuleClientAsync( Settings.Current.TransportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); Logger.LogInformation($"Load gen delay start for {Settings.Current.TestStartDelay}."); await Task.Delay(Settings.Current.TestStartDelay, cts.Token); DateTime testStartAt = DateTime.UtcNow; while (!cts.Token.IsCancellationRequested && IsTestTimeUp(testStartAt)) { (HttpStatusCode result, long dmCounter) = await directMethodClient.InvokeDirectMethodAsync(cts); // TODO: Create an abstract class to handle the reporting client generation if (testReportCoordinatorUrl.HasValue) { await testReportCoordinatorUrl.ForEachAsync( async (Uri uri) => { TestResultCoordinatorClient trcClient = new TestResultCoordinatorClient { BaseUrl = uri.AbsoluteUri }; await ModuleUtil.ReportStatus( trcClient, Logger, Settings.Current.ModuleId + ".send", ModuleUtil.FormatDirectMethodTestResultValue( Settings.Current.TrackingId.Expect(() => new ArgumentException("TrackingId is empty")), batchId.ToString(), dmCounter.ToString(), result.ToString()), TestOperationResultType.DirectMethod.ToString()); }); } else { await analyzerUrl.ForEachAsync( async (Uri uri) => { AnalyzerClient analyzerClient = new AnalyzerClient { BaseUrl = uri.AbsoluteUri }; await ReportStatus(Settings.Current.TargetModuleId, result, analyzerClient); }, async() => { await reportClient.SendEventAsync("AnyOutput", new Message(Encoding.UTF8.GetBytes("Direct Method call succeeded."))); }); } await Task.Delay(Settings.Current.DirectMethodDelay, cts.Token); } await cts.Token.WhenCanceled(); } catch (Exception e) { Logger.LogError(e, "Error occurred during direct method sender test setup"); } finally { // Implicit CloseAsync() directMethodClient?.Dispose(); reportClient?.Dispose(); } completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); Logger.LogInformation("DirectMethodSender Main() finished."); return(0); }
/// <inheritdoc /> public void Dispose() { _client.Dispose(); }