// Check whether the simulation is running with the conn string in the configuration
private bool IsPreprovisionedIoTHubInUse(IServicesConfig servicesConfig, IIotHubConnectionStringManager connectionStringManager)
{
var csInUse = connectionStringManager.GetIotHubConnectionString().ToLowerInvariant().Trim();
var csInConf = servicesConfig?.IoTHubConnString?.ToLowerInvariant().Trim();
return(csInUse == csInConf);
}
public async Task ValidateInputRequestAsync(ILogger log, IIotHubConnectionStringManager connectionStringManager)
{
const string NO_DEVICE_MODEL = "The simulation doesn't contain any device model";
const string ZERO_DEVICES = "The simulation has zero devices";
const string END_TIME_BEFORE_START_TIME = "The simulation End Time must be after the Start Time";
const string INVALID_DATE = "Invalid date format";
const string CANNOT_RUN_IN_THE_PAST = "The simulation end date is in the past";
const string NO_IOTHUB_CONNSTRING = "The simulation doesn't contain any IoTHub connection string";
// A simulation must contain at least one device model
if (this.DeviceModels.Count < 1)
{
log.Error(NO_DEVICE_MODEL, () => new { simulation = this });
throw new BadRequestException(NO_DEVICE_MODEL);
}
// A simulation must use at least one device
if (this.DeviceModels.Sum(x => x.Count) < 1)
{
log.Error(ZERO_DEVICES, () => new { simulation = this });
throw new BadRequestException(ZERO_DEVICES);
}
try
{
var now = DateTimeOffset.UtcNow;
var startTime = DateHelper.ParseDateExpression(this.StartTime, now);
var endTime = DateHelper.ParseDateExpression(this.EndTime, now);
// The start time must be before the end time
if (startTime.HasValue && endTime.HasValue && startTime.Value.Ticks >= endTime.Value.Ticks)
{
log.Error(END_TIME_BEFORE_START_TIME, () => new { simulation = this });
throw new BadRequestException(END_TIME_BEFORE_START_TIME);
}
// The end time cannot be in the past
if (endTime.HasValue && endTime.Value.Ticks <= now.Ticks)
{
log.Error(CANNOT_RUN_IN_THE_PAST, () => new { simulation = this });
throw new BadRequestException(CANNOT_RUN_IN_THE_PAST);
}
}
catch (InvalidDateFormatException e)
{
log.Error(INVALID_DATE, () => new { simulation = this });
throw new BadRequestException(INVALID_DATE, e);
}
// A simulation contains at least one iothub connect string
if (this.IotHubs.Count == 0)
{
throw new BadRequestException(NO_IOTHUB_CONNSTRING);
}
foreach (var iotHub in this.IotHubs)
{
await connectionStringManager.ValidateConnectionStringAsync(iotHub.ConnectionString);
}
}
public SimulationsController(
ISimulations simulationsService,
IIotHubConnectionStringManager connectionStringManager,
ILogger logger)
{
this.simulationsService = simulationsService;
this.connectionStringManager = connectionStringManager;
this.log = logger;
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
ILogger logger)
{
this.connectionStringManager = connStringManager;
this.registry = registryManager;
this.log = logger;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
this.registryCount = -1;
this.setupDone = false;
}
public Simulations(
IDeviceModels deviceModels,
IStorageAdapterClient storage,
IIotHubConnectionStringManager connectionStringManager,
IDevices devices,
ILogger logger)
{
this.deviceModels = deviceModels;
this.storage = storage;
this.connectionStringManager = connectionStringManager;
this.devices = devices;
this.log = logger;
}
public SimulationsController(
ISimulations simulationsService,
IIotHubConnectionStringManager connectionStringManager,
IIothubMetrics iothubMetrics,
IPreprovisionedIotHub preprovisionedIotHub,
ISimulationAgent simulationAgent,
ILogger logger)
{
this.simulationsService = simulationsService;
this.connectionStringManager = connectionStringManager;
this.iothubMetrics = iothubMetrics;
this.simulationAgent = simulationAgent;
this.log = logger;
}
/// <summary>Map a service model to the corresponding API model</summary>
public SimulationListApiModel(
IEnumerable <Services.Models.Simulation> simulations,
IServicesConfig servicesConfig,
IDeploymentConfig deploymentConfig,
IIotHubConnectionStringManager connectionStringManager,
ISimulationRunner simulationRunner,
IRateLimiting rateReporter)
{
this.Items = new List <SimulationApiModel.SimulationApiModel>();
foreach (var x in simulations)
{
this.Items.Add(SimulationApiModel.SimulationApiModel.FromServiceModel(
x, servicesConfig, deploymentConfig, connectionStringManager, simulationRunner, rateReporter));
}
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
IDeviceClientWrapper deviceClient,
ILogger logger)
{
this.config = config;
this.connectionStringManager = connStringManager;
this.connString = null;
this.registry = registryManager;
this.deviceClient = deviceClient;
this.log = logger;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
this.setupDone = false;
}
// Append additional Hub properties and Statistics
private async Task AppendHubPropertiesAndStatisticsAsync(
IServicesConfig servicesConfig,
IDeploymentConfig deploymentConfig,
IIotHubConnectionStringManager connectionStringManager,
ISimulationRunner simulationRunner,
IRateLimiting rateReporter)
{
var isRunning = this.Running == true;
foreach (var iotHub in this.IotHubs)
{
// Preprovisioned IoT hub status
var isHubPreprovisioned = this.IsHubConnectionStringConfigured(servicesConfig);
if (isHubPreprovisioned && isRunning)
{
iotHub.PreprovisionedIoTHubInUse = await this.IsPreprovisionedIoTHubInUseAsync(servicesConfig, connectionStringManager);
iotHub.PreprovisionedIoTHubMetricsUrl = await this.GetIoTHubMetricsUrlAsync(servicesConfig, deploymentConfig, connectionStringManager);
}
}
if (isRunning)
{
// Average messages per second frequency in the last minutes
this.Statistics.AverageMessagesPerSecond = rateReporter.GetThroughputForMessages();
// Total messages count
this.Statistics.TotalMessagesSent = simulationRunner.TotalMessagesCount;
// Active devices count
this.Statistics.ActiveDevicesCount = simulationRunner.ActiveDevicesCount;
// Failed telemetry messages count
this.Statistics.FailedMessagesCount = simulationRunner.FailedMessagesCount;
// Failed device connections count
this.Statistics.FailedDeviceConnectionsCount = simulationRunner.FailedDeviceConnectionsCount;
// Failed device connections count
this.Statistics.FailedDeviceTwinUpdatesCount = simulationRunner.FailedDeviceTwinUpdatesCount;
// Simulation errors count
this.Statistics.SimulationErrorsCount = simulationRunner.SimulationErrorsCount;
}
}
public Simulations(
IServicesConfig config,
IDeviceModels deviceModels,
IFactory factory,
IStorageAdapterClient storageAdapterClient,
IIotHubConnectionStringManager connectionStringManager,
IDevices devices,
ILogger logger,
IDiagnosticsLogger diagnosticsLogger)
{
this.deviceModels = deviceModels;
this.storageAdapterClient = storageAdapterClient;
this.simulationsStorage = factory.Resolve <IStorageRecords>().Init(config.SimulationsStorage);
this.connectionStringManager = connectionStringManager;
this.devices = devices;
this.log = logger;
this.diagnosticsLogger = diagnosticsLogger;
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
IDeviceClientWrapper deviceClient,
ILogger logger,
IDiagnosticsLogger diagnosticsLogger,
IInstance instance)
{
this.config = config;
this.connectionStringManager = connStringManager;
this.registry = registryManager;
this.deviceClient = deviceClient;
this.log = logger;
this.diagnosticsLogger = diagnosticsLogger;
this.instance = instance;
this.connString = null;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
}
public SimulationsController(
ISimulations simulationsService,
IServicesConfig servicesConfig,
IDeploymentConfig deploymentConfig,
IIotHubConnectionStringManager connectionStringManager,
IPreprovisionedIotHub preprovisionedIotHub,
ISimulationAgent simulationAgent,
ISimulationRunner simulationRunner,
IRateLimiting rateReporter,
ILogger logger)
{
this.simulationsService = simulationsService;
this.servicesConfig = servicesConfig;
this.deploymentConfig = deploymentConfig;
this.connectionStringManager = connectionStringManager;
this.simulationAgent = simulationAgent;
this.simulationRunner = simulationRunner;
this.rateReporter = rateReporter;
this.log = logger;
}
public StatusController(
IPreprovisionedIotHub preprovisionedIotHub,
IStorageAdapterClient storage,
ISimulations simulations,
ILogger logger,
IServicesConfig servicesConfig,
IDeploymentConfig deploymentConfig,
IIotHubConnectionStringManager connectionStringManager,
ISimulationRunner simulationRunner,
IRateLimiting rateLimiting)
{
this.preprovisionedIotHub = preprovisionedIotHub;
this.storage = storage;
this.simulations = simulations;
this.log = logger;
this.servicesConfig = servicesConfig;
this.deploymentConfig = deploymentConfig;
this.connectionStringManager = connectionStringManager;
this.simulationRunner = simulationRunner;
this.rateReporter = rateLimiting;
}
// If the simulation is running with the conn string in the config then return a URL to the metrics
private string GetIoTHubMetricsUrl(IServicesConfig servicesConfig, IDeploymentConfig deploymentConfig, IIotHubConnectionStringManager connectionStringManager)
{
var csInUse = connectionStringManager.GetIotHubConnectionString().ToLowerInvariant().Trim();
var csInConf = servicesConfig?.IoTHubConnString?.ToLowerInvariant().Trim();
// Return the URL only when the simulation is running with the configured conn string
if (csInUse != csInConf)
{
return(string.Empty);
}
return($"https://portal.azure.com/{deploymentConfig.AzureSubscriptionDomain}" +
$"#resource/subscriptions/{deploymentConfig.AzureSubscriptionId}" +
$"/resourceGroups/{deploymentConfig.AzureResourceGroup}" +
$"/providers/Microsoft.Devices/IotHubs/{deploymentConfig.AzureIothubName}/Metrics");
}
// Map service model to API model
public static SimulationApiModel FromServiceModel(
Simulation value,
IServicesConfig servicesConfig,
IDeploymentConfig deploymentConfig,
IIotHubConnectionStringManager connectionStringManager,
ISimulationRunner simulationRunner,
IRateLimiting rateReporter)
{
if (value == null)
{
return(null);
}
var result = new SimulationApiModel
{
ETag = value.ETag,
Id = value.Id,
Name = value.Name,
Description = value.Description,
Enabled = value.Enabled,
Running = value.ShouldBeRunning,
StartTime = value.StartTime.ToString(),
EndTime = value.EndTime.ToString(),
StoppedTime = value.StoppedTime.ToString(),
IotHubs = new List <SimulationIotHub>()
};
foreach (var iotHubConnectionString in value.IotHubConnectionStrings)
{
var iotHub = new SimulationIotHub {
ConnectionString = iotHubConnectionString
};
result.IotHubs.Add(iotHub);
}
// Ignore the date if the simulation doesn't have a start time
if (value.StartTime.HasValue && !value.StartTime.Value.Equals(DateTimeOffset.MinValue))
{
result.StartTime = value.StartTime?.ToString(DATE_FORMAT);
}
// Ignore the date if the simulation doesn't have an end time
if (value.EndTime.HasValue && !value.EndTime.Value.Equals(DateTimeOffset.MaxValue))
{
result.EndTime = value.EndTime?.ToString(DATE_FORMAT);
}
// Ignore the date if the simulation doesn't have an end time
if (value.StoppedTime.HasValue && !value.StoppedTime.Value.Equals(DateTimeOffset.MaxValue))
{
result.StoppedTime = value.StoppedTime?.ToString(DATE_FORMAT);
}
result.DeviceModels = SimulationDeviceModelRef.FromServiceModel(value.DeviceModels);
result.Statistics = SimulationStatistics.FromServiceModel(value.Statistics);
result.created = value.Created;
result.modified = value.Modified;
result.AppendHubPropertiesAndStatistics(servicesConfig, deploymentConfig, connectionStringManager, simulationRunner, rateReporter);
return(result);
}
// Check whether the simulation is running with the conn string in the configuration
private async Task <bool> IsPreprovisionedIoTHubInUseAsync(IServicesConfig servicesConfig, IIotHubConnectionStringManager connectionStringManager)
{
var csInUse = (await connectionStringManager.GetConnectionStringAsync()).ToLowerInvariant().Trim();
var csInConf = servicesConfig?.IoTHubConnString?.ToLowerInvariant().Trim();
return(csInUse == csInConf);
}
