446 lines
18 KiB
C#
446 lines
18 KiB
C#
using System.Diagnostics;
|
|
using Microsoft.AspNetCore.Builder;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Hosting;
|
|
using Newtonsoft.Json;
|
|
using Microsoft.AspNetCore.Http;
|
|
using System.Runtime.InteropServices;
|
|
using System.Management;
|
|
|
|
namespace ResourceMonitorService
|
|
{
|
|
public class Worker : BackgroundService
|
|
{
|
|
private readonly IHostApplicationLifetime _lifetime;
|
|
|
|
public Worker(IHostApplicationLifetime lifetime)
|
|
{
|
|
_lifetime = lifetime;
|
|
}
|
|
|
|
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
|
{
|
|
var builder = WebApplication.CreateBuilder();
|
|
builder.Services.AddCors(options =>
|
|
{
|
|
options.AddPolicy("AllowAllOrigins",
|
|
builder => builder
|
|
.WithOrigins("http://localhost:4200","http://192.168.50.52:4200","http://vmwin11:4200")
|
|
.AllowAnyHeader()
|
|
.AllowAnyMethod());
|
|
});
|
|
builder.Services.AddControllers().AddNewtonsoftJson();
|
|
|
|
// Read the API key from appsettings.json
|
|
var configuration = builder.Configuration;
|
|
var apiKey = configuration["ApiSettings:ApiKey"];
|
|
|
|
var app = builder.Build();
|
|
|
|
// Middleware to validate API key
|
|
// This middleware checks for the presence of the API key in the request headers
|
|
// and compares it with the expected API key from appsettings.json.
|
|
// If the API key is missing or invalid, it returns a 401 Unauthorized response.
|
|
//
|
|
/* app.Use(async (context, next) =>
|
|
{
|
|
if (!context.Request.Headers.TryGetValue("X-API-KEY", out var extractedApiKey) || extractedApiKey != apiKey)
|
|
{
|
|
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
|
|
await context.Response.WriteAsync("Unauthorized: Invalid API Key");
|
|
return;
|
|
}
|
|
|
|
await next();
|
|
}); */
|
|
// Apply CORS policy to allow all origins
|
|
app.UseCors("AllowAllOrigins");
|
|
|
|
app.MapGet("/api/resource-usage", async context =>
|
|
{
|
|
var currentTime = GetCurrentTime();
|
|
|
|
var computerInfo = GetComputerInfo();
|
|
var cpuUsage = GetCpuUsage();
|
|
var ramUsage = GetRamUsage();
|
|
var gpuUsage = GetGpuUsage();
|
|
var runningGame = GetCurrentlyRunningGame();
|
|
|
|
var resourceUsage = new
|
|
{
|
|
CurrentTime = currentTime,
|
|
ComputerInfo = computerInfo,
|
|
CPU = cpuUsage,
|
|
RAM = ramUsage,
|
|
GPU = gpuUsage,
|
|
CurrentlyRunningGame = runningGame
|
|
};
|
|
|
|
var json = JsonConvert.SerializeObject(resourceUsage);
|
|
context.Response.ContentType = "application/json";
|
|
await context.Response.WriteAsync(json);
|
|
});
|
|
|
|
app.MapPost("/api/kill-process", async context =>
|
|
{
|
|
try
|
|
{
|
|
var idStr = await new StreamReader(context.Request.Body).ReadToEndAsync();
|
|
int processId = Convert.ToInt32(idStr);
|
|
|
|
Process[] processes = Process.GetProcesses().Where(p => p.Id == processId).ToArray();
|
|
|
|
if (processes.Length > 0)
|
|
{
|
|
foreach (var process in processes)
|
|
{
|
|
try
|
|
{
|
|
process.Kill();
|
|
await context.Response.WriteAsync($"Process with ID {processId} has been killed.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await context.Response.WriteAsync($"Error killing process with ID {processId}: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await context.Response.WriteAsync($"No process found with ID {processId}.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await context.Response.WriteAsync($"An error occurred: {ex.Message}");
|
|
}
|
|
});
|
|
|
|
/* curl -X POST http://localhost:5000/api/force-shutdown -d "5000" */
|
|
/* Invoke-WebRequest -Uri "http://localhost:5000/api/force-shutdown" -Method POST -Body "50000" -ContentType "text/plain" */
|
|
app.MapPost("/api/force-shutdown", async context =>
|
|
{
|
|
try
|
|
{
|
|
var requestBody = await new StreamReader(context.Request.Body).ReadToEndAsync();
|
|
var parameters = JsonConvert.DeserializeObject<dynamic>(requestBody);
|
|
|
|
string? action = parameters?.Action?.ToString()?.ToLower(); // "shutdown" or "restart"
|
|
int delaySeconds = parameters?.DelaySeconds ?? 0;
|
|
|
|
// Validate action input
|
|
if (action != "shutdown" && action != "restart" && action != "cancel")
|
|
{
|
|
await context.Response.WriteAsync("Invalid action. Use 'shutdown', 'restart', or 'cancel'.");
|
|
return;
|
|
}
|
|
|
|
//if action is stop, then cancel the shutdown
|
|
if (action == "cancel")
|
|
{
|
|
var processStartInfoCancel = new ProcessStartInfo
|
|
{
|
|
FileName = "shutdown",
|
|
Arguments = "/a",
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false
|
|
};
|
|
|
|
Process.Start(processStartInfoCancel);
|
|
await context.Response.WriteAsync("Shutdown cancelled.");
|
|
return;
|
|
}
|
|
|
|
// Validate delay input
|
|
if (delaySeconds < 0)
|
|
{
|
|
await context.Response.WriteAsync("Delay must be a non-negative integer.");
|
|
return;
|
|
}
|
|
|
|
// Determine the shutdown command
|
|
string shutdownCommand = action == "shutdown" ? $"/s /f /t {delaySeconds}" : $"/r /f /t {delaySeconds}";
|
|
|
|
var processStartInfo = new ProcessStartInfo
|
|
{
|
|
FileName = "shutdown",
|
|
Arguments = shutdownCommand,
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false
|
|
};
|
|
|
|
Process.Start(processStartInfo);
|
|
|
|
await context.Response.WriteAsync($"{action.ToUpper()} command executed with a delay of {delaySeconds} seconds.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await context.Response.WriteAsync($"An error occurred: {ex.Message}");
|
|
}
|
|
});
|
|
|
|
app.MapGet("/api/stop", async context =>
|
|
{
|
|
await context.Response.WriteAsync("Stopping the service...");
|
|
_lifetime.StopApplication();
|
|
});
|
|
|
|
app.MapGet("/", () => "Resource Monitor Service is running.");
|
|
app.MapGet("/api/current-time", () => Results.Ok(GetCurrentTime()));
|
|
app.MapGet("/api/computer-info", () => Results.Ok(GetComputerInfo()));
|
|
app.MapGet("/api/cpu-usage", () => Results.Ok(GetCpuUsage()));
|
|
app.MapGet("/api/ram-usage", () => Results.Ok(GetRamUsage()));
|
|
app.MapGet("/api/gpu-usage", () => Results.Ok(GetGpuUsage()));
|
|
app.MapGet("/api/running-game", () => Results.Ok(GetCurrentlyRunningGame()));
|
|
app.MapGet("/api/total-physical-memory", () => Results.Ok(GetTotalPhysicalMemory()));
|
|
app.MapGet("/api/total-available-memory", () => Results.Ok(new { TotalAvailableMemory = Environment.WorkingSet }));
|
|
|
|
app.MapGet("/health", () => Results.Ok("Service is healthy."));
|
|
|
|
|
|
_ = app.RunAsync(stoppingToken);
|
|
|
|
await Task.Delay(Timeout.Infinite, stoppingToken);
|
|
}
|
|
|
|
private object GetComputerInfo()
|
|
{
|
|
return new
|
|
{
|
|
MachineName = Environment.MachineName,
|
|
OSVersion = RuntimeInformation.OSDescription,
|
|
OSArchitecture = RuntimeInformation.OSArchitecture.ToString(),
|
|
ProcessorCount = Environment.ProcessorCount
|
|
};
|
|
}
|
|
|
|
private object GetCpuUsage()
|
|
{
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
cpuCounter.NextValue();
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
Thread.Sleep(1000); // Wait a second to get a valid reading
|
|
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
var usage = cpuCounter.NextValue();
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
if (usage > 80)
|
|
{
|
|
// Get the current processes and sort them by CPU usage in descending order
|
|
var processes = Process.GetProcesses()
|
|
.Select(p =>
|
|
{
|
|
try
|
|
{
|
|
return new
|
|
{
|
|
Process = p,
|
|
TotalProcessorTime = p.TotalProcessorTime
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
return null; // Skip processes that throw exceptions
|
|
}
|
|
})
|
|
.Where(p => p != null)
|
|
.OrderByDescending(p => p!.TotalProcessorTime)
|
|
.Select(p => p!.Process)
|
|
.ToList();
|
|
|
|
// Create a new anonymous type containing the CPU usage, RAM usage, and the top 3 highest CPU-using processes
|
|
return new
|
|
{
|
|
Usage = usage,
|
|
Process1 = processes.Count > 0 ? new
|
|
{
|
|
Name = processes[0].ProcessName,
|
|
TotalProcessorTime = processes[0].TotalProcessorTime,
|
|
WorkingSet64 = processes[0].WorkingSet64 / (1024 * 1024) // Convert to MB
|
|
} : null,
|
|
Process2 = processes.Count > 1 ? new
|
|
{
|
|
Name = processes[1].ProcessName,
|
|
TotalProcessorTime = processes[1].TotalProcessorTime,
|
|
WorkingSet64 = processes[1].WorkingSet64 / (1024 * 1024) // Convert to MB
|
|
} : null,
|
|
Process3 = processes.Count > 2 ? new
|
|
{
|
|
Name = processes[2].ProcessName,
|
|
TotalProcessorTime = processes[2].TotalProcessorTime,
|
|
WorkingSet64 = processes[2].WorkingSet64 / (1024 * 1024) // Convert to MB
|
|
} : null
|
|
};
|
|
}
|
|
|
|
return new
|
|
{
|
|
Usage = usage
|
|
};
|
|
}
|
|
|
|
private float GetRamUsage()
|
|
{
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
var ramCounter = new PerformanceCounter("Memory", "Available MBytes");
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
var totalMemory = GetTotalPhysicalMemory();
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
var availableMemory = ramCounter.NextValue() * 1024 * 1024;
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
return (float)(totalMemory - availableMemory) / totalMemory * 100;
|
|
}
|
|
|
|
private ulong GetTotalPhysicalMemory()
|
|
{
|
|
ulong totalMemory = 0;
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
var searcher = new ManagementObjectSearcher("SELECT TotalPhysicalMemory FROM Win32_ComputerSystem");
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
foreach (var obj in searcher.Get())
|
|
{
|
|
#pragma warning disable CA1416 // Validate platform compatibility
|
|
totalMemory = (ulong)obj["TotalPhysicalMemory"];
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
}
|
|
#pragma warning restore CA1416 // Validate platform compatibility
|
|
return totalMemory;
|
|
}
|
|
|
|
private object GetGpuUsage()
|
|
{
|
|
/* if (!IsNvidiaGpuPresent())
|
|
{
|
|
return new
|
|
{
|
|
Usage = 0,
|
|
Temperature = 0,
|
|
FanSpeed = 0,
|
|
IsAvailable = false,
|
|
Message = "No NVIDIA GPU detected"
|
|
};
|
|
} */
|
|
|
|
try
|
|
{
|
|
|
|
NvmlWrapper.NvmlInit();
|
|
IntPtr device;
|
|
NvmlWrapper.NvmlDeviceGetHandleByIndex(0, out device);
|
|
NvmlWrapper.NvmlUtilization utilization;
|
|
NvmlWrapper.NvmlDeviceGetUtilizationRates(device, out utilization);
|
|
|
|
uint temperature;
|
|
NvmlWrapper.NvmlDeviceGetTemperature(device, 0, out temperature);
|
|
|
|
uint fanSpeed;
|
|
NvmlWrapper.NvmlDeviceGetFanSpeed(device, out fanSpeed);
|
|
|
|
NvmlWrapper.NvmlShutdown();
|
|
|
|
return new
|
|
{
|
|
Usage = utilization.Gpu,
|
|
Temperature = temperature,
|
|
FanSpeed = fanSpeed,
|
|
IsAvailable = false,
|
|
Error = ""
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
Usage = 0,
|
|
Temperature = 0,
|
|
FanSpeed = 0,
|
|
IsAvailable = false,
|
|
Error = ex.Message
|
|
};
|
|
}
|
|
}
|
|
|
|
/* private bool IsNvidiaGpuPresent()
|
|
{
|
|
try
|
|
{
|
|
// Method 1: Try to initialize NVML
|
|
NvmlWrapper.NvmlInit();
|
|
uint deviceCount = 0;
|
|
NvmlWrapper.NvmlDeviceGetCount(ref deviceCount);
|
|
NvmlWrapper.NvmlShutdown();
|
|
|
|
return deviceCount > 0;
|
|
}
|
|
catch
|
|
{
|
|
// Method 2: Fallback to checking using WMI
|
|
try
|
|
{
|
|
using (var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_VideoController WHERE Name LIKE '%NVIDIA%'"))
|
|
{
|
|
var collection = searcher.Get();
|
|
return collection.Count > 0;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
} */
|
|
|
|
private object GetCurrentlyRunningGame()
|
|
{
|
|
var processes = Process.GetProcesses();
|
|
|
|
foreach (var process in processes)
|
|
{
|
|
try
|
|
{
|
|
#pragma warning disable CS8602 // Dereference of a possibly null reference.
|
|
var filePath = process.MainModule.FileName;
|
|
#pragma warning restore CS8602 // Dereference of a possibly null reference.
|
|
if (filePath.Contains(@"\steamapps\common\"))
|
|
{
|
|
// Extract the game directory name
|
|
var parts = filePath.Split(new[] { @"\steamapps\common\" }, StringSplitOptions.None);
|
|
if (parts.Length > 1)
|
|
{
|
|
var gamePath = parts[1];
|
|
var gameName = gamePath.Split(Path.DirectorySeparatorChar)[0];
|
|
return new
|
|
{
|
|
GameName = gameName,
|
|
ExecutableName = Path.GetFileName(filePath),
|
|
FullPath = filePath,
|
|
ProcessId = process.Id,
|
|
MemoryUsage = process.WorkingSet64 / (1024 * 1024) + " MB", // Memory usage in MB
|
|
CpuTime = process.TotalProcessorTime.ToString(),
|
|
StartTime = process.StartTime.ToString("G"), // General date/time pattern
|
|
UserName = Environment.UserName // The user running the process
|
|
};
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// Handle access exceptions or continue if not important
|
|
}
|
|
}
|
|
return "No Steam game is currently running.";
|
|
}
|
|
private string GetCurrentTime()
|
|
{
|
|
return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
|
}
|
|
|
|
|
|
}
|
|
}
|