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();
}
