aswi2022bug-thugs-gitlab/ld_client/LDClient/detection/ProcessDetection.cs @ fa084fc4

using System.Diagnostics;
using LDClient.network;
using LDClient.network.data;

namespace LDClient.detection {
   
	 public sealed class ProcessDetection : IProcessDetection {
        
        private const string DatetimeFormat = "yyyy-MM-dd hh:mm:ss";

        private readonly string _processName;
        private readonly uint _detectionPeriodMs;
        private readonly IInfoFetcher _infoFetcher;
        private readonly IApiClient _apiClient;
        private readonly IProcessUtils _processUtils;

        private bool _processIsActive;
        private bool _failedToRetrieveData;
        private Payload? _lastConnectedPayload;

        public bool DetectionRunning = false;

        public ProcessDetection(string processName, uint detectionPeriodMs, IInfoFetcher infoFetcher, IApiClient apiClient, IProcessUtils processUtils) {
            _processName = processName;
            _detectionPeriodMs = detectionPeriodMs;
            _infoFetcher = infoFetcher;
            _apiClient = apiClient;
            _failedToRetrieveData = false;
            _processUtils = processUtils;
        }

        private async Task<bool> RetrieveDataFromDebugger() {
            var success = await _infoFetcher.FetchDataAsync();
            if (success) {
                _lastConnectedPayload = await SendDataToServerAsync(_infoFetcher.HeadSerialNumber, _infoFetcher.BodySerialNumber, DatetimeFormat);
            }
            return success;
        }

        private async Task DebuggerDisconnected() {
            if (_lastConnectedPayload is not null) {
                _lastConnectedPayload.Status = ConnectionStatus.Disconnected;
                _lastConnectedPayload.TimeStamp = DateTime.Now.ToString(DatetimeFormat);
                await _apiClient.SendPayloadAsync(_lastConnectedPayload);
                _lastConnectedPayload = null;
            }
        }

        private async Task DetectProcessAsync() {
            var processExists = _processUtils.IsProcessRunning(_processName);

            if (processExists && !_processIsActive) {
                Program.DefaultLogger.Info($"Process started: {_processName}");
                if (!_failedToRetrieveData) {
                    _failedToRetrieveData = !await RetrieveDataFromDebugger();
                }
            } else if (!processExists && _processIsActive) {
                Program.DefaultLogger.Info($"Process stopped: {_processName}");
                _failedToRetrieveData = false;
                await DebuggerDisconnected();
            }
            _processIsActive = processExists;
        }
        
        private async Task<Payload> SendDataToServerAsync(string headSerialNumber, string bodySerialNumber, string datetimeFormat) {
            Payload payload = new() {
                UserName = Environment.UserName,
                HostName = Environment.MachineName,
                TimeStamp = DateTime.Now.ToString(datetimeFormat),
                HeadDevice = new DebuggerInfo {
                    SerialNumber = headSerialNumber
                },
                BodyDevice = new DebuggerInfo {
                    SerialNumber = bodySerialNumber
                },
                Status = ConnectionStatus.Connected
            };
            await _apiClient.SendPayloadAsync(payload);
            return payload;
        }
        
        public async void RunPeriodicDetection() {
            Program.DefaultLogger.Info("Process periodic detector has started");
            DetectionRunning = true;
            while (DetectionRunning) {
                await DetectProcessAsync();
                Thread.Sleep((int)_detectionPeriodMs);
            }
        }
    }
}