/// <summary>
/// Invoke this method before calling Execute(), to initialize the actor
/// with details like the device id. SetupAsync() should be called only once.
/// </summary>
public void Setup(
string deviceId,
IDeviceStateActor deviceStateActor,
IDeviceConnectionActor deviceConnectionActor,
PropertiesLoopSettings loopSettings)
{
if (this.status != ActorStatus.None)
{
this.log.Error("The actor is already initialized",
() => new { CurrentDeviceId = this.deviceId });
throw new DeviceActorAlreadyInitializedException();
}
this.deviceId = deviceId;
this.deviceStateActor = deviceStateActor;
this.deviceConnectionActor = deviceConnectionActor;
this.loopSettings = loopSettings;
this.updatePropertiesLogic.Setup(this, this.deviceId);
this.deviceSetDeviceTagLogic.Setup(this, this.deviceId);
this.updatePropertiesLogic.Setup(this, this.deviceId);
this.actorLogger.Setup(deviceId, "Properties");
this.status = ActorStatus.ReadyToStart;
}
public SimulationRunner(
IRateLimitingConfig ratingConfig,
IRateLimiting rateLimiting,
ISimulationConcurrencyConfig simulationConcurrencyConfig,
ILogger logger,
IDiagnosticsLogger diagnosticsLogger,
IDeviceModels deviceModels,
IDeviceModelsGeneration deviceModelsOverriding,
IDevices devices,
ISimulations simulations,
IFactory factory)
{
this.connectionLoopSettings = new ConnectionLoopSettings(ratingConfig);
this.propertiesLoopSettings = new PropertiesLoopSettings(ratingConfig);
this.simulationConcurrencyConfig = simulationConcurrencyConfig;
this.log = logger;
this.diagnosticsLogger = diagnosticsLogger;
this.deviceModels = deviceModels;
this.deviceModelsOverriding = deviceModelsOverriding;
this.devices = devices;
this.simulations = simulations;
this.factory = factory;
this.startLock = new { };
this.running = false;
this.starting = false;
this.rateLimiting = rateLimiting;
this.deviceStateActors = new ConcurrentDictionary <string, IDeviceStateActor>();
this.deviceConnectionActors = new ConcurrentDictionary <string, IDeviceConnectionActor>();
this.deviceTelemetryActors = new ConcurrentDictionary <string, IDeviceTelemetryActor>();
this.devicePropertiesActors = new ConcurrentDictionary <string, IDevicePropertiesActor>();
}
public async Task InitAsync(Simulation simulation)
{
this.instance.InitOnce();
var rateLimits = simulation.RateLimits;
this.RateLimiting.Init(rateLimits);
this.ConnectionLoopSettings = new ConnectionLoopSettings(rateLimits);
this.PropertiesLoopSettings = new PropertiesLoopSettings(rateLimits);
await this.Devices.InitAsync();
this.instance.InitComplete();
}
public async Task InitAsync(Simulation simulation)
{
this.instance.InitOnce();
// TODO: init using the simulation settings, not the defaults
var defaultRatingConfig = this.factory.Resolve <IRateLimitingConfig>();
this.RateLimiting.Init(defaultRatingConfig);
this.ConnectionLoopSettings = new ConnectionLoopSettings(defaultRatingConfig);
this.PropertiesLoopSettings = new PropertiesLoopSettings(defaultRatingConfig);
await this.Devices.InitAsync();
this.instance.InitComplete();
}
/// <summary>
/// Invoke this method before calling Execute(), to initialize the actor
/// with details like the device id.
/// </summary>
public void Init(
ISimulationContext simulationContext,
string deviceId,
IDeviceStateActor deviceStateActor,
IDeviceConnectionActor deviceConnectionActor,
PropertiesLoopSettings loopSettings)
{
this.instance.InitOnce();
this.simulationContext = simulationContext;
this.deviceId = deviceId;
this.deviceStateActor = deviceStateActor;
this.deviceConnectionActor = deviceConnectionActor;
this.updatePropertiesLogic.Init(this, this.deviceId);
this.actorLogger.Init(deviceId, "Properties");
this.status = ActorStatus.ReadyToStart;
this.instance.InitComplete();
}
public LoopSettingsTest(ITestOutputHelper logger)
{
this.log = logger;
this.rateLimitingConfig = new Mock <IRateLimitingConfig>();
this.propertiesTarget = new PropertiesLoopSettings(this.rateLimitingConfig.Object);
}
