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
}
}
}
private async Task ModuleClient_Gives_ConnectionStatus_DeviceDisabled_Base(
Client.TransportType protocol, Func <RegistryManager, string, Task> registryManagerOperation)
{
AmqpTransportSettings amqpTransportSettings = new AmqpTransportSettings(protocol);
ITransportSettings[] transportSettings = new ITransportSettings[] { amqpTransportSettings };
TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix + $"_{Guid.NewGuid()}", ModulePrefix).ConfigureAwait(false);
ConnectionStatus? status = null;
ConnectionStatusChangeReason?statusChangeReason = null;
int deviceDisabledReceivedCount = 0;
ConnectionStatusChangesHandler statusChangeHandler = (s, r) =>
{
if (r == ConnectionStatusChangeReason.Device_Disabled)
{
status = s;
statusChangeReason = r;
deviceDisabledReceivedCount++;
}
};
using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings))
{
moduleClient.SetConnectionStatusChangesHandler(statusChangeHandler);
_log.WriteLine($"Created {nameof(DeviceClient)} ID={TestLogging.IdOf(moduleClient)}");
Console.WriteLine("ModuleClient OpenAsync.");
await moduleClient.OpenAsync().ConfigureAwait(false);
// Receiving the module twin should succeed right now.
Console.WriteLine("ModuleClient GetTwinAsync.");
var twin = await moduleClient.GetTwinAsync().ConfigureAwait(false);
Assert.IsNotNull(twin);
// Delete/disable the device in IoT Hub.
using (RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString))
{
await registryManagerOperation(registryManager, testModule.DeviceId).ConfigureAwait(false);
}
// Artificial sleep waiting for the connection status change handler to get triggered.
int sleepCount = 50;
for (int i = 0; i < sleepCount; i++)
{
await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
if (deviceDisabledReceivedCount == 1)
{
break;
}
}
Assert.AreEqual(1, deviceDisabledReceivedCount);
Assert.AreEqual(ConnectionStatus.Disconnected, status);
Assert.AreEqual(ConnectionStatusChangeReason.Device_Disabled, statusChangeReason);
}
}
public async Task InitiateSimulationAsync()
{
string logPrefix = "system".BuildLogPrefix();
IoTTools.CheckModuleConnectionStringData(ModuleSettings.ConnectionString, _logger);
// Connect to the IoT hub using the MQTT protocol
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module client created.");
if (SimulationSettings.EnableTwinPropertiesDesiredChangesNotifications)
{
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChange, null);
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Twin Desired Properties update callback handler registered.");
}
//Configuration
if (SimulationSettings.EnableC2DDirectMethods)
{
//Register C2D Direct methods handlers
await RegisterC2DDirectMethodsHandlersAsync(_moduleClient, ModuleSettings, _logger);
}
if (SimulationSettings.EnableC2DMessages)
{
//Start receiving C2D messages
ReceiveC2DMessagesAsync(_moduleClient, ModuleSettings, _logger);
}
//Messages
if (SimulationSettings.EnableTelemetryMessages)
{
SendDeviceToCloudMessagesAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, _logger); //interval is a global variable changed by processes
}
if (SimulationSettings.EnableReadingTwinProperties)
{
//Twins
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Retrieving twin.");
Twin twin = await _moduleClient.GetTwinAsync();
if (twin != null)
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Device twin: {JsonConvert.SerializeObject(twin, Formatting.Indented)}.");
}
else
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::No device twin.");
}
}
_moduleClient.SetConnectionStatusChangesHandler(new ConnectionStatusChangesHandler(ConnectionStatusChanged));
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
Console.WriteLine("Open a connection to the Edge runtime");
ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
ioTHubModuleClient.SetConnectionStatusChangesHandler(ConnectionStatusChanged);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
}
// Initialize the device client instance over Mqtt protocol (TCP, with fallback over Websocket), setting the ModelId into ClientOptions.
// This method also sets a connection status change callback, that will get triggered any time the device's connection status changes.
private static void InitializeDeviceClientAsync()
{
var options = new ClientOptions
{
ModelId = ModelId,
};
s_deviceClient = ModuleClient.CreateFromConnectionString(s_deviceConnectionString, TransportType.Mqtt, options);
//s_deviceClient = DeviceClient.CreateFromConnectionString(s_deviceConnectionString, TransportType.Mqtt, options);
s_deviceClient.SetConnectionStatusChangesHandler((status, reason) =>
{
s_logger.LogDebug($"Connection status change registered - status={status}, reason={reason}.");
});
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
moduleClient = ModuleClient.CreateFromConnectionString("");
moduleClient.SetConnectionStatusChangesHandler(OnConnectionStatusChanged);
await moduleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
timer = new Timer(new TimerCallback(Program.SendEvent), null, 5000 /*dueTime*/, 5000 /*period*/);
}
public DesiredPropertiesValidator(RegistryManager registryManager, ModuleClient moduleClient, TwinEventStorage storage, ITwinTestResultHandler resultHandler, TwinState twinState)
{
this.registryManager = registryManager;
this.moduleClient = moduleClient;
this.storage = storage;
this.resultHandler = resultHandler;
this.twinState = twinState;
moduleClient.SetConnectionStatusChangesHandler((status, reason) =>
{
Logger.LogInformation($"Detected change in connection status:{Environment.NewLine}Changed Status: {status} Reason: {reason}");
if (status == ConnectionStatus.Disconnected_Retrying)
{
this.twinState.LastTimeOfEdgeRestart = DateTime.UtcNow;
}
});
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
api = new InfsoftRest.InfsoftAPI();
// Register callback to be called when a message is received by the module
//await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
ioTHubModuleClient.SetConnectionStatusChangesHandler(ConnectionStatusHandler);
Guid apiKey = Guid.Empty;
var apiKeyEnv = Environment.GetEnvironmentVariable("apikey");
if (!string.IsNullOrEmpty(apiKeyEnv))
{
apiKey = Guid.Parse(apiKeyEnv);
}
int locationId = 0;
var locationIdEnv = Environment.GetEnvironmentVariable("locationid");
if (!string.IsNullOrEmpty(locationIdEnv))
{
locationId = int.Parse(locationIdEnv);
}
int sleepDurationoInSec = 0;
var sleepDurationoInSecEnv = Environment.GetEnvironmentVariable("sleepdurationoinsec");
if (!string.IsNullOrEmpty(sleepDurationoInSecEnv))
{
sleepDurationoInSec = int.Parse(sleepDurationoInSecEnv);
}
await SendInfsoftTrackingAssetTelemetry(ioTHubModuleClient, cts.Token, apiKey, locationId, sleepDurationoInSec);
}
public async Task Init(CancellationTokenSource cancellationTokenSource)
{
var tokenHelper = new SecurityDaemonClient();
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
Console.WriteLine($"tokenHelper: '{tokenHelper.ToString()}'");
var token = tokenHelper.GetModuleToken(3600).Result;
Console.WriteLine($"Token: '{token}'");
var tokenAuthentication = new ModuleAuthenticationWithToken(tokenHelper.DeviceId, tokenHelper.ModuleId, token);
var transportType = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { transportType };
using (ModuleClient moduleClient = ModuleClient.Create(tokenHelper.IotHubHostName, tokenAuthentication, settings))
{
if (moduleClient == null)
{
Console.WriteLine("Failed to create ModuleClient!");
throw new InvalidOperationException("Failed to create ModuleClient");
}
moduleClient.SetConnectionStatusChangesHandler((ConnectionStatus status, ConnectionStatusChangeReason reason) =>
{
if (reason == ConnectionStatusChangeReason.Bad_Credential)
{
Init(cancellationTokenSource).Wait();
}
});
Console.WriteLine($"Starting DeviceStreamSample on '{_hostName}:{_port}'");
await RunSampleAsync(moduleClient, true, cancellationTokenSource);
}
}
catch (Exception ex)
{
Console.WriteLine($"{DateTime.UtcNow} - Got an exception: {ex.ToString()}");
Console.WriteLine("Waiting 1 minute and trying again...");
await Task.Delay(TimeSpan.FromMinutes(1));
}
}
}
public async Task Initialize(ConnectionStatusChangesHandler connectionStatusHander, MessageHandler messageCallback, DesiredPropertyUpdateCallback twinCallback, MethodCallback methodCallback, object context, CancellationToken ct)
{
var option = new ClientOptions
{
ModelId = ModuleClientConnector.PnPModelId
};
moduleClient = await ModuleClient.CreateFromEnvironmentAsync(envSettings, options : option);
Console.WriteLine($"Connected to Edge Hub as Plug and Play Model Id={ModuleClientConnector.PnPModelId}");
await moduleClient.OpenAsync();
moduleClient.SetConnectionStatusChangesHandler(connectionStatusHander);
await moduleClient.SetInputMessageHandlerAsync(this.msgInputName, messageCallback, context);
await moduleClient.SetDesiredPropertyUpdateCallbackAsync(twinCallback, context);
await moduleClient.SetMethodDefaultHandlerAsync(methodCallback, context);
}
TwinAllOperationsInitializer(RegistryManager registryManager, ModuleClient moduleClient, ITwinTestResultHandler resultHandler, TwinEventStorage storage, TwinTestState twinTestState)
{
this.registryManager = registryManager;
this.twinTestState = twinTestState;
this.reportedPropertyUpdater = new ReportedPropertyUpdater(moduleClient, resultHandler, twinTestState.ReportedPropertyUpdateCounter);
this.desiredPropertyUpdater = new DesiredPropertyUpdater(registryManager, resultHandler, twinTestState);
this.desiredPropertyReceiver = new DesiredPropertyReceiver(moduleClient, resultHandler);
this.reportedPropertiesValidator = new ReportedPropertiesValidator(registryManager, moduleClient, storage, resultHandler, twinTestState);
this.desiredPropertiesValidator = new DesiredPropertiesValidator(registryManager, moduleClient, storage, resultHandler, twinTestState);
moduleClient.SetConnectionStatusChangesHandler((status, reason) =>
{
Logger.LogInformation($"Detected change in connection status:{Environment.NewLine}Changed Status: {status} Reason: {reason}");
if (status == ConnectionStatus.Disconnected_Retrying)
{
this.twinTestState.EdgeHubLastStopped = DateTime.UtcNow;
}
else if (status == ConnectionStatus.Connected)
{
this.twinTestState.EdgeHubLastStarted = DateTime.UtcNow;
}
});
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
ioTHubModuleClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);
_moduleClient = ioTHubModuleClient;
#region for test
//_timer = new Timer(DoWork);
//_timer.Change(0, 1000);
//Console.WriteLine("Timer start");
#endregion
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient
/// </summary>
static async Task <ModuleClient> Init()
{
var transportType = TransportType.Amqp_Tcp_Only;
string transportProtocol = Environment.GetEnvironmentVariable("ClientTransportType");
// The way the module connects to the EdgeHub can be controlled via the env variable. Either MQTT or AMQP
if (!string.IsNullOrEmpty(transportProtocol))
{
switch (transportProtocol.ToUpper())
{
case "AMQP":
transportType = TransportType.Amqp_Tcp_Only;
break;
case "MQTT":
transportType = TransportType.Mqtt_Tcp_Only;
break;
default:
// Anything else: use default
Log.Warning($"Ignoring unknown TransportProtocol={transportProtocol}. Using default={transportType}");
break;
}
}
// Open a connection to the Edge runtime
ModuleClient moduleClient = await ModuleClient.CreateFromEnvironmentAsync(transportType);
moduleClient.SetConnectionStatusChangesHandler(ConnectionStatusHandler);
await moduleClient.OpenAsync();
Log.Information($"Edge Hub module client initialized using {transportType}");
return(moduleClient);
}
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();
}
}
}
async Task ModuleClient_Gives_ConnectionStatus_DeviceDisabled_Base(
Client.TransportType protocol, Func <RegistryManager, string, Task> registryManagerOperation)
{
AmqpTransportSettings amqpTransportSettings = new AmqpTransportSettings(protocol);
ITransportSettings[] transportSettings = new ITransportSettings[] { amqpTransportSettings };
TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix + $"_{Guid.NewGuid()}", ModulePrefix).ConfigureAwait(false);
ConnectionStatus? status = null;
ConnectionStatusChangeReason?statusChangeReason = null;
int deviceDisabledReceivedCount = 0;
ConnectionStatusChangesHandler statusChangeHandler = (s, r) =>
{
if (r == ConnectionStatusChangeReason.Device_Disabled)
{
status = s;
statusChangeReason = r;
deviceDisabledReceivedCount++;
}
};
using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings))
{
moduleClient.SetConnectionStatusChangesHandler(statusChangeHandler);
_log.WriteLine($"Created {nameof(DeviceClient)} ID={TestLogging.IdOf(moduleClient)}");
Console.WriteLine("ModuleClient OpenAsync.");
await moduleClient.OpenAsync().ConfigureAwait(false);
// Receiving the module twin should succeed right now.
Console.WriteLine("ModuleClient GetTwinAsync.");
var twin = await moduleClient.GetTwinAsync().ConfigureAwait(false);
Assert.IsNotNull(twin);
// Delete the device in IoT Hub.
using (RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString))
{
await registryManagerOperation(registryManager, testModule.DeviceId).ConfigureAwait(false);
}
// Periodically keep retrieving the device twin to keep connection alive.
// The ConnectionStatusChangesHandler should be triggered when the connection is closed from IoT hub with an
// exception thrown.
int twinRetrievals = 50;
for (int i = 0; i < twinRetrievals; i++)
{
try
{
await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
if (deviceDisabledReceivedCount == 1)
{
// Call an API on the client again to trigger the ConnectionStatusChangesHandler once again with the
// Device_Disabled status.
// This currently does not work due to some issues with IoT hub allowing new connections even when the
// device is deleted/disabled. Once that problem is investigated and fixed, we can re-enable this call
// and test for multiple invocations of the ConnectionStatusChangeHandler.
// await moduleClient.GetTwinAsync().ConfigureAwait(false);
break;
}
}
catch (IotHubException ex)
{
_log.WriteLine($"Exception occurred while retrieving module twin: {ex}");
Assert.IsInstanceOfType(ex.InnerException, typeof(DeviceNotFoundException));
}
}
Assert.AreEqual(1, deviceDisabledReceivedCount);
Assert.AreEqual(ConnectionStatus.Disconnected, status);
Assert.AreEqual(ConnectionStatusChangeReason.Device_Disabled, statusChangeReason);
}
}
public async Task InitiateSimulationAsync()
{
string logPrefix = "system".BuildLogPrefix();
try
{
//Connectivity tests
//Control if a connection string exists (ideally, stored in TPM/HSM or any secured location.
//If there is no connection string, check if the DPS settings are provided.
//If so, provision the device and persist the connection string for upcoming boots.
if (string.IsNullOrEmpty(ModuleSettings.ConnectionString))
{
ModuleSettings.ConnectionString = await _provisioningService.AddModuleIdentityToDevice(ModuleSettings.ModuleId);
if (string.IsNullOrEmpty(ModuleSettings.ConnectionString))
{
_logger.LogWarning($"{logPrefix}::{ModuleSettings.ArtifactId}::No module connection string has been created.");
}
else
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module connection string being persisted.");
await ConfigurationHelpers.WriteModulesSettings(ModuleSettings, _environmentName);
}
}
IoTTools.CheckModuleConnectionStringData(ModuleSettings.ConnectionString, _logger);
// Connect to the IoT hub using the MQTT protocol
_moduleClient = ModuleClient.CreateFromConnectionString(ModuleSettings.ConnectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt);
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module client created.");
if (SimulationSettings.EnableTwinPropertiesDesiredChangesNotifications)
{
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChange, null);
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Twin Desired Properties update callback handler registered.");
}
//Configuration
if (SimulationSettings.EnableC2DDirectMethods)
{
//Register C2D Direct methods handlers
await RegisterC2DDirectMethodsHandlersAsync(_moduleClient, ModuleSettings, _logger);
}
if (SimulationSettings.EnableC2DMessages)
{
//Start receiving C2D messages
ReceiveC2DMessagesAsync(_moduleClient, ModuleSettings, _logger);
}
//Messages
if (SimulationSettings.EnableTelemetryMessages)
{
SendDeviceToCloudMessagesAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, _logger); //interval is a global variable changed by processes
}
if (SimulationSettings.EnableErrorMessages)
{
SendDeviceToCloudErrorAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, SimulationSettings.ErrorFrecuency, _logger);
}
if (SimulationSettings.EnableCommissioningMessages)
{
SendDeviceToCloudCommissioningAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, SimulationSettings.CommissioningFrecuency, _logger);
}
if (SimulationSettings.EnableReadingTwinProperties)
{
//Twins
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Retrieving twin.");
Twin twin = await _moduleClient.GetTwinAsync();
if (twin != null)
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Device twin: {JsonConvert.SerializeObject(twin, Formatting.Indented)}.");
}
else
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::No device twin.");
}
}
_moduleClient.SetConnectionStatusChangesHandler(new ConnectionStatusChangesHandler(ConnectionStatusChanged));
}
catch (ConnectionStringException ex)
{
_logger.LogError($"{logPrefix}::{ModuleSettings.ArtifactId}::ConnectionStringException:{ex.Message}");
}
catch (Exception ex)
{
_logger.LogError($"{logPrefix}::{ModuleSettings.ArtifactId}::{ex.Message}");
}
}
static async Task <int> MainAsync()
{
try
{
Logger.LogInformation("Validate Metrics Main() started.");
(CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger);
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("config/appsettings.json", optional: true)
.AddEnvironmentVariables()
.Build();
var transportType = configuration.GetValue("ClientTransportType", Microsoft.Azure.Devices.Client.TransportType.Mqtt);
Logger.LogInformation("Make Client");
using (ModuleClient moduleClient = await ModuleUtil.CreateModuleClientAsync(
transportType,
new ClientOptions(),
ModuleUtil.DefaultTimeoutErrorDetectionStrategy,
ModuleUtil.DefaultTransientRetryStrategy,
Logger))
using (MetricsScraper scraper = new MetricsScraper(new List <string> {
"http://edgeHub:9600/metrics", "http://edgeAgent:9600/metrics"
}))
{
Logger.LogInformation("Open Async");
await moduleClient.OpenAsync();
Logger.LogInformation("Set method handler");
await moduleClient.SetMethodHandlerAsync(
"ValidateMetrics",
async (MethodRequest methodRequest, object _) =>
{
Logger.LogInformation("Validating metrics");
TestReporter testReporter = new TestReporter("Metrics Validation");
List <TestBase> tests = new List <TestBase>
{
new ValidateMessages(testReporter, scraper, moduleClient, transportType),
new ValidateDocumentedMetrics(testReporter, scraper, moduleClient),
// new ValidateHostRanges(testReporter, scraper, moduleClient),
};
using (testReporter.MeasureDuration())
{
await Task.WhenAll(tests.Select(test => test.Start(cts.Token)));
}
var result = new MethodResponse(Encoding.UTF8.GetBytes(testReporter.ReportResults()), (int)HttpStatusCode.OK);
Logger.LogInformation($"Finished validating metrics. Result size: {result.Result.Length}");
return(result);
},
null);
moduleClient.SetConnectionStatusChangesHandler((status, reason)
=> Logger.LogWarning($"Module to Edge Hub connection changed Status: {status} Reason: {reason}"));
Logger.LogInformation("Ready to validate metrics");
await cts.Token.WhenCanceled();
}
completed.Set();
handler.ForEach(h => GC.KeepAlive(h));
Logger.LogInformation("Validate Metrics Main() finished.");
}
catch (Exception e)
{
Logger.LogError(e.ToString());
}
return(0);
}
/// <inheritdoc />
public void SetConnectionStatusChangesHandler(ConnectionStatusChangesHandler statusChangesHandler)
{
_client.SetConnectionStatusChangesHandler(statusChangesHandler);
}
