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") { }