public Task <WorkstationMonitorServiceClient> GetNewWorkstationMonitorServiceClient()
{
NetTcpBinding netTcpBinding = new NetTcpBinding
{
CloseTimeout = this.timeoutTimeSpan,
OpenTimeout = this.timeoutTimeSpan,
SendTimeout = this.timeoutTimeSpan,
MaxBufferPoolSize = this.maxBufferPoolSize,
MaxBufferSize = this.maxBufferSize,
MaxReceivedMessageSize = this.maxReceivedMessageSize
};
netTcpBinding.ReliableSession.Enabled = this.reliableSessionEnabled;
netTcpBinding.ReliableSession.Ordered = this.reliableSessionOrdered;
netTcpBinding.Security.Mode = SecurityMode.Transport;
netTcpBinding.Security.Transport.ProtectionLevel = ProtectionLevel.EncryptAndSign;
netTcpBinding.Security.Transport.ClientCredentialType =
TcpClientCredentialType.Certificate;
X509Certificate2 serverCertificate = this.GetCertificate(this.MachineCertificateSubjectName);
X509Certificate2 clientCertificate = this.GetCertificate(this.ClientCertificateSubjectName);
// TODO: Refactor in order to validate certificate existance first and not to use exceptions in this case
if (serverCertificate == null)
{
throw new InvalidOperationException($"Certificate with subject name: {this.MachineCertificateSubjectName} not found.");
}
if (clientCertificate == null)
{
throw new InvalidOperationException($"Certificate with subject name: {this.ClientCertificateSubjectName} not found.");
}
EndpointAddress endpointAddress = new EndpointAddress(
new Uri(this.UriAddress),
EndpointIdentity.CreateX509CertificateIdentity(serverCertificate));
WorkstationMonitorServiceClient workstationMonitorServiceClient = new WorkstationMonitorServiceClient(netTcpBinding, endpointAddress);
// Specify a default certificate for the service.
workstationMonitorServiceClient.ClientCredentials.ServiceCertificate.SetDefaultCertificate(
StoreLocation.LocalMachine,
StoreName.TrustedPeople,
X509FindType.FindBySubjectDistinguishedName,
this.MachineCertificateSubjectName);
workstationMonitorServiceClient.ClientCredentials.ServiceCertificate
.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerOrChainTrust;
// Specify a certificate to use for authenticating the client.
workstationMonitorServiceClient.ClientCredentials.ClientCertificate.SetCertificate(
StoreLocation.LocalMachine,
StoreName.TrustedPeople,
X509FindType.FindBySubjectDistinguishedName,
this.ClientCertificateSubjectName);
return(Task.FromResult <WorkstationMonitorServiceClient>(workstationMonitorServiceClient));
}
public ITargetBlock <DateTimeOffset> CreateNeverEndingTaskMakingWcfCalls(
Func <DateTimeOffset, CancellationToken, WorkstationMonitorServiceClient, Task> action,
CancellationToken cancellationToken,
uint betweenCallsDelayInSeconds,
string machineIdentifier,
WorkstationMonitorServiceClient client)
{
ActionBlock <DateTimeOffset> block = null;
block = new ActionBlock <DateTimeOffset>(
async now =>
{
try
{
await action(now, cancellationToken, client)
.ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(betweenCallsDelayInSeconds), cancellationToken)
.ConfigureAwait(false);
// Post the action back to the block.
block.Post(DateTimeOffset.Now);
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(machineIdentifier);
client.Abort();
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(machineIdentifier);
client.Abort();
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(machineIdentifier);
client.Abort();
}
catch (TaskCanceledException ex)
{
client.Abort();
}
}, new ExecutionDataflowBlockOptions {
CancellationToken = cancellationToken
});
return(block);
}
public async Task <WindowsService[]> ReadWindowsServiceDynamicDataAsync(
WpfObservableRangeCollection <WindowsService> windowsServiceDynamicObservableCollection,
WorkstationMonitorServiceClient workstationMonitorServiceClient,
CancellationToken cancellationToken)
{
WindowsService[] result = await workstationMonitorServiceClient.ReadWindowsServiceDynamicDataAsync();
if (result != null && !cancellationToken.IsCancellationRequested)
{
windowsServiceDynamicObservableCollection.ReplaceRange(result, new WindowsServiceComparer());
}
return(result);
}
public IAsyncCommand CreateWindowsServiceDynamicDataCommand(WpfObservableRangeCollection <WindowsService> windowsService)
{
return(new AsyncCommand <bool>(async(cancellationToken) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
bool result = false;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
// Set the task.
var neverEndingTask = this.tPLFactory.CreateNeverEndingTaskMakingWcfCalls(
(now, ct, client) => this.wcfClient.ReadWindowsServiceDynamicDataAsync(windowsService, client, ct)
.WithCancellation(ct),
cancellationToken,
this.configProvider.DelayBetweenCalls_WindowsService,
this.wcfClient.MachineIdentifier,
workstationMonitorServiceClient);
// Start the task. Post the time.
result = neverEndingTask.Post(DateTimeOffset.Now);
// if cancel was not requested task is still ongoing
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(this.neverEndingCommandDelayInMiliSeconds);
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
}
return result;
});
}));
}
public async Task <HardwareDynamicData> ReadHardwareDynamicDataAsync(
WpfObservableRangeCollection <HardwareDynamicData> hardwareDynamicObservableCollection,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorClock,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorPower,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorLoad,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelDiskLoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelDiskTemp,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelMemoryData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPULoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUClock,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelGPUData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUVoltage,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardVoltage,
bool logsEnabled,
string logsDirectoryPath,
WorkstationMonitorServiceClient workstationMonitorServiceClient,
CancellationToken cancellationToken)
{
HardwareDynamicData result = await workstationMonitorServiceClient.ReadHardwareDynamicDataAsync();
if (result != null && !cancellationToken.IsCancellationRequested)
{
string fileName = string.Empty;
foreach (var processor in result.Processor)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "CPU");
foreach (var load in processor.Load)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorLoad, load, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var clock in processor.Clock)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorClock, clock, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, clock);
}
foreach (var power in processor.Power)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorPower, power, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, power);
}
foreach (var temperature in processor.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorTemp, temperature, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
}
foreach (var disk in result.Disk)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "DISK");
foreach (var load in disk.Load)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelDiskLoad, load, disk.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var temperature in disk.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelDiskTemp, temperature, disk.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
}
foreach (var memory in result.Memory)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "MEMORY");
foreach (var data in memory.Data)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelMemoryData, data, memory.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, data);
}
}
foreach (var gpu in result.VideoController)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "GPU");
foreach (var load in gpu.Load)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPULoad, load, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var temperature in gpu.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUTemp, temperature, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
foreach (var clock in gpu.Clock)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUClock, clock, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, clock);
}
foreach (var data in gpu.Data)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelGPUData, data, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, data);
}
foreach (var voltage in gpu.Voltage)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUVoltage, voltage, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, voltage);
}
foreach (var fan in gpu.Fan)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUFan, fan, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, fan);
}
}
foreach (var mainBoard in result.MainBoard)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "MAINBOARD");
foreach (var temperature in mainBoard.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardTemp, temperature, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
foreach (var fan in mainBoard.Fan)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardFan, fan, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, fan);
}
foreach (var voltage in mainBoard.Voltage)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardVoltage, voltage, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, voltage);
}
}
}
return(result);
}
public async Task <HardwareStaticData> ReadHardwareStaticDataAsync(WorkstationMonitorServiceClient client)
{
return(await client.ReadHardwareStaticDataAsync());
}
public async Task <OperationStatus> RestartMachineAsync(
WorkstationMonitorServiceClient workstationMonitorServiceClient,
uint timeoutInSeconds)
{
return(await workstationMonitorServiceClient.RestartMachineAsync(timeoutInSeconds));
}
public async Task <WindowsLog[]> ReadWindowsLogDynamicDataAsync(WorkstationMonitorServiceClient workstationMonitorServiceClient)
{
return(await workstationMonitorServiceClient.ReadWindowsLogDynamicDataAsync());
}
public IAsyncCommand CreateRestartMachineOffCommand(UIntParameter timeoutInSeconds)
{
return(new AsyncCommandParameterized <OperationStatus>(
async(cancellationToken, timeout) =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
OperationStatus result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await this.wcfClient.RestartMachineAsync(workstationMonitorServiceClient, ((UIntParameter)timeout).Parameter)
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
this.ShowMessageBox(result);
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
},
timeoutInSeconds));
}
public IAsyncCommand CreateSoftwareStaticDataCommand(
WpfObservableRangeCollection <CurrentUser> currentUser,
WpfObservableRangeCollection <OS> operatingSystem,
WpfObservableRangeCollection <Bios> bios,
WpfObservableRangeCollection <InstalledProgram> installedProgram,
WpfObservableRangeCollection <MicrosoftWindowsUpdate> microsoftWindowsUpdate,
WpfObservableRangeCollection <StartupCommand> startupCommand,
WpfObservableRangeCollection <LocalUser> localUser)
{
return(new AsyncCommand <SoftwareStaticData>(async(cancellationToken) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
SoftwareStaticData result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await this.wcfClient.ReadSoftwareStaticDataAsync(workstationMonitorServiceClient)
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
currentUser.ReplaceRange(result.CurrentUser, new CurrentUserStaticComparer());
operatingSystem.ReplaceRange(result.OperatingSystem, new OSComparer());
bios.ReplaceRange(result.Bios, new BiosComparer());
installedProgram.ReplaceRange(result.InstalledProgram, new InstalledProgramComparer());
microsoftWindowsUpdate.ReplaceRange(result.MicrosoftWindowsUpdate, new MicrosoftWindowsUpdateComparer());
startupCommand.ReplaceRange(result.StartupCommand, new StartupCommandComparer());
localUser.ReplaceRange(result.LocalUser, new LocalUserComparer());
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
});
}));
}
public IAsyncCommand CreateHardwareStaticDataCommand(
WpfObservableRangeCollection <ProcessorStatic> processorStatic,
WpfObservableRangeCollection <ProcessorCache> processorCache,
WpfObservableRangeCollection <Memory> memoryItems,
WpfObservableRangeCollection <BaseBoard> baseBoard,
WpfObservableRangeCollection <VideoController> videoController,
WpfObservableRangeCollection <NetworkAdapter> networkAdapter,
WpfObservableRangeCollection <PnPEntity> pnPEntity,
WpfObservableRangeCollection <CDROMDrive> cDROMDrive,
WpfObservableRangeCollection <Fan> fan,
WpfObservableRangeCollection <Printer> printer,
WpfObservableRangeCollection <Battery> battery,
WpfObservableRangeCollection <Storage> storage)
{
return(new AsyncCommand <HardwareStaticData>(async(cancellationToken) =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
HardwareStaticData result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await Task.Run <HardwareStaticData>(() => workstationMonitorServiceClient.ReadHardwareStaticDataAsync())
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
processorStatic.ReplaceRange(result.Processor, new ProcessorStaticComparer());
processorCache.ReplaceRange(result.ProcessorCache, new ProcessorCacheStaticComparer());
memoryItems.ReplaceRange(result.Memory, new MemoryStaticComparer());
baseBoard.ReplaceRange(result.BaseBoard, new BaseBoardStaticComparer());
videoController.ReplaceRange(result.VideoController, new VideoControllerStaticComparer());
networkAdapter.ReplaceRange(result.NetworkAdapter, new NetworkAdapterStaticComparer());
pnPEntity.ReplaceRange(result.PnPEntity, new PnPEntityStaticComparer());
cDROMDrive.ReplaceRange(result.CDROMDrive, new CDROMDriveStaticComparer());
fan.ReplaceRange(result.Fan, new FanStaticComparer());
printer.ReplaceRange(result.Printer, new PrinterStaticComparer());
battery.ReplaceRange(result.Battery, new BatteryStaticComparer());
storage.ReplaceRange(result.Storage);
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
}));
}
public IAsyncCommand CreateHardwareDynamicDataCommand(
WpfObservableRangeCollection <HardwareDynamicData> hardwareDynamic,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorClock,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorPower,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorLoad,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelDiskLoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelDiskTemp,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelMemoryData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPULoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUClock,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelGPUData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUVoltage,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardVoltage,
string machineName)
{
return(new AsyncCommandParameterized <bool>(
async(cancellationToken, nameOfMachine) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
bool result = false;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
bool logsEnabled = false;
DirectoryInfo logsDirectory = null;
if (this.configProvider.DynamicHardwareLogs_Include)
{
string logsPath = this.configProvider.DynamicHardwareLogs_Path;
if (!string.IsNullOrEmpty(logsPath))
{
string directoryName = nameOfMachine + "_Hardware_Dynamic_Logs\\";
logsDirectory = Directory.CreateDirectory(logsPath + directoryName);
logsEnabled = true;
}
}
string logsDirectoryPath = logsDirectory?.FullName ?? string.Empty;
// Set the task.
var neverEndingTask = this.tPLFactory.CreateNeverEndingTaskMakingWcfCalls(
(now, ct, client) => this.wcfClient.ReadHardwareDynamicDataAsync(
hardwareDynamic,
dynamicChartViewModelProcessorClock,
dynamicChartViewModelProcessorPower,
dynamicChartViewModelProcessorTemp,
dynamicChartViewModelProcessorLoad,
dynamicChartViewModelDiskLoad,
dynamicChartViewModelDiskTemp,
dynamicChartViewModelMemoryData,
dynamicChartViewModelGPULoad,
dynamicChartViewModelGPUTemp,
dynamicChartViewModelGPUClock,
dynamicChartViewModelGPUData,
dynamicChartViewModelGPUVoltage,
dynamicChartViewModelGPUFan,
dynamicChartViewModelMainBoardTemp,
dynamicChartViewModelMainBoardFan,
dynamicChartViewModelMainBoardVoltage,
logsEnabled,
logsDirectoryPath,
client,
ct)
.WithCancellation(ct),
cancellationToken,
this.configProvider.DelayBetweenCalls_HardwareDynamic,
this.wcfClient.MachineIdentifier,
workstationMonitorServiceClient);
// Start the task. Post the time.
result = neverEndingTask.Post(DateTimeOffset.Now);
// if cancel was not requested task is still ongoing
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(this.neverEndingCommandDelayInMiliSeconds);
}
}
catch (Exception ex)
{
this.messageSender.SendErrorMessage(ex.Message);
}
return result;
});
}, machineName));
}
public IAsyncCommand CreateWindowsLogDynamicDataCommand(WpfObservableRangeCollection <WindowsLog> windowsLog)
{
return(new AsyncCommand <WindowsLog[]>(async(cancellationToken) =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
WindowsLog[] result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await this.wcfClient.ReadWindowsLogDynamicDataAsync(workstationMonitorServiceClient)
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
windowsLog.ReplaceRange(result, new WindowsLogComparer());
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
}));
}
