public void GivenNotSupportedTarget_WhenGetCalculatedValue_ThenItThrowsProper()
{
IHardwareManager manager = GivenHardwareManager();
MonitoringTarget notSupported = GetNotSupportedTarget();
Assert.Throws <HardwareCommunicationException>(() => manager.GetCalculatedValue(notSupported));
}
public override HardwareInformation GetValue(MonitoringTarget resource)
{
switch (resource)
{
case MonitoringTarget.CPU_Core_Count:
return(GetCpuCoreCount());
case MonitoringTarget.CPU_Clock_Speed:
return(GetCpuClockSpeed());
case MonitoringTarget.CPU_Make:
return(GetCpuMake());
case MonitoringTarget.CPU_Temp:
return(GetCpuTemperature());
case MonitoringTarget.CPU_Thread_Count:
return(GetCpuThreadCount());
case MonitoringTarget.CPU_Load:
return(GetGlobalCpuUsageWithPerfCounter());
case MonitoringTarget.RAM_Usage:
return(GetRamMemoryUsage());
default:
throw new NotImplementedException($"Monitoring target '{resource}' is not implemented for connector {nameof(WMI_Connector)}");
}
}
private void SetMonitoringDictionary(KeyValuePair <MonitoringTarget, bool> target)
{
_targetDict[target.Key] = target.Value;
if (target.Value)
{
_lruTargets.Add(target.Key);
}
else if (!target.Value && _lruTargets.Contains(target.Key))
{
_lruTargets.Remove(target.Key);
}
while (_lruTargets.Count() > MaxAllowedMonTargets)
{
MonitoringTarget lruTarget = _lruTargets.First();
if (_lruTargets.Any())
{
_lruTargets.RemoveAt(0);
}
_targetDict[lruTarget] = false;
}
SetCheckboxValues();
if (_lruTargets.Count() == MaxAllowedMonTargets)
{
PublishQueue(_lruTargets);
}
}
public void GivenMaxTargetNotCountTopped_WhenAddingAdditionalTarget_ThenItAppendsIt()
{
List <MonitoringTarget> updatedTargets = null;
MonitoringTarget expectedFirstTarget = _currentTargets.ElementAt(0);
MonitoringTarget notCurrentlyMonitored = _allTargets.Except(_currentTargets).FirstOrDefault();
Mock <IEventAggregator> eventManager = new Mock <IEventAggregator>();
Mock <OnWatchdogTargetChangedEvent> watchdogTargetChangedEvent = new Mock <OnWatchdogTargetChangedEvent>();
Mock <OnMonitoringTargetsChangedEvent> monTargetChangedEvent = new Mock <OnMonitoringTargetsChangedEvent>();
monTargetChangedEvent.Setup(e => e.Publish(It.IsAny <List <MonitoringTarget> >())).Verifiable();
monTargetChangedEvent.Setup(e => e.Publish(It.IsAny <List <MonitoringTarget> >())).Callback <List <MonitoringTarget> >(lru => updatedTargets = lru);
ComputerMonitoringTestHelper.SetupEventAggMockBehaviour(eventManager, watchdogTargetChangedEvent.Object, monTargetChangedEvent.Object);
Mock <IAppManager> appManagerMock = GivenAppManagerMock();
HardwareSettingsViewModel hardwareSettingsVm = new HardwareSettingsViewModel(eventManager.Object, appManagerMock.Object, Mock.Of <IUiSettings>());
hardwareSettingsVm.MaxAllowedMonTargets++;
MonitoringTargetViewModel elementToAdd = hardwareSettingsVm.MonitoringOptionsCollection.SingleOrDefault(mo => mo.Type == notCurrentlyMonitored);
elementToAdd.IsSelected = true;
elementToAdd.PublishMonitoringOptionStatusCommand.Execute(new KeyValuePair <MonitoringTarget, bool>(elementToAdd.Type, elementToAdd.IsSelected));
Assert.Equal(expectedFirstTarget, updatedTargets.FirstOrDefault());
monTargetChangedEvent.Verify(e => e.Publish(It.IsAny <List <MonitoringTarget> >()), Times.Exactly(2));
}
public void GivenTargetConfig_WhenGetAllTargets_ThenItOmitsNotReachableTargets()
{
IHardwareManager manager = GivenHardwareManager();
IEnumerable <MonitoringTarget> allTargets = GetConfigurationAllTargets();
MonitoringTarget notSupported = GetNotSupportedTarget();
IEnumerable <MonitoringTarget> actual = manager.GetAllTargets();
Assert.NotEmpty(allTargets.Except(actual));
Assert.Contains(notSupported, allTargets.Except(actual));
}
public override HardwareInformation GetValue(MonitoringTarget resource)
{
switch (resource)
{
case MonitoringTarget.Server_CPU_Load:
case MonitoringTarget.Server_CPU_Temp:
case MonitoringTarget.Server_RAM_Usage:
var resultDTO = Task.Run(() => GetSingleResourceInfo(resource)).Result;
return(MapDTO2Model(resultDTO));
default:
throw new NotImplementedException($"Monitoring target '{resource}' not implemented for connector {nameof(ASPNET_API_Connector)}");
}
}
private Uri GetUri(MonitoringTarget ressource)
{
switch (ressource)
{
case MonitoringTarget.Server_CPU_Load:
return(new Uri(_client.BaseAddress, "/api/GeneralUsage/Cpu"));
case MonitoringTarget.Server_RAM_Usage:
return(new Uri(_client.BaseAddress, "/api/GeneralUsage/Ram"));
case MonitoringTarget.Server_CPU_Temp:
return(new Uri(_client.BaseAddress, "/api/Temperature/Cpu"));
default:
throw new NotImplementedException($"No Specific URI for resource'{ressource.ToString()}'");
}
}
public override HardwareInformation GetValue(MonitoringTarget resource)
{
switch (resource)
{
case MonitoringTarget.GPU_Make:
return(GetFirstGpuMake());
case MonitoringTarget.GPU_Temp:
return(GetFirstGpuTemp());
case MonitoringTarget.GPU_Load:
return(GetFirstGpuLoad());
default:
throw new NotImplementedException($"Monitoring target '{resource}' is not implemented for connector {nameof(NVDIA_API_Connector)}");
}
}
private async Task <ServerResourceDTO> GetSingleResourceInfo(MonitoringTarget target)
{
var uri = GetUri(target);
using (var response = await _client.GetAsync(uri))
{
if (response.IsSuccessStatusCode)
{
var output = await response.Content.ReadAsAsync <ServerResourceDTO>();
return(output);
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
public virtual IHardwareInfo GetCalculatedValue(MonitoringTarget target)
{
var targetKey = _target2Connector.SingleOrDefault(t2C => t2C.Key.TargetType == target).Key;
if (_target2Connector[targetKey] == null)
{
_target2Connector[targetKey] = _connectorFactory.CreateInstance(targetKey.ConnectorName);
}
try
{
return(_target2Connector[targetKey].GetValue(target));
}
catch (Exception e)
{
throw new HardwareCommunicationException(e.Message);
}
}
public override HardwareInformation GetValue(MonitoringTarget resource)
{
switch (resource)
{
case MonitoringTarget.GPU_Clock:
return(GetHardwareSensorValue <double>("MHz", "GPU Core", OpenHardwareSensorType.Clock));
case MonitoringTarget.GPU_Make:
return(GetGpuMake());
case MonitoringTarget.GPU_Memory_Controller:
return(GetHardwareSensorValue <double>("Mem.Controllers", "GPU Memory Controller", OpenHardwareSensorType.Load));
case MonitoringTarget.GPU_Memory_Clock:
return(GetHardwareSensorValue <double>("MHz Mem.Clock", "GPU Memory", OpenHardwareSensorType.Clock));
case MonitoringTarget.GPU_Memory_Load:
return(GetHardwareSensorValue <double>("%", "GPU Memory", OpenHardwareSensorType.Load));
case MonitoringTarget.GPU_Shader_Clock:
return(GetHardwareSensorValue <double>("MHz Shader.Clock", "GPU Shader", OpenHardwareSensorType.Clock));
case MonitoringTarget.GPU_Temp:
return(GetHardwareSensorValue <double>("°C", "GPU Core", OpenHardwareSensorType.Temperature));
case MonitoringTarget.GPU_Load:
return(GetHardwareSensorValue <double>("%", "GPU Core", OpenHardwareSensorType.Load));
case MonitoringTarget.GPU_VideoEngine_Load:
return(GetHardwareSensorValue <double>("%", "GPU Video Engine", OpenHardwareSensorType.Load));
case MonitoringTarget.FAN_Speed:
return(GetMainFanSpeed());
case MonitoringTarget.Mother_Board_Make:
return(GetMotherBoardMake());
default:
throw new NotImplementedException($"Monitoring target '{resource}' not implemented for connector {nameof(OpenHardware_Connector)}");
}
}
public void GivenMultipleSupportedTargetsWithOneNotSupported_WhenGetCalculatedValues_ThenItReturnsProperValue()
{
IHardwareManager manager = GivenHardwareManager();
ICollection <MonitoringTarget> expected = GetConfigurationInitialTargets().ToList();
MonitoringTarget notSupported = GetNotSupportedTarget();
expected.Add(notSupported);
int initialCount = expected.Count();
IEnumerable <IHardwareInfo> values = manager.GetCalculatedValues(expected);
Assert.All(values, v =>
{
Assert.NotNull(v);
Assert.NotNull(v.MainValue);
Assert.NotEmpty(v.ShortName);
Assert.NotEmpty(v.UnitSymbol);
});
Assert.Equal(initialCount - 1, expected.Count());
Assert.DoesNotContain(notSupported, expected);
}
public override HardwareInformation GetValue(MonitoringTarget resource)
{
IEnumerable <IDriveInfo> localDrives = _provider.GetLocalDrive();
IEnumerable <IDriveInfo> networkDrives = _provider.GetNetworkDrive();
switch (resource)
{
case MonitoringTarget.Primary_HDD_Used_Space:
return(GetDriveUsage(localDrives.SingleOrDefault(D => D.Name.StartsWith("C"))));
case MonitoringTarget.Secondary_HDD_Used_Space:
return(GetDriveUsage(localDrives.FirstOrDefault(D => !D.Name.StartsWith("C"))));
case MonitoringTarget.Primary_Network_HDD_Used_Space:
return(GetDriveUsage(networkDrives.FirstOrDefault()));
case MonitoringTarget.Secondary_Network_HDD_Used_Space:
return(GetDriveUsage(networkDrives.ElementAtOrDefault(1)));
default:
throw new NotImplementedException($"Monitoring target {resource} not implemented for connector {nameof(SystemIO_Connector)}");
}
}
public IHardwareInfo GetCalculatedValue(MonitoringTarget monTarget)
{
return(_hardwareManager.GetCalculatedValue(monTarget));
}
public MonitoringTargetViewModel(MonitoringTarget type)
{
Type = type;
}
public abstract HardwareInformation GetValue(MonitoringTarget resource);
public HardwareCommunicationException(MonitoringTarget monTarget) :
base($"Can't reach {monTarget} on computer")
{
}
