public IDevice CreateDevice(ILogger logger, ITransportFactory transportFactory,
ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config)
{
var device = new DeviceBase(logger, transportFactory, telemetryFactory, configurationProvider);
device.Init(config);
return device;
}
public async Task <List <InitialDeviceConfig> > GetDeviceListAsync()
{
return(await Task.Run(() =>
{
_logger.LogInfo("********** READING DEVICES FROM APP.CONFIG ********** ");
if (_devices.Any())
{
return _devices;
}
StringCollection deviceList = Settings.Default.DeviceList;
foreach (string device in deviceList)
{
string[] deviceConfigElements = device.Split(',');
var deviceConfig = new InitialDeviceConfig();
if (deviceConfigElements.Length > 1)
{
deviceConfig.DeviceId = deviceConfigElements[0];
deviceConfig.HostName = _hostName;
deviceConfig.Key = deviceConfigElements[1];
_devices.Add(deviceConfig);
}
}
return _devices;
}));
}
public async Task<List<InitialDeviceConfig>> GetDeviceListAsync()
{
return await Task.Run(() =>
{
_logger.LogInfo("********** READING DEVICES FROM APP.CONFIG ********** ");
if (_devices.Any())
{
return _devices;
}
StringCollection deviceList = Settings.Default.DeviceList;
foreach (string device in deviceList)
{
string[] deviceConfigElements = device.Split(',');
var deviceConfig = new InitialDeviceConfig();
if (deviceConfigElements.Length > 1)
{
deviceConfig.DeviceId = deviceConfigElements[0];
deviceConfig.HostName = _hostName;
deviceConfig.Key = deviceConfigElements[1];
_devices.Add(deviceConfig);
}
}
return _devices;
});
}
protected virtual void InitDeviceInfo(InitialDeviceConfig config, dynamic initialDevice)
{
// = SampleDeviceFactory.GetSampleSimulatedDevice(config.DeviceId, config.Key);
DeviceProperties = DeviceSchemaHelper.GetDeviceProperties(initialDevice);
Commands = CommandSchemaHelper.GetSupportedCommands(initialDevice);
HostName = config.HostName;
PrimaryAuthKey = config.Key;
}
public void Init(InitialDeviceConfig config, dynamic initialDevice)
{
InitDeviceInfo(config, initialDevice);
Transport = TransportFactory.CreateTransport(this);
_telemetryController = TelemetryFactory.PopulateDeviceWithTelemetryEvents(this);
InitCommandProcessors();
}
public void Init(InitialDeviceConfig config)
{
InitDeviceInfo(config);
Transport = TransportFactory.CreateTransport(this);
_telemetryController = TelemetryFactory.PopulateDeviceWithTelemetryEvents(this);
InitCommandProcessors();
}
protected virtual void InitDeviceInfo(InitialDeviceConfig config)
{
dynamic initialDevice = SampleDeviceFactory.GetSampleSimulatedDevice(config.DeviceId, config.Key);
DeviceProperties = DeviceSchemaHelper.GetDeviceProperties(initialDevice);
Commands = CommandSchemaHelper.GetSupportedCommands(initialDevice);
HostName = config.HostName;
PrimaryAuthKey = config.Key;
}
protected virtual void InitDeviceInfo(InitialDeviceConfig config)
{
DeviceModel initialDevice = SampleDeviceFactory.GetSampleSimulatedDevice(config.DeviceId, config.Key);
DeviceProperties = initialDevice.DeviceProperties;
Commands = initialDevice.Commands ?? new List <Command>();
Telemetry = initialDevice.Telemetry ?? new List <Common.Models.Telemetry>();
HostName = config.HostName;
PrimaryAuthKey = config.Key;
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var deviceEnity = new DeviceListEntity()
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await _azureTableStorageClient.ExecuteAsync(operation);
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
var deviceEnity = new DeviceListEntity
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await devicesTable.ExecuteAsync(operation);
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
var deviceEnity = new DeviceListEntity()
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await devicesTable.ExecuteAsync(operation);
}
public void GetDeviceInfoTests()
{
var config = new InitialDeviceConfig();
config.HostName = "HostName";
config.DeviceId = "test";
config.Key = "key";
deviceBase.Init(config);
var device = deviceBase.GetDeviceInfo();
Assert.Equal(device.DeviceProperties.DeviceID, "test");
Assert.Null(device.SystemProperties);
}
public void InitTests()
{
var config = new InitialDeviceConfig();
config.HostName = "HostName";
config.DeviceId = "test";
config.Key = "key";
deviceBase.Init(config);
Assert.Equal(deviceBase.DeviceID, "test");
Assert.Equal(deviceBase.HostName, "HostName");
Assert.Equal(deviceBase.PrimaryAuthKey, "key");
Assert.NotNull(deviceBase.DeviceProperties);
Assert.NotNull(deviceBase.Commands);
Assert.NotNull(deviceBase.Telemetry);
}
public async Task<List<InitialDeviceConfig>> GetDeviceListAsync()
{
List<InitialDeviceConfig> devices = new List<InitialDeviceConfig>();
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
TableQuery<DeviceListEntity> query = new TableQuery<DeviceListEntity>();
foreach (var device in devicesTable.ExecuteQuery(query))
{
var deviceConfig = new InitialDeviceConfig
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return devices;
}
public async Task <List <InitialDeviceConfig> > GetDeviceListAsync()
{
List <InitialDeviceConfig> devices = new List <InitialDeviceConfig>();
TableQuery <DeviceListEntity> query = new TableQuery <DeviceListEntity>();
var devicesResult = await _azureTableStorageClient.ExecuteQueryAsync(query);
foreach (var device in devicesResult)
{
var deviceConfig = new InitialDeviceConfig()
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return(devices);
}
public async void RemoveDeviceAsyncTest()
{
InitialDeviceConfig device = new InitialDeviceConfig()
{
DeviceId = this.testDeviceId,
HostName = this.testHostName,
Key = this.testKey
};
Assert.False(await this.repo.RemoveDeviceAsync(device.DeviceId));
await this.repo.GetDeviceListAsync();
await this.repo.AddOrUpdateDeviceAsync(device);
Assert.True(await this.repo.RemoveDeviceAsync(device.DeviceId));
Assert.False(await this.repo.RemoveDeviceAsync(device.DeviceId));
}
public CoolerDeviceTests()
{
_fixture = new Fixture();
_initConfig = _fixture.Create <InitialDeviceConfig>();
var loggerMock = new Mock <ILogger>();
_transportMock = new Mock <ITransport>();
var transportFactoryMock = new Mock <ITransportFactory>();
transportFactoryMock.Setup(x => x.CreateTransport(It.IsNotNull <IDevice>())).Returns(_transportMock.Object);
var telemetryFactoryMock = new Mock <ITelemetryFactory>();
var configurationProviderMock = new Mock <IConfigurationProvider>();
var coolerDeviceFactory = new CoolerDeviceFactory();
_coolerDevice = coolerDeviceFactory.CreateDevice(loggerMock.Object, transportFactoryMock.Object,
telemetryFactoryMock.Object, configurationProviderMock.Object, _initConfig) as CoolerDevice;
loggerMock.Setup(x => x.LogInfo(It.IsAny <string>(), It.IsAny <object[]>()));
}
public async void AddOrUpdateDeviceAsyncTest()
{
//add device
InitialDeviceConfig device = new InitialDeviceConfig()
{
DeviceId = this.testDeviceId,
HostName = this.testHostName,
Key = this.testKey
};
//should fail before GetDeviceListAsync initializes the known list of devices
await this.repo.AddOrUpdateDeviceAsync(device);
//get all devices
Assert.Null(await this.repo.GetDeviceAsync(device.DeviceId));
List <InitialDeviceConfig> devices = await this.repo.GetDeviceListAsync();
Assert.False(devices.Contains(device));
//repeat and it should be added
await this.repo.AddOrUpdateDeviceAsync(device);
var returnedDevice = await this.repo.GetDeviceAsync(device.DeviceId);
Assert.NotNull(returnedDevice);
Assert.Equal(returnedDevice.Key, this.testKey);
Assert.Equal(returnedDevice.HostName, this.testHostName);
//repeat and it should be updated
string changedKey = "changedKey";
device.Key = changedKey;
string changedHostName = "changedHostName";
device.HostName = changedHostName;
await this.repo.AddOrUpdateDeviceAsync(device);
var changedDevice = await this.repo.GetDeviceAsync(device.DeviceId);
Assert.NotNull(changedDevice);
Assert.Equal(changedDevice.Key, changedKey);
Assert.Equal(changedDevice.HostName, changedHostName);
}
public async Task <List <InitialDeviceConfig> > GetDeviceListAsync()
{
List <InitialDeviceConfig> devices = new List <InitialDeviceConfig>();
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
TableQuery <DeviceListEntity> query = new TableQuery <DeviceListEntity>();
foreach (var device in devicesTable.ExecuteQuery(query))
{
var deviceConfig = new InitialDeviceConfig()
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return(devices);
}
public async void UpdateDeviceEnabledStatusAsyncTest_simulatedDevice()
{
var device = this.fixture.Create <DeviceModel>();
var keys = fixture.Create <SecurityKeys>();
var hostname = "hostname";
device.IsSimulatedDevice = true;
var deviceId = device.DeviceProperties.DeviceID;
InitialDeviceConfig savedConfig = null;
this._configProviderMock.Setup(x => x.GetConfigurationSettingValue(It.IsAny <string>())).Returns(hostname);
this._iotHubRepositoryMock.Setup(mock => mock.UpdateDeviceEnabledStatusAsync(deviceId, It.IsAny <bool>())).ReturnsAsync(new Device());
this._iotHubRepositoryMock.Setup(mock => mock.GetDeviceKeysAsync(deviceId)).ReturnsAsync(keys);
this._deviceRegistryCrudRepositoryMock.Setup(
mock => mock.UpdateDeviceEnabledStatusAsync(deviceId, It.IsAny <bool>()))
.ReturnsAsync(device);
this._virtualDeviceStorageMock.Setup(
mock => mock.AddOrUpdateDeviceAsync(It.IsNotNull <InitialDeviceConfig>()))
.Callback <InitialDeviceConfig>(conf => savedConfig = conf)
.Returns(Task.FromResult(true))
.Verifiable();
// Enable simulated device
var res = await this._deviceLogic.UpdateDeviceEnabledStatusAsync(deviceId, true);
Assert.Equal(res, device);
_virtualDeviceStorageMock.Verify();
Assert.Equal(deviceId, savedConfig.DeviceId);
Assert.Equal(hostname, savedConfig.HostName);
Assert.Equal(keys.PrimaryKey, savedConfig.Key);
this._virtualDeviceStorageMock.Setup(mock => mock.RemoveDeviceAsync(deviceId))
.Returns(Task.FromResult(true))
.Verifiable();
// Disable simulated device
res = await this._deviceLogic.UpdateDeviceEnabledStatusAsync(deviceId, false);
Assert.Equal(res, device);
_virtualDeviceStorageMock.Verify();
}
public Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
return(Task.Run(() =>
{
if (!_devices.Any())
{
return;
}
var device = _devices.FirstOrDefault(x => x.DeviceId == deviceConfig.DeviceId);
if (device != null)
{
device.Key = deviceConfig.Key;
device.HostName = deviceConfig.HostName;
}
else
{
_devices.Add(deviceConfig);
}
}));
}
public Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
return Task.Run(() =>
{
if (!_devices.Any())
{
return;
}
var device = _devices.FirstOrDefault(x => x.DeviceId == deviceConfig.DeviceId);
if (device != null)
{
device.Key = deviceConfig.Key;
device.HostName = deviceConfig.HostName;
}
else
{
_devices.Add(deviceConfig);
}
});
}
public IDevice CreateDevice(ILogger logger, ITransportFactory transportFactory,
ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config)
{
var device = new EngineDevice(logger, transportFactory, telemetryFactory, configurationProvider);
device.Init(config);
return(device);
}
internal WeatherShieldDeviceFactory(ILogger logger, ITransportFactory transportFactory,
ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config)
{
}
public async void StartDeviceSensorAsync(AbstractSensor sensor, dynamic device)
{
if (device == null)
return;
bool hasMutex = false;
try
{
hasMutex = _mutex.WaitOne(5000);
;
// check if device already exists
string deviceID = DeviceSchemaHelper.GetDeviceID(device);
WeatherShieldDevice existingDevice;
if (!_devices.ContainsKey(deviceID))
{
var deviceCancellationToken = new CancellationTokenSource();
_cancellationTokens.Add(deviceID, deviceCancellationToken);
//Initialize device as a new
existingDevice = new WeatherShieldDevice(this._logger, this._transportFactory,
this._telemetryFactory, this._configProvider, deviceCancellationToken.Token);
InitialDeviceConfig config = await this._deviceConfiguration.GetDeviceAsync(deviceID);
if (config == null) {
config = new InitialDeviceConfig();
///HostName=MtcDataCenter.azure-devices.net;DeviceId=makhluDev;SharedAccessKey=Q3e1wSyrkpspcR06m11bNw==
config.Key = @"QoGh9kGJus4hvWUX9Hhjag==";//string.Empty;
config.HostName = @"MtcDataCenter.azure-devices.net";//string.Empty;
}
existingDevice.Init(config, device);
_devices.Add(deviceID, existingDevice);
}
else
{
existingDevice = _devices[deviceID] as WeatherShieldDevice;
}
existingDevice.AddDeviceSensor(sensor);
this._logger.LogInfo("Addedd sensor {0} dor device id {1}", new object[] { sensor.Title, existingDevice.DeviceID });
}catch(Exception ex)
{
this._logger.LogError("Error adding {0} for device {1}. Error message: {2}", new object[] { sensor, device, ex.Message });
}
finally
{
if (hasMutex)
{
_mutex.ReleaseMutex();
}
}
}
