VeloeGameServerDataCollector/VeloeMonitorDataCollector/DataCollector.cs

using System.Text;
using LibreHardwareMonitor.Hardware;
using MinecraftStatus;
using SteamQueryNet;
using SteamQueryNet.Interfaces;
using System.Text.Json;
using Microsoft.Extensions.Configuration;
using VeloeMonitorDataCollector.DatabaseConnectors;
using VeloeMonitorDataCollector.Models;
using Serilog;
using VeloeMonitorDataCollector.Dependencies;

namespace VeloeMonitorDataCollector
{
    public class DataCollector
    {
        private Dictionary<string, Task> _updaterTasks; //TODO i can use an array here

        CancellationToken _token;
        CancellationTokenSource _cancellationTokenSource;

        Serilog.ILogger _logger;
        
        Computer? _computerHardware;
        float prevIdle = 0f;
        float prevTotal = 0f;
        List<DriveInfo> _drives;
        Dictionary<string, int> _deviceLoadSensorIndex = new()
        {
            {"cpuload", -1},
            {"ramavailable", -1},
            {"ramused", -1},
            {"ramload", -1}
        };
        
        private List<IDataSendable> _sendToDb; //TODO and here
        
        
        //Exception thrown on checking values 
        /// <exception cref="ArgumentNullException">when there is no value in INI file or this value is not declared.</exception>
        /// <exception cref="ArgumentOutOfRangeException">when value in INI file does not match in range. Example: Port value range is 1..65565]</exception>
        /// <exception cref="FormatException">when value can not be parsed to needed type. Expample: Port value can't be NaN</exception>
        /// <exception cref="OverflowException">when provided value caused overflowed return variable in parse method.</exception>

        public DataCollector(in IConfiguration data,in Serilog.ILogger logger)
        {
            _updaterTasks = new Dictionary<string, Task>(); 
            _cancellationTokenSource = new CancellationTokenSource();
            _token = _cancellationTokenSource.Token;

            _logger = logger;
         
            //ini file check
            //is it needed?
            if (!File.Exists("config.ini"))
            {
                File.WriteAllText("config.ini",
                    "#[Hardware]\n#hardware = true\n#hardwareUpdateInterval = true\n\n#[MySQL]\n#server = 127.0.0.1\n#port = 8806\n#uid = User\n#pwd = Password\n#database = values\n\n#[WebSoket]\n#url = http://192.168.1.2:5000\n\n#[MinecraftServer]\n#Ip = 127.0.0.1\n#Port = 25565\n#Type = Minecraft\n#updateInterval = 30\n\n#[SteamAPIServer]\n#Ip = 127.0.0.1\n#Port = 27015\n#Type = Steam\n#updateInterval = 30\n\n#[Gamespy3Server]\n#Ip = 127.0.0.1\n#Port = 5446\n#Type = Gamespy3\n#updateInterval = 30\n\n#[Gamespy2Server]\n#Ip = 127.0.0.1\n#Port = 10480\n#Type = Gamespy2\n#updateInterval = 30");
                throw new FileNotFoundException("config.ini does not exist! Default config was created as an example.");
            }

            //check read/write
            //is it needed
            FileStream config = File.Open("config.ini", FileMode.Open, FileAccess.ReadWrite);
            config.Close();
            config.Dispose();

            var hardware = data.GetSection("Hardware");

            //ini hardvare section validation
            
            if (hardware["hardware"] != "true" && hardware["hardware"] != "false" || hardware["hardware"] is null) 
            {
                hardware["hardware"] = "false";
            }

            //configuring database connections
            var dbSections = data
                    .GetChildren()
                    .Where(section => 
                        section.Path is ("MySQL" or "InfluxDB" or "TimescaleDB" or "WebSoket"))
                    .ToArray();

            _sendToDb = new List<IDataSendable>();
            if (!dbSections.Any()) 
            {
                _logger.Information("No databases detected.");
            }
            else
            {
                foreach (var dbSection in dbSections)
                {
                    //init db connections
                    switch (dbSection.Path)
                    {
                        case "MySQL":
                            try
                            {
                                var mySqlDb = new VeloeMonitorDataCollector.DatabaseConnectors.MySqlConnector(dbSection, logger);
                                _sendToDb.Add(mySqlDb);
                            }
                            catch (Exception ex)
                            {
                                logger.Warning("Database connector not confugured properly. It won't be added in working configuration.");
                                logger.Error(ex.Message);
                            }
                            break;

                        case "WebSoket":
                            try
                            {
                                SignalRConnector signalRWebApp = new(dbSection, logger);
                                _sendToDb.Add(signalRWebApp);
                            }
                            catch (Exception ex)
                            {
                                logger.Warning("SignalR connector not confugured properly. It won't be added in working configuration.");
                                logger.Error(ex.Message);
                            }
                            break;

                        case "TimescaleDB":
                            throw new NotImplementedException();

                        case "InfluxDB":
                            throw new NotImplementedException();

                    }


                }
            }

            // checking params in game servers sections
            // configuring game servers
            var gameServersSections = data
                .GetChildren()
                .Where (section => 
                    section.Key is not ("MySQL" or "InfluxDB" or"TimescaleDB" or "WebSoket" or "Hardware"))
                .ToArray();

            if (!gameServersSections.Any())
            {
                //add commented block with default example
                _logger.Information("No game servers detected.");
            }
            else
                
                foreach (var gameServer in gameServersSections)
                {
                    //Console.WriteLine(gameServer.Key);
                    if (gameServer["Ip"] == null ||
                        gameServer["Port"] == null ||
                        gameServer["Type"] == null)
                    {
                        throw new ArgumentNullException($"Some parameters for {gameServer.Key} are missing.");
                    }
                    
                    if (!(Int32.Parse(gameServer["Port"]) is >= 1 and <= 65565))
                        throw new ArgumentOutOfRangeException(gameServer["Port"]);

                    foreach (char c in gameServer.Key)
                    {
                        if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')))
                        {
                            throw new ArgumentException($"Not allowed symbols in {gameServer.Key}. Only letters and numbers are allowed.");
                        }
                    }
                }

            // create task for hardware update
            if (bool.Parse(hardware["hardware"]))
            {
                _computerHardware = new Computer()
                {
                    IsCpuEnabled = true,
                    IsMemoryEnabled = true,
                };
                _drives = new List<DriveInfo>();

                DriveInfo[] allDrives = DriveInfo.GetDrives();

                foreach (DriveInfo d in allDrives)
                {
                    if (d.IsReady == true && (d.DriveType is DriveType.Fixed or DriveType.Network) && d.TotalSize != 0 && !(d.Name.StartsWith("/boot") || d.Name.StartsWith("/dev")))
                    {
                        _drives.Add(d);                       
                    }
                }

                _computerHardware.Open();
                SetValuesTimeZero();    //no history

                CreateHardwareInfoFile();

                //check database table configuration
                foreach (var database in _sendToDb)
                {
                    var hardwareConfiguration = UpdateHardware();
                    if (database.CheckHardware(hardwareConfiguration) is false)
                    {
                        throw new Exception(
                            "Table configuration for hardware is invalid. Repair it manually or drop table and restart program.");
                    }
                }

                int updateIntervalHardware;
                if (!Int32.TryParse(hardware["updateIntervalHardware"], out updateIntervalHardware))
                {
                    _logger.Warning("Unable to parse updateIntervalHardware. Used default value.");
                    updateIntervalHardware = 1;
                }

                _updaterTasks.Add("hardware", new Task(async () => 
                {                  
                    while (!_token.IsCancellationRequested)
                    {
                        //Console.WriteLine(_token.IsCancellationRequested);
                        var data = UpdateHardware();
                        if (_sendToDb != null)
                            foreach (var dbController in _sendToDb)
                            {
                                dbController.SendHardware(data);
                            }
                        
                        await Task.Delay(TimeSpan.FromSeconds(updateIntervalHardware));
                    }
                }, _token));
            }
            //create tasks for game servers updates

            foreach (var section in gameServersSections)
            {
                //check database table configuration
                foreach (var database in _sendToDb)
                {   //Gamespy3 servers ignores it
                    //Tablecheck in BuildUpdater method
                    if (database.CheckGameServer(section.Key, section["Type"]) is false)
                    {
                        throw new Exception(
                            $"Table {section.Key} configuration is invalid. Repair it manually or drop table and restart program.");
                    }
                }
                int interval;
                if (!Int32.TryParse(section["updateInterval"], out interval))
                {
                    _logger.Information("Unable to parse updateInterval. Used default value.");
                    interval = 1;
                }

                    BuildUpdater(section.Path,
                    section["Ip"],
                    Int32.Parse(section["Port"]), 
                    section["Type"], interval);
            }
        }


        public void Start()
        {
            foreach (var task in _updaterTasks)
            {
                _logger.Information("{0} started!",task.Key);
                task.Value.Start();
            }
        }

        public void Stop()
        {
            _cancellationTokenSource.Cancel();

            bool tasksStillActive = true;
            while (tasksStillActive)
            {
                tasksStillActive = false;

                foreach (var task in _updaterTasks)
                   if (task.Value.Status == TaskStatus.Running) tasksStillActive = true;

                Task.Delay(TimeSpan.FromMilliseconds(250));
            }

            if (_computerHardware is not null)
                _computerHardware.Close();
            //wait to Tasks to end their execution

            //close all db connections
            foreach (var database in  _sendToDb)
            {
                database.Close();
            }
            
        }

        private void SetValuesTimeZero()
        {
            if (_computerHardware is null)
                return;

            foreach (var hardware in _computerHardware.Hardware)
            {
                foreach (var sensor in hardware.Sensors)
                {
                    sensor.ValuesTimeWindow = TimeSpan.Zero;
                }
            }
        }

        private void CreateHardwareInfoFile()
        {
            File.Create("sysinfo.txt").Close();

            StreamWriter sw = File.AppendText("sysinfo.txt");

            if (OperatingSystem.IsLinux())
            {
                var cpuLine = File
                    .ReadAllLines("/proc/stat")
                    .First()
                    .Split(' ', StringSplitOptions.RemoveEmptyEntries)
                    .Skip(1)
                    .Select(float.Parse)
                    .ToArray();

                var idle = cpuLine[3];
                var total = cpuLine.Sum();

                var percent = 100 * (1.0f - (idle - prevIdle) / (total - prevTotal));
                sw.WriteLine("CPU Load: {0}", percent);

                prevIdle = idle;
                prevTotal = total;

            }

            foreach (var hardware in _computerHardware.Hardware)
            {
                hardware.Update();
                //foreach (var sensor in hardware.Sensors)
                //    _logger.Warning("{0}: {1}", sensor.Name, sensor.Value);
                sw.WriteLine(hardware.Name);
                sw.WriteLine("  Type: {0}", hardware.HardwareType);
                sw.WriteLine("  Type: {0}", hardware.Identifier);
                sw.WriteLine("  Sensors:");
                foreach (var sensor in hardware.Sensors)
                {
                    sw.WriteLine("    {0,-25}  {1,-15}  {2,-15}",sensor.Name, sensor.SensorType, sensor.Value);
                }
            }


            foreach (DriveInfo d in DriveInfo.GetDrives())
            {
                if (d.IsReady == true && (d.DriveType is DriveType.Fixed or DriveType.Network) && d.TotalSize != 0 && !(d.Name.StartsWith("/boot") || d.Name.StartsWith("/dev")))
                {
                    sw.WriteLine("Drive {0}", d.Name);
                    sw.WriteLine("  File type: {0}", d.DriveType);

                    sw.WriteLine("  Volume label: {0}", d.VolumeLabel);
                    sw.WriteLine("  File system: {0}", d.DriveFormat);
                    sw.WriteLine(
                        "  Available space to current user:{0, 15} bytes",
                        d.AvailableFreeSpace);

                    sw.WriteLine(
                        "  Total available space:          {0, 15} bytes",
                        d.TotalFreeSpace);

                    sw.WriteLine(
                        "  Total size of drive:            {0, 15} bytes ",
                        d.TotalSize);
                }
            }

            sw.Close();
        }
        private Dictionary<string, float> UpdateHardware()
        {
            Dictionary<string, float> output = new Dictionary<string, float>();

            if (_computerHardware is null)
                return output;

            if (OperatingSystem.IsLinux())
            {
                var cpuLine = File
                    .ReadAllLines("/proc/stat")
                    .First()
                    .Split(' ', StringSplitOptions.RemoveEmptyEntries)
                    .Skip(1)
                    .Select(float.Parse)
                    .ToArray();

                var idle = cpuLine[3];
                var total = cpuLine.Sum();

                var percent = 100 * (1.0f - (idle - prevIdle) / (total - prevTotal));
                //for the first calc number can be inf or nan
                if (float.IsFinite(percent))
                    output.Add("cpuload", percent);

                prevIdle = idle;
                prevTotal = total;

            }

            foreach (var hardware in _computerHardware.Hardware)
            {
                hardware.Update();
                //foreach (var sensor in hardware.Sensors)
                //    _logger.Warning("{0}: {1}", sensor.Name, sensor.Value);
   
                if (hardware.HardwareType is HardwareType.Cpu && OperatingSystem.IsWindows())
                    if (_deviceLoadSensorIndex["cpuload"] is not -1)
                        output.Add("cpuload", hardware.Sensors[_deviceLoadSensorIndex["cpuload"]].Value.GetValueOrDefault());
                    else
                    {
                        for(int i = 0; i < hardware.Sensors.Length; i++)
                            if (hardware.Sensors[i].SensorType is SensorType.Load && hardware.Sensors[i].Name == "CPU Total")
                            {
                                output.Add("cpuload", hardware.Sensors[i].Value.GetValueOrDefault());
                                _deviceLoadSensorIndex["cpuload"] = i;
                            }
                    }

                if (hardware.HardwareType is HardwareType.Memory)
                {
                    //output.Add("ramavailable", hardware.Sensors[1].Value.GetValueOrDefault());
                    if (_deviceLoadSensorIndex["ramavailable"] is not -1)
                        output.Add("ramavailable", hardware.Sensors[_deviceLoadSensorIndex["ramavailable"]].Value.GetValueOrDefault());
                    else
                    {
                        for (int i = 0; i < hardware.Sensors.Length; i++)
                            if (hardware.Sensors[i].SensorType is SensorType.Data && hardware.Sensors[i].Name == "Memory Available")
                            {
                                output.Add("ramavailable", hardware.Sensors[i].Value.GetValueOrDefault());
                                _deviceLoadSensorIndex["ramavailable"] = i;
                            }
                    }
                    //output.Add("ramused", hardware.Sensors[0].Value.GetValueOrDefault());
                    if (_deviceLoadSensorIndex["ramused"] is not -1)
                        output.Add("ramused", hardware.Sensors[_deviceLoadSensorIndex["ramused"]].Value.GetValueOrDefault());
                    else
                    {
                        for (int i = 0; i < hardware.Sensors.Length; i++)
                            if (hardware.Sensors[i].SensorType is SensorType.Data && hardware.Sensors[i].Name == "Memory Used")
                            {
                                output.Add("ramused", hardware.Sensors[i].Value.GetValueOrDefault());
                                _deviceLoadSensorIndex["ramused"] = i;
                            }
                    }
                    //output.Add("ramload", hardware.Sensors[2].Value.GetValueOrDefault());
                    if (_deviceLoadSensorIndex["ramload"] is not -1)
                        output.Add("ramload", hardware.Sensors[_deviceLoadSensorIndex["ramload"]].Value.GetValueOrDefault());
                    else
                    {
                        for (int i = 0; i < hardware.Sensors.Length; i++)
                            if (hardware.Sensors[i].SensorType is SensorType.Load && hardware.Sensors[i].Name == "Memory")
                            {
                                output.Add("ramload", hardware.Sensors[i].Value.GetValueOrDefault());
                                _deviceLoadSensorIndex["ramload"] = i;
                            }
                    }
                }
            }

            for (int i = 0; i < _drives.Count; i++)
            {
                _drives[i] = new DriveInfo(_drives[i].Name);
                var name = "";
                
                if (OperatingSystem.IsWindows())
                    name = _drives[i].Name.ToLower().Replace(":\\", "").Replace('\\','_');
                else
                    if (_drives[i].Name == "/")
                        name = "root_directory";
                    else
                        name = _drives[i].Name.ToLower().Replace('/','_');
                output.Add(name , (float)_drives[i].TotalFreeSpace / _drives[i].TotalSize);
            }
            return output;
        }

        private void BuildUpdater(string name ,string ip, int port, string type, int interval)
        {
            switch (type)
            {
                case "Minecraft":

                    _updaterTasks.Add(name, new Task(async () => {
                        while (!_token.IsCancellationRequested)
                        {
                            await Task.Delay(TimeSpan.FromSeconds(interval));
                            McStatus? data = null;      
                            data = UpdateMinecraft(ip, port);
                            
                            if (data is null)
                                continue;

                            if (_sendToDb is null)
                                continue;
                            
                            foreach (var dbController in _sendToDb)
                            {
                                //_logger.Debug("Sending {0}", name);
                                dbController.SendMinecraft(data,name);
                            }
                        }
                    }, _token));

                    break;

                case "Steam":

                    _updaterTasks.Add(name, new Task(async () => {
                        while (!_token.IsCancellationRequested)
                        {
                            await Task.Delay(TimeSpan.FromSeconds(interval));
                            SteamData? data = null;

                            data = await UpdateSteam(ip, port, interval);

                            if (data is null)
                                continue;
                            
                            if (_sendToDb is null)
                                continue;
                            
                            foreach (var dbController in _sendToDb)
                            {
                                dbController.SendSteam(data.Value,name);
                            }
                        }
                    }, _token));

                    break;

                case "Gamespy3":

                    _updaterTasks.Add(name, new Task(async () => {
                        try
                        {
                            Gs3Status server = new Gs3Status(ip, port);
                            /*
                            bool dataIsNull = true;

                            while (dataIsNull && !_token.IsCancellationRequested)
                            {
                                var data = server.GetStatus();

                                if (data is null)
                                    continue;

                                if (_sendToDb is null)
                                    dataIsNull = false;

                                foreach(var dbController in _sendToDb)
                                {
                                    dbController.CheckGamespy3(data, name);
                                }
                            }
                            */
                            while (!_token.IsCancellationRequested)
                            {
                                try
                                {
                                    await Task.Delay(TimeSpan.FromSeconds(interval));
                                    var data = server.GetStatus();

                                    if (data is null)
                                        continue;

                                    if (_sendToDb is null)
                                        continue;

                                    foreach (var dbController in _sendToDb)
                                    {
                                        dbController.SendGamespy3(data, name);
                                    }
                                }
                                catch (System.Net.Sockets.SocketException ex)
                                {
                                    _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
                                }
                            }
                        }
                        catch(System.Net.Sockets.SocketException ex)
                        {
                            _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
                        }
                    }, _token));

                    break;

                case "Gamespy2":

                    _updaterTasks.Add(name, new Task(async () => {
                        try
                        {
                            Gs2Status server = new Gs2Status(ip, port);

                            while (!_token.IsCancellationRequested)
                            {
                                try
                                {
                                    await Task.Delay(TimeSpan.FromSeconds(interval));
                                    var data = server.GetStatus();

                                    if (data is null)
                                        continue;

                                    if (_sendToDb is null)
                                        continue;

                                    foreach (var dbController in _sendToDb)
                                    {
                                        dbController.SendGamespy2(data, name);
                                    }
                                }
                                catch (System.Net.Sockets.SocketException ex)
                                {
                                    _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
                                }
                            }
                        }
                        catch (System.Net.Sockets.SocketException ex)
                        {
                            _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
                        }
                    }, _token));

                    break;
            }
        }

        private McStatus? UpdateMinecraft(string ip, int port)
        {
            McStatus? status = null;
            try
            {
                status = McStatus.GetStatus(ip, port);
            }
            catch (Exception ex)
            {
                _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
            }

            if (status != null)
                return status;
            return null;
        }

        private async Task<SteamData?> UpdateSteam(string ip, int port, int interval)
        {   
            ServerQuery serverQuery = new ServerQuery();
            try
            {
                serverQuery.SendTimeout = 2000;
                serverQuery.ReceiveTimeout = 2000;

                SteamData? output = null;
                serverQuery.Connect(ip, (ushort)port);

                var serverInfo = await serverQuery.GetServerInfoAsync();
                var serverPlayers = await serverQuery.GetPlayersAsync();

                output = new SteamData
                {
                    ServerInfo = serverInfo,

                    Players = serverPlayers
                };
                

                if (output is null)
                    return null;
                
                return output;
            }
            catch (TimeoutException ex)
            {
                _logger.Debug("{0}:{1} {2}", ip, port, ex.Message); 
                return null;
            }
            catch (Exception ex)
            {
                _logger.Debug("{0}:{1} {2}", ip, port, ex.Message);
                return null;
            }
        }
        
    }
}