Merge pull request #188 from Moonlight-Panel/ImproveLogging

Improved logging. Added better error handling for mysql database backup

.gitattributes

@@ -1,2 +1,3 @@
 # Auto detect text files and perform LF normalization
 * text=auto
+Moonlight/wwwroot/* linguist-vendored

.gitignore

@@ -42,3 +42,4 @@ Desktop.ini
 
 storage/
 Moonlight/publish.ps1
+Moonlight/version

Moonlight/App/ApiClients/Modrinth/ModrinthApiHelper.cs

@@ -0,0 +1,58 @@
+using Newtonsoft.Json;
+using RestSharp;
+
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthApiHelper
+{
+    private readonly RestClient Client;
+
+    public ModrinthApiHelper()
+    {
+        Client = new();
+        Client.AddDefaultParameter(
+            new HeaderParameter("User-Agent", "Moonlight-Panel/Moonlight (admin@endelon-hosting.de)")
+        );
+    }
+    
+    public async Task<T> Get<T>(string resource)
+    {
+        var request = CreateRequest(resource);
+
+        request.Method = Method.Get;
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new ModrinthException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+
+        return JsonConvert.DeserializeObject<T>(response.Content!)!;
+    }
+    
+    private RestRequest CreateRequest(string resource)
+    {
+        var url = "https://api.modrinth.com/v2/" + resource;
+
+        var request = new RestRequest(url)
+        {
+            Timeout = 60 * 15
+        };
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+
+        return request;
+    }
+}

Moonlight/App/ApiClients/Modrinth/ModrinthException.cs

@@ -0,0 +1,19 @@
+namespace Moonlight.App.ApiClients.Modrinth;
+
+public class ModrinthException : Exception
+{
+    public int StatusCode { get; set; }
+    
+    public ModrinthException()
+    {
+    }
+
+    public ModrinthException(string message, int statusCode) : base(message)
+    {
+        StatusCode = statusCode;
+    }
+
+    public ModrinthException(string message, Exception inner) : base(message, inner)
+    {
+    }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Pagination.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Pagination
+{
+    [JsonProperty("hits")] public Project[] Hits { get; set; }
+
+    [JsonProperty("offset")] public long Offset { get; set; }
+
+    [JsonProperty("limit")] public long Limit { get; set; }
+
+    [JsonProperty("total_hits")] public long TotalHits { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Project.cs

@@ -0,0 +1,48 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Project
+{
+    [JsonProperty("project_id")] public string ProjectId { get; set; }
+
+    [JsonProperty("project_type")] public string ProjectType { get; set; }
+
+    [JsonProperty("slug")] public string Slug { get; set; }
+
+    [JsonProperty("author")] public string Author { get; set; }
+
+    [JsonProperty("title")] public string Title { get; set; }
+
+    [JsonProperty("description")] public string Description { get; set; }
+
+    [JsonProperty("categories")] public string[] Categories { get; set; }
+
+    [JsonProperty("display_categories")] public string[] DisplayCategories { get; set; }
+
+    [JsonProperty("versions")] public string[] Versions { get; set; }
+
+    [JsonProperty("downloads")] public long Downloads { get; set; }
+
+    [JsonProperty("follows")] public long Follows { get; set; }
+
+    [JsonProperty("icon_url")] public string IconUrl { get; set; }
+
+    [JsonProperty("date_created")] public DateTimeOffset DateCreated { get; set; }
+
+    [JsonProperty("date_modified")] public DateTimeOffset DateModified { get; set; }
+
+    [JsonProperty("latest_version")] public string LatestVersion { get; set; }
+
+    [JsonProperty("license")] public string License { get; set; }
+
+    [JsonProperty("client_side")] public string ClientSide { get; set; }
+
+    [JsonProperty("server_side")] public string ServerSide { get; set; }
+
+    [JsonProperty("gallery")] public Uri[] Gallery { get; set; }
+
+    [JsonProperty("featured_gallery")] public Uri FeaturedGallery { get; set; }
+
+    [JsonProperty("color")] public long? Color { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/Version.cs

@@ -0,0 +1,57 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class Version
+{
+    [JsonProperty("name")]
+    public string Name { get; set; }
+
+    [JsonProperty("version_number")]
+    public string VersionNumber { get; set; }
+
+    [JsonProperty("changelog")]
+    public string Changelog { get; set; }
+
+    [JsonProperty("dependencies")]
+    public object[] Dependencies { get; set; }
+
+    [JsonProperty("game_versions")]
+    public object[] GameVersions { get; set; }
+
+    [JsonProperty("version_type")]
+    public string VersionType { get; set; }
+
+    [JsonProperty("loaders")]
+    public object[] Loaders { get; set; }
+
+    [JsonProperty("featured")]
+    public bool Featured { get; set; }
+
+    [JsonProperty("status")]
+    public string Status { get; set; }
+
+    [JsonProperty("requested_status")]
+    public string RequestedStatus { get; set; }
+
+    [JsonProperty("id")]
+    public string Id { get; set; }
+
+    [JsonProperty("project_id")]
+    public string ProjectId { get; set; }
+
+    [JsonProperty("author_id")]
+    public string AuthorId { get; set; }
+
+    [JsonProperty("date_published")]
+    public DateTime DatePublished { get; set; }
+
+    [JsonProperty("downloads")]
+    public long Downloads { get; set; }
+
+    [JsonProperty("changelog_url")]
+    public object ChangelogUrl { get; set; }
+
+    [JsonProperty("files")]
+    public VersionFile[] Files { get; set; }
+}

Moonlight/App/ApiClients/Modrinth/Resources/VersionFile.cs

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.ApiClients.Modrinth.Resources;
+
+public class VersionFile
+{
+    [JsonProperty("url")]
+    public Uri Url { get; set; }
+
+    [JsonProperty("filename")]
+    public string Filename { get; set; }
+
+    [JsonProperty("primary")]
+    public bool Primary { get; set; }
+
+    [JsonProperty("size")]
+    public long Size { get; set; }
+
+    [JsonProperty("file_type")]
+    public string FileType { get; set; }
+}

Moonlight/App/Database/Entities/Image.cs

@@ -20,4 +20,5 @@ public class Image
     public List<DockerImage> DockerImages { get; set; } = new();
     public List<ImageVariable> Variables { get; set; } = new();
     public string TagsJson { get; set; } = "";
+    public string BackgroundImageUrl { get; set; } = "";
 }

Moonlight/App/Database/Entities/Server.cs

@@ -13,6 +13,8 @@ public class Server
     public string OverrideStartup { get; set; } = "";
     public bool Installing { get; set; } = false;
     public bool Suspended { get; set; } = false;
+    public bool IsArchived { get; set; } = false;
+    public ServerBackup? Archive { get; set; } = null;
 
     public List<ServerVariable> Variables { get; set; } = new();
     public List<ServerBackup> Backups { get; set; } = new();

Moonlight/App/Database/Entities/User.cs

@@ -43,6 +43,7 @@ public class User
     // Date stuff
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime LastVisitedAt { get; set; } = DateTime.UtcNow;
     
     // Subscriptions
 

Moonlight/App/Database/Interceptors/SqlLoggingInterceptor.cs

@@ -1,6 +1,6 @@
 using System.Data.Common;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore.Diagnostics;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Database.Interceptors;
 

Moonlight/App/Database/Migrations/20230609202138_AddBackgroundImageUrlImage.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBackgroundImageUrlImage : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "BackgroundImageUrl",
+                table: "Images",
+                type: "longtext",
+                nullable: false)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "BackgroundImageUrl",
+                table: "Images");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230611152138_AddLastVisitedTimestamp.cs

@@ -0,0 +1,30 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLastVisitedTimestamp : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastVisitedAt",
+                table: "Users",
+                type: "datetime(6)",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastVisitedAt",
+                table: "Users");
+        }
+    }
+}

Moonlight/App/Database/Migrations/20230614010621_AddedServerAchive.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedServerAchive : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "ArchiveId",
+                table: "Servers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsArchived",
+                table: "Servers",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers",
+                column: "ArchiveId",
+                principalTable: "ServerBackups",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Servers_ServerBackups_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Servers_ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "ArchiveId",
+                table: "Servers");
+
+            migrationBuilder.DropColumn(
+                name: "IsArchived",
+                table: "Servers");
+        }
+    }
+}

Moonlight/App/Database/Migrations/DataContextModelSnapshot.cs

@@ -132,6 +132,10 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Allocations")
                         .HasColumnType("int");
 
+                    b.Property<string>("BackgroundImageUrl")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("ConfigFiles")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -492,6 +496,9 @@ namespace Moonlight.App.Database.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("int");
 
+                    b.Property<int?>("ArchiveId")
+                        .HasColumnType("int");
+
                     b.Property<int>("Cpu")
                         .HasColumnType("int");
 
@@ -507,6 +514,9 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<bool>("Installing")
                         .HasColumnType("tinyint(1)");
 
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<bool>("IsCleanupException")
                         .HasColumnType("tinyint(1)");
 
@@ -538,6 +548,8 @@ namespace Moonlight.App.Database.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("ArchiveId");
+
                     b.HasIndex("ImageId");
 
                     b.HasIndex("MainAllocationId");
@@ -758,6 +770,9 @@ namespace Moonlight.App.Database.Migrations
                         .IsRequired()
                         .HasColumnType("longtext");
 
+                    b.Property<DateTime>("LastVisitedAt")
+                        .HasColumnType("datetime(6)");
+
                     b.Property<string>("Password")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -928,6 +943,10 @@ namespace Moonlight.App.Database.Migrations
 
             modelBuilder.Entity("Moonlight.App.Database.Entities.Server", b =>
                 {
+                    b.HasOne("Moonlight.App.Database.Entities.ServerBackup", "Archive")
+                        .WithMany()
+                        .HasForeignKey("ArchiveId");
+
                     b.HasOne("Moonlight.App.Database.Entities.Image", "Image")
                         .WithMany()
                         .HasForeignKey("ImageId")
@@ -950,6 +969,8 @@ namespace Moonlight.App.Database.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("Archive");
+
                     b.Navigation("Image");
 
                     b.Navigation("MainAllocation");

Moonlight/App/Diagnostics/HealthChecks/DaemonHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DaemonHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public DaemonHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetCpuMetrics(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All node daemons are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All node daemons are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} node daemons are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/DatabaseHealthCheck.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class DatabaseHealthCheck : IHealthCheck
+{
+    private readonly DataContext DataContext;
+
+    public DatabaseHealthCheck(DataContext dataContext)
+    {
+        DataContext = dataContext;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(
+        HealthCheckContext context,
+        CancellationToken cancellationToken = new CancellationToken())
+    {
+        try
+        {
+            await DataContext.Database.OpenConnectionAsync(cancellationToken);
+            await DataContext.Database.CloseConnectionAsync();
+            
+            return HealthCheckResult.Healthy("Database is online");
+        }
+        catch (Exception e)
+        {
+            return HealthCheckResult.Unhealthy("Database is offline", e);
+        }
+    }
+}

Moonlight/App/Diagnostics/HealthChecks/NodeHealthCheck.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Diagnostics.HealthChecks;
+
+public class NodeHealthCheck : IHealthCheck
+{
+    private readonly Repository<Node> NodeRepository;
+    private readonly NodeService NodeService;
+
+    public NodeHealthCheck(Repository<Node> nodeRepository, NodeService nodeService)
+    {
+        NodeRepository = nodeRepository;
+        NodeService = nodeService;
+    }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
+    {
+        var nodes = NodeRepository.Get().ToArray();
+        
+        var results = new Dictionary<Node, bool>();
+        var healthCheckData = new Dictionary<string, object>();
+        
+        foreach (var node in nodes)
+        {
+            try
+            {
+                await NodeService.GetStatus(node);
+                
+                results.Add(node, true);
+            }
+            catch (Exception e)
+            {
+                results.Add(node, false);
+                healthCheckData.Add(node.Name, e.ToStringDemystified());
+            }
+        }
+
+        var offlineNodes = results
+            .Where(x => !x.Value)
+            .ToArray();
+
+        if (offlineNodes.Length == nodes.Length)
+        {
+            return HealthCheckResult.Unhealthy("All nodes are offline", null, healthCheckData);
+        }
+        
+        if (offlineNodes.Length == 0)
+        {
+            return HealthCheckResult.Healthy("All nodes are online");
+        }
+            
+        return HealthCheckResult.Degraded($"{offlineNodes.Length} nodes are offline", null, healthCheckData);
+    }
+}

Moonlight/App/Events/EventSystem.cs

@@ -1,5 +1,5 @@
 using System.Diagnostics;
-using Logging.Net;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Events;
 
@@ -112,4 +112,22 @@ public class EventSystem
         
         return Task.CompletedTask;
     }
+    
+    public Task<T> WaitForEvent<T>(string id, object handle, Func<T, bool> filter)
+    {
+        var taskCompletionSource = new TaskCompletionSource<T>();
+    
+        Func<T, Task> action = async data =>
+        {
+            if (filter.Invoke(data))
+            {
+                taskCompletionSource.SetResult(data);
+                await Off(id, handle);
+            }
+        };
+
+        On<T>(id, handle, action);
+
+        return taskCompletionSource.Task;
+    }
 }

Moonlight/App/Exceptions/DisplayException.cs

@@ -5,6 +5,8 @@ namespace Moonlight.App.Exceptions;
 [Serializable]
 public class DisplayException : Exception
 {
+    public bool DoNotTranslate { get; set; } = false;
+    
     //
     // For guidelines regarding the creation of new exception types, see
     //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
@@ -19,6 +21,11 @@ public class DisplayException : Exception
     public DisplayException(string message) : base(message)
     {
     }
+    
+    public DisplayException(string message, bool doNotTranslate) : base(message)
+    {
+        DoNotTranslate = doNotTranslate;
+    }
 
     public DisplayException(string message, Exception inner) : base(message, inner)
     {

Moonlight/App/Helpers/AvgHelper.cs

@@ -0,0 +1,39 @@
+using Moonlight.App.Database.Entities;
+
+namespace Moonlight.App.Helpers;
+
+public static class AvgHelper
+{
+    public static StatisticsData[] Calculate(StatisticsData[] data, int splitSize = 40)
+    {
+        if (data.Length <= splitSize)
+            return data;
+
+        var result = new List<StatisticsData>();
+
+        var i = data.Length / (float)splitSize;
+        var pc = (int)Math.Round(i);
+
+        foreach (var part in data.Chunk(pc))
+        {
+            double d = 0;
+            var res = new StatisticsData();
+
+            foreach (var entry in part)
+            {
+                d += entry.Value;
+            }
+
+            res.Chart = part.First().Chart;
+            res.Date = part.First().Date;
+
+            if (d == 0)
+                res.Value = 0;
+
+            res.Value = d / part.Length;
+            result.Add(res);
+        }
+
+        return result.ToArray();
+    }
+}

Moonlight/App/Helpers/CacheLogger.cs

@@ -1,252 +0,0 @@
-using System.Diagnostics;
-using Logging.Net;
-using Logging.Net.Loggers.SB;
-using Moonlight.App.Models.Misc;
-using ILogger = Logging.Net.ILogger;
-
-namespace Moonlight.App.Helpers;
-
-public class CacheLogger : ILogger
-{
-    private SBLogger SbLogger = new();
-    private List<LogEntry> Messages = new();
-
-    public LogEntry[] GetMessages()
-    {
-        lock (Messages)
-        {
-            var result = new LogEntry[Messages.Count];
-            Messages.CopyTo(result);
-            return result;
-        }
-    }
-
-    public void Clear(int messages)
-    {
-        lock (Messages)
-        {
-            Messages.RemoveRange(0, Math.Min(messages, Messages.Count));
-        }
-    }
-
-    public void Info(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "info",
-                Message = s
-            });
-        }
-
-        SbLogger.Info(s);
-    }
-
-    public void Debug(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "debug",
-                Message = s
-            });
-        }
-
-        SbLogger.Debug(s);
-    }
-
-    public void Warn(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "warn",
-                Message = s
-            });
-        }
-
-        SbLogger.Warn(s);
-    }
-
-    public void Error(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "error",
-                Message = s
-            });
-        }
-
-        SbLogger.Error(s);
-    }
-
-    public void Fatal(string? s)
-    {
-        if (s == null)
-            return;
-
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "fatal",
-                Message = s
-            });
-        }
-
-        SbLogger.Fatal(s);
-    }
-
-    public void InfoEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "info",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.InfoEx(ex);
-    }
-
-    public void DebugEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "debug",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.DebugEx(ex);
-    }
-
-    public void WarnEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "warn",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.WarnEx(ex);
-    }
-
-    public void ErrorEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "error",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.ErrorEx(ex);
-    }
-
-    public void FatalEx(Exception ex)
-    {
-        lock (Messages)
-        {
-            Messages.Add(new()
-            {
-                Level = "fatal",
-                Message = ex.ToStringDemystified()
-            });
-        }
-
-        SbLogger.FatalEx(ex);
-    }
-
-    public LoggingConfiguration GetErrorConfiguration()
-    {
-        return SbLogger.GetErrorConfiguration();
-    }
-
-    public void SetErrorConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetErrorConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetFatalConfiguration()
-    {
-        return SbLogger.GetFatalConfiguration();
-    }
-
-    public void SetFatalConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetFatalConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetWarnConfiguration()
-    {
-        return SbLogger.GetWarnConfiguration();
-    }
-
-    public void SetWarnConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetWarnConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetInfoConfiguration()
-    {
-        return SbLogger.GetInfoConfiguration();
-    }
-
-    public void SetInfoConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetInfoConfiguration(configuration);
-    }
-
-    public LoggingConfiguration GetDebugConfiguration()
-    {
-        return SbLogger.GetDebugConfiguration();
-    }
-
-    public void SetDebugConfiguration(LoggingConfiguration configuration)
-    {
-        SbLogger.SetDebugConfiguration(configuration);
-    }
-
-    public ILoggingAddition GetAddition()
-    {
-        return SbLogger.GetAddition();
-    }
-
-    public void SetAddition(ILoggingAddition addition)
-    {
-        SbLogger.SetAddition(addition);
-    }
-
-    public bool LogCallingClass
-    {
-        get => SbLogger.LogCallingClass;
-        set => SbLogger.LogCallingClass = value;
-    }
-}

Moonlight/App/Helpers/DatabaseCheckupService.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database;
 using Moonlight.App.Services;
@@ -82,19 +81,32 @@ public class DatabaseCheckupService
         Logger.Info($"Saving it to: {file}");
         Logger.Info("Starting backup...");
 
-        var sw = new Stopwatch();
+        try
-        sw.Start();
+        {
+            var sw = new Stopwatch();
+            sw.Start();
 
-        await using MySqlConnection conn = new MySqlConnection(connectionString);
+            await using MySqlConnection conn = new MySqlConnection(connectionString);
-        await using MySqlCommand cmd = new MySqlCommand();
+            await using MySqlCommand cmd = new MySqlCommand();
-        using MySqlBackup mb = new MySqlBackup(cmd);
+            using MySqlBackup mb = new MySqlBackup(cmd);
         
-        cmd.Connection = conn;
+            cmd.Connection = conn;
-        await conn.OpenAsync();
+            await conn.OpenAsync();
-        mb.ExportToFile(file);
+            mb.ExportToFile(file);
-        await conn.CloseAsync();
+            await conn.CloseAsync();
 
-        sw.Stop();
+            sw.Stop();
-        Logger.Info($"Done. {sw.Elapsed.TotalSeconds}s");
+            Logger.Info($"Done. {sw.Elapsed.TotalSeconds}s");
+        }
+        catch (Exception e)
+        {
+            Logger.Fatal("-----------------------------------------------");
+            Logger.Fatal("Unable to create backup for moonlight database");
+            Logger.Fatal("Moonlight will start anyways in 30 seconds");
+            Logger.Fatal("-----------------------------------------------");
+            Logger.Fatal(e);
+            
+            Thread.Sleep(TimeSpan.FromSeconds(30));
+        }
     }
 }

Moonlight/App/Helpers/Files/SftpFileAccess.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Renci.SshNet;
-using Renci.SshNet;
 using ConnectionInfo = Renci.SshNet.ConnectionInfo;
 
 namespace Moonlight.App.Helpers.Files;

Moonlight/App/Helpers/Formatter.cs

@@ -17,6 +17,18 @@ public static class Formatter
             return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
         }
     }
+    
+    public static string FormatUptime(TimeSpan t)
+    {
+        if (t.Days > 0)
+        {
+            return $"{t.Days}d  {t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+        else
+        {
+            return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        }
+    }
 
     private static double Round(this double d, int decimals)
     {

Moonlight/App/Helpers/HostSystemHelper.cs

@@ -1,6 +1,5 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using Logging.Net;
 
 namespace Moonlight.App.Helpers;
 

Moonlight/App/Helpers/Logger.cs

@@ -0,0 +1,108 @@
+using System.Diagnostics;
+using System.Reflection;
+using Serilog;
+
+namespace Moonlight.App.Helpers;
+
+public static class Logger
+{
+    #region String method calls
+    public static void Verbose(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Verbose("{Message}", message);
+    }
+    
+    public static void Info(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Information("{Message}", message);
+    }
+    
+    public static void Debug(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Debug("{Message}", message);
+    }
+    
+    public static void Error(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Error("{Message}", message);
+    }
+    
+    public static void Warn(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Warning("{Message}", message);
+    }
+    
+    public static void Fatal(string message, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Fatal("{Message}", message);
+    }
+    #endregion
+    
+    #region Exception method calls
+    public static void Verbose(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Verbose(exception, "");
+    }
+    
+    public static void Info(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Information(exception, "");
+    }
+    
+    public static void Debug(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Debug(exception, "");
+    }
+    
+    public static void Error(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Error(exception, "");
+    }
+    
+    public static void Warn(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Warning(exception, "");
+    }
+    
+    public static void Fatal(Exception exception, string channel = "default")
+    {
+        Log.ForContext("SourceContext", GetNameOfCallingClass())
+            .Fatal(exception, "");
+    }
+    #endregion
+    
+    private static string GetNameOfCallingClass(int skipFrames = 4)
+    {
+        string fullName;
+        Type declaringType;
+            
+        do
+        {
+            MethodBase method = new StackFrame(skipFrames, false).GetMethod();
+            declaringType = method.DeclaringType;
+            if (declaringType == null)
+            {
+                return method.Name;
+            }
+            skipFrames++;
+            if (declaringType.Name.Contains("<"))
+                fullName = declaringType.ReflectedType.Name;
+            else
+                fullName = declaringType.Name;
+        }
+        while (declaringType.Module.Name.Equals("mscorlib.dll", StringComparison.OrdinalIgnoreCase) | fullName.Contains("Logger"));
+
+        return fullName;
+    }
+}

Moonlight/App/Helpers/MustBeTrueAttribute.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using Logging.Net;
 
 namespace Moonlight.App.Helpers;
 

Moonlight/App/Helpers/ParseHelper.cs

@@ -1,6 +1,4 @@
-using Logging.Net;
+namespace Moonlight.App.Helpers;
-
-namespace Moonlight.App.Helpers;
 
 public static class ParseHelper
 {

Moonlight/App/Helpers/Wings/WingsConsole.cs

@@ -1,6 +1,5 @@
 using System.Net.WebSockets;
 using System.Text;
-using Logging.Net;
 using Moonlight.App.Helpers.Wings.Data;
 using Moonlight.App.Helpers.Wings.Enums;
 using Moonlight.App.Helpers.Wings.Events;
@@ -243,6 +242,7 @@ public class WingsConsole : IDisposable
                         break;
                 }
             }
+            catch(JsonReaderException){}
             catch (Exception e)
             {
                 if (!Disconnecting)

Moonlight/App/Http/Controllers/Api/Moonlight/DiscordBotController.cs

@@ -102,7 +102,7 @@ public class DiscordBotController : Controller
             return BadRequest();
     }
 
-    [HttpGet("{id}/servers/{uuid}")]
+    [HttpGet("{id}/servers/{uuid}/details")]
     public async Task<ActionResult<ServerDetails>> GetServerDetails(ulong id, Guid uuid)
     {
         if (!await IsAuth(Request))
@@ -123,6 +123,33 @@ public class DiscordBotController : Controller
 
         return await ServerService.GetDetails(server);
     }
+    
+    [HttpGet("{id}/servers/{uuid}")]
+    public async Task<ActionResult<ServerDetails>> GetServer(ulong id, Guid uuid)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        var user = await GetUserFromDiscordId(id);
+
+        if (user == null)
+            return BadRequest();
+
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Owner)
+            .Include(x => x.Image)
+            .Include(x => x.Node)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        server.Node.Token = "";
+        server.Node.TokenId = "";
+
+        return Ok(server);
+    }
 
     private Task<User?> GetUserFromDiscordId(ulong discordId)
     {

Moonlight/App/Http/Controllers/Api/Moonlight/Notifications/ListenController.cs

@@ -2,145 +2,166 @@
 using System.Text;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Moonlight.App.Database.Entities;
 using Moonlight.App.Database.Entities.Notification;
 using Moonlight.App.Models.Notifications;
 using Moonlight.App.Repositories;
 using Moonlight.App.Services;
 using Moonlight.App.Services.Notifications;
-using Moonlight.App.Services.Sessions;
 using Newtonsoft.Json;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight.Notifications;
 
-public class ListenController : ControllerBase
+[ApiController]
+[Route("api/moonlight/notification/listen")]
+public class ListenController : Controller
 {
-    internal WebSocket ws;
+    private WebSocket WebSocket;
-    private bool active = true;
-    private bool isAuth = false;
     private NotificationClient Client;
-    
+    private CancellationTokenSource CancellationTokenSource = new();
-    private readonly IdentityService IdentityService;
-    private readonly NotificationRepository NotificationRepository;
-    private readonly OneTimeJwtService OneTimeJwtService;
-    private readonly NotificationClientService NotificationClientService;
-    private readonly NotificationServerService NotificationServerService;
 
-    public ListenController(IdentityService identityService, 
+    private User? CurrentUser;
-        NotificationRepository notificationRepository, 
+
-        OneTimeJwtService oneTimeJwtService, 
+    private readonly OneTimeJwtService OneTimeJwtService;
-        NotificationClientService notificationClientService,
+    private readonly NotificationServerService NotificationServerService;
-        NotificationServerService notificationServerService)
+    private readonly Repository<NotificationClient> NotificationClientRepository;
+
+    public ListenController(
+        OneTimeJwtService oneTimeJwtService,
+        NotificationServerService notificationServerService, Repository<NotificationClient> notificationClientRepository)
     {
-        IdentityService = identityService;
-        NotificationRepository = notificationRepository;
         OneTimeJwtService = oneTimeJwtService;
-        NotificationClientService = notificationClientService;
         NotificationServerService = notificationServerService;
+        NotificationClientRepository = notificationClientRepository;
     }
-    
+
     [Route("/api/moonlight/notifications/listen")]
-    public async Task Get()
+    public async Task<ActionResult> Get()
     {
         if (HttpContext.WebSockets.IsWebSocketRequest)
         {
-            using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+            WebSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            ws = webSocket;
+
-            await Echo();
+            await ProcessWebsocket();
+
+            return new EmptyResult();
         }
         else
         {
-            HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
+            return StatusCode(400);
         }
     }
 
-    private async Task Echo()
+    private async Task ProcessWebsocket()
     {
-        while (active)
+        while (!CancellationTokenSource.Token.IsCancellationRequested && WebSocket.State == WebSocketState.Open)
         {
-            byte[] bytes = new byte[1024 * 16]; 
+            try
-            var asg = new ArraySegment<byte>(bytes);
-            var res = await ws.ReceiveAsync(asg, CancellationToken.None);
-
-            var text = Encoding.UTF8.GetString(bytes).Trim('\0');
-
-            var obj = JsonConvert.DeserializeObject<BasicWSModel>(text);
-
-            if (!string.IsNullOrWhiteSpace(obj.Action))
             {
-                await HandleRequest(text, obj.Action);
+                byte[] buffer = new byte[1024 * 16];
+                _ = await WebSocket.ReceiveAsync(buffer, CancellationTokenSource.Token);
+                var text = Encoding.UTF8.GetString(buffer).Trim('\0');
+
+                var basicWsModel = JsonConvert.DeserializeObject<BasicWSModel>(text) ?? new();
+
+                if (!string.IsNullOrWhiteSpace(basicWsModel.Action))
+                {
+                    await HandleRequest(text, basicWsModel.Action);
+                }
+
+                if (WebSocket.State != WebSocketState.Open)
+                {
+                    CancellationTokenSource.Cancel();
+                }
+            }
+            catch (WebSocketException e)
+            {
+                CancellationTokenSource.Cancel();
             }
-            
-            active = ws.State == WebSocketState.Open;
         }
+
+        await NotificationServerService.UnRegisterClient(Client);
     }
 
     private async Task HandleRequest(string text, string action)
     {
-        if (!isAuth && action == "login")
+        if (CurrentUser == null && action != "login")
-            await Login(text);
-        else if (!isAuth)
-            await ws.SendAsync(Encoding.UTF8.GetBytes("{\"error\": \"Unauthorised\"}"), WebSocketMessageType.Text,
-                WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-        else switch (action)
         {
+            await Send("{\"error\": \"Unauthorised\"}");
+        }
+
+        switch (action)
+        {
+            case "login":
+                await Login(text);
+                break;
             case "received":
                 await Received(text);
                 break;
             case "read":
                 await Read(text);
                 break;
-            default:
-                break;
         }
     }
 
+    private async Task Send(string text)
+    {
+        await WebSocket.SendAsync(
+            Encoding.UTF8.GetBytes(text),
+            WebSocketMessageType.Text,
+            WebSocketMessageFlags.EndOfMessage, CancellationTokenSource.Token
+        );
+    }
+
     private async Task Login(string json)
     {
-        var jwt = JsonConvert.DeserializeObject<Login>(json).token;
+        var loginModel = JsonConvert.DeserializeObject<Login>(json) ?? new();
-        
+
-        var dict = await OneTimeJwtService.Validate(jwt);
+        var dict = await OneTimeJwtService.Validate(loginModel.Token);
 
         if (dict == null)
         {
-            string error = "{\"status\":false}";
+            await Send("{\"status\":false}");
-            var bytes = Encoding.UTF8.GetBytes(error);
-            await ws.SendAsync(bytes, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
             return;
         }
 
-        var _clientId = dict["clientId"];
+        if (!int.TryParse(dict["clientId"], out int clientId))
-        var clientId = int.Parse(_clientId);
+        {
+            await Send("{\"status\":false}");
+            return;
+        }
 
-        var client = NotificationRepository.GetClients().Include(x => x.User).First(x => x.Id == clientId);
+        Client = NotificationClientRepository
+            .Get()
+            .Include(x => x.User)
+            .First(x => x.Id == clientId);
 
-        Client = client;
+        CurrentUser = Client.User;
-        await InitWebsocket();
-        
-        string success = "{\"status\":true}";
-        var byt = Encoding.UTF8.GetBytes(success);
-        await ws.SendAsync(byt, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-    }
 
-    private async Task InitWebsocket()
+        await NotificationServerService.RegisterClient(WebSocket, Client);
-    {
-        NotificationClientService.listenController = this;
-        NotificationClientService.WebsocketReady(Client);
 
-        isAuth = true;
+        await Send("{\"status\":true}");
     }
 
     private async Task Received(string json)
     {
-        var id = JsonConvert.DeserializeObject<NotificationById>(json).notification;
+        var id = JsonConvert.DeserializeObject<NotificationById>(json).Notification;
-        
+
         //TODO: Implement ws notification received
     }
 
     private async Task Read(string json)
     {
-        var id = JsonConvert.DeserializeObject<NotificationById>(json).notification;
+        var model = JsonConvert.DeserializeObject<NotificationById>(json) ?? new();
 
-        await NotificationServerService.SendAction(NotificationClientService.User,
+        await NotificationServerService.SendAction(
-            JsonConvert.SerializeObject(new NotificationById() {Action = "hide", notification = id}));
+            CurrentUser!,
+            JsonConvert.SerializeObject(
+                new NotificationById()
+                {
+                    Action = "hide", Notification = model.Notification
+                }
+            )
+        );
     }
 }

Moonlight/App/Http/Controllers/Api/Moonlight/OAuth2Controller.cs

@@ -1,5 +1,5 @@
-using Logging.Net;
+using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc;
+using Moonlight.App.Helpers;
 using Moonlight.App.Services;
 using Moonlight.App.Services.Sessions;
 

Moonlight/App/Http/Controllers/Api/Moonlight/ResourcesController.cs

@@ -1,12 +1,6 @@
-using System.Text;
+using Microsoft.AspNetCore.Mvc;
-using Logging.Net;
-using Microsoft.AspNetCore.Mvc;
 using Moonlight.App.Helpers;
-using Moonlight.App.Models.Misc;
-using Moonlight.App.Services;
 using Moonlight.App.Services.Files;
-using Moonlight.App.Services.LogServices;
-using Moonlight.App.Services.Sessions;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 
@@ -14,13 +8,10 @@ namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 [Route("api/moonlight/resources")]
 public class ResourcesController : Controller
 {
-    private readonly SecurityLogService SecurityLogService;
     private readonly BucketService BucketService;
 
-    public ResourcesController(SecurityLogService securityLogService,
+    public ResourcesController(BucketService bucketService)
-        BucketService bucketService)
     {
-        SecurityLogService = securityLogService;
         BucketService = bucketService;
     }
 
@@ -29,10 +20,7 @@ public class ResourcesController : Controller
     {
         if (name.Contains(".."))
         {
-            await SecurityLogService.Log(SecurityLogType.PathTransversal, x =>
+            Logger.Warn($"Detected an attempted path transversal. Path: {name}", "security");
-            {
-                x.Add<string>(name);
-            });
             
             return NotFound();
         }
@@ -46,16 +34,33 @@ public class ResourcesController : Controller
 
         return NotFound();
     }
+    
+    [HttpGet("background/{name}")]
+    public async Task<ActionResult> GetBackground([FromRoute] string name)
+    {
+        if (name.Contains(".."))
+        {
+            Logger.Warn($"Detected an attempted path transversal. Path: {name}", "security");
+            
+            return NotFound();
+        }
+
+        if (System.IO.File.Exists(PathBuilder.File("storage", "resources", "public", "background", name)))
+        {
+            var fs = new FileStream(PathBuilder.File("storage", "resources", "public", "background", name), FileMode.Open);
+        
+            return File(fs, MimeTypes.GetMimeType(name), name);
+        }
+
+        return NotFound();
+    }
 
     [HttpGet("bucket/{bucket}/{name}")]
     public async Task<ActionResult> GetBucket([FromRoute] string bucket, [FromRoute] string name)
     {
         if (name.Contains(".."))
         {
-            await SecurityLogService.Log(SecurityLogType.PathTransversal, x =>
+            Logger.Warn($"Detected an attempted path transversal. Path: {name}", "security");
-            {
-                x.Add<string>(name);
-            });
             
             return NotFound();
         }

Moonlight/App/Http/Controllers/Api/Remote/DdosController.cs

@@ -1,10 +1,8 @@
-using Logging.Net;
+using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Events;
 using Moonlight.App.Http.Requests.Daemon;
 using Moonlight.App.Repositories;
-using Moonlight.App.Services;
 
 namespace Moonlight.App.Http.Controllers.Api.Remote;
 

Moonlight/App/LogMigrator/LogMigrator.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Moonlight.App.Helpers;
-using ILogger = Microsoft.Extensions.Logging.ILogger;
 
 namespace Moonlight.App.LogMigrator;
 

Moonlight/App/Models/Forms/ServerImageDataModel.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Models.Forms;
+
+public class ServerImageDataModel
+{
+    public string OverrideStartup { get; set; }
+    
+    public int DockerImageIndex { get; set; }
+}

Moonlight/App/Models/Forms/ServerOverviewDataModel.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using Moonlight.App.Database.Entities;
+
+namespace Moonlight.App.Models.Forms;
+
+public class ServerOverviewDataModel
+{
+    [Required(ErrorMessage = "You need to enter a name")]
+    [MaxLength(32, ErrorMessage = "The name cannot be longer that 32 characters")]
+    public string Name { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify a owner")]
+    public User Owner { get; set; }
+}

Moonlight/App/Models/Forms/ServerResourcesDataModel.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Moonlight.App.Models.Forms;
+
+public class ServerResourcesDataModel
+{
+    [Required(ErrorMessage = "You need to specify the cpu cores")]
+    public int Cpu { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify the memory")]
+    public long Memory { get; set; }
+    
+    [Required(ErrorMessage = "You need to specify the disk")]
+    public long Disk { get; set; }
+}

Moonlight/App/Models/Misc/ActiveNotificationClient.cs

@@ -0,0 +1,19 @@
+using System.Net.WebSockets;
+using System.Text;
+using Moonlight.App.Database.Entities.Notification;
+
+namespace Moonlight.App.Models.Misc;
+
+public class ActiveNotificationClient
+{
+    public WebSocket WebSocket { get; set; }
+    public NotificationClient Client { get; set; }
+    
+    public async Task SendAction(string action)
+    {
+        await WebSocket.SendAsync(
+            Encoding.UTF8.GetBytes(action),
+            WebSocketMessageType.Text,
+            WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
+    }
+}

Moonlight/App/Models/Misc/HealthCheck.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Misc;
+
+public class HealthCheck
+{
+    public string Status { get; set; }
+    public TimeSpan TotalDuration { get; set; }
+    public Dictionary<string, HealthCheckEntry> Entries { get; set; } = new();
+    
+    public class HealthCheckEntry
+    {
+        public Dictionary<string, string> Data { get; set; } = new();
+        public string Description { get; set; }
+        public TimeSpan Duration { get; set; }
+        public string Status { get; set; }
+        public List<string> Tags { get; set; } = new();
+    }
+}

Moonlight/App/Models/Misc/MalwareScanResult.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Models.Misc;
+
+public class MalwareScanResult
+{
+    public string Title { get; set; } = "";
+    public string Description { get; set; } = "";
+    public string Author { get; set; } = "";
+}

Moonlight/App/Models/Notifications/Login.cs

@@ -1,6 +1,8 @@
-namespace Moonlight.App.Models.Notifications;
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Notifications;
 
 public class Login : BasicWSModel
 {
-    public string token { get; set; }
+    [JsonProperty("token")] public string Token { get; set; } = "";
 }

Moonlight/App/Models/Notifications/NotificationById.cs

@@ -1,6 +1,9 @@
-namespace Moonlight.App.Models.Notifications;
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Models.Notifications;
 
 public class NotificationById : BasicWSModel
 {
-    public int notification { get; set; }
+    [JsonProperty("notification")]
+    public int Notification { get; set; }
 }

Moonlight/App/OAuth2/Providers/DiscordOAuth2Provider.cs

@@ -1,5 +1,4 @@
 using System.Text;
-using Logging.Net;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;

Moonlight/App/OAuth2/Providers/GoogleOAuth2Provider.cs

@@ -1,5 +1,4 @@
 using System.Text;
-using Logging.Net;
 using Moonlight.App.ApiClients.Google.Requests;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;

Moonlight/App/Services/Addon/ServerAddonPluginService.cs

@@ -0,0 +1,83 @@
+using Moonlight.App.ApiClients.Modrinth;
+using Moonlight.App.ApiClients.Modrinth.Resources;
+using Moonlight.App.Exceptions;
+using FileAccess = Moonlight.App.Helpers.Files.FileAccess;
+using Version = Moonlight.App.ApiClients.Modrinth.Resources.Version;
+
+namespace Moonlight.App.Services.Addon;
+
+public class ServerAddonPluginService
+{
+    private readonly ModrinthApiHelper ModrinthApiHelper;
+    private readonly ServerService ServerService;
+
+    public ServerAddonPluginService(ModrinthApiHelper modrinthApiHelper)
+    {
+        ModrinthApiHelper = modrinthApiHelper;
+    }
+
+    public async Task<Project[]> GetPluginsForVersion(string version, string search = "")
+    {
+        string resource;
+        var filter =
+            "[[\"categories:\'bukkit\'\",\"categories:\'paper\'\",\"categories:\'spigot\'\"],[\"versions:" + version + "\"],[\"project_type:mod\"]]";
+
+        if (string.IsNullOrEmpty(search))
+            resource = "search?limit=21&index=relevance&facets=" + filter;
+        else
+            resource = $"search?query={search}&limit=21&index=relevance&facets=" + filter;
+        
+        var result = await ModrinthApiHelper.Get<Pagination>(resource);
+
+        return result.Hits;
+    }
+
+    public async Task InstallPlugin(FileAccess fileAccess, string version, Project project, Action<string>? onStateUpdated = null)
+    {
+        // Resolve plugin download
+        
+        onStateUpdated?.Invoke($"Resolving {project.Slug}");
+        
+        var filter = "game_versions=[\"" + version + "\"]&loaders=[\"bukkit\", \"paper\", \"spigot\"]";
+        
+        var versions = await ModrinthApiHelper.Get<Version[]>(
+            $"project/{project.Slug}/version?" + filter);
+
+        if (!versions.Any())
+            throw new DisplayException("No plugin download for your minecraft version found");
+
+        var installVersion = versions.OrderByDescending(x => x.DatePublished).First();
+        var fileToInstall = installVersion.Files.First();
+        
+        // Download plugin in a stream cached mode
+
+        var httpClient = new HttpClient();
+        var stream = await httpClient.GetStreamAsync(fileToInstall.Url);
+        var dataStream = new MemoryStream(1024 * 1024 * 40);
+        await stream.CopyToAsync(dataStream);
+        stream.Close();
+        dataStream.Position = 0;
+        
+        // Install plugin
+
+        await fileAccess.SetDir("/");
+        
+        try
+        {
+            await fileAccess.MkDir("plugins");
+        }
+        catch (Exception)
+        {
+            // Ignored
+        }
+
+        await fileAccess.SetDir("plugins");
+        
+        onStateUpdated?.Invoke($"Installing {project.Slug}");
+        await fileAccess.Upload(fileToInstall.Filename, dataStream);
+        
+        await dataStream.DisposeAsync();
+        
+        //TODO: At some point of time, create a dependency resolver
+    }
+}

Moonlight/App/Services/Background/CleanupService.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
 using MineStatLib;
 using Moonlight.App.ApiClients.Daemon.Resources;
 using Moonlight.App.ApiClients.Wings;
@@ -85,7 +84,30 @@ public class CleanupService
                     var cpuMetrics = await nodeService.GetCpuMetrics(node);
                     var memoryMetrics = await nodeService.GetMemoryMetrics(node);
 
-                    if (cpuMetrics.CpuUsage > maxCpu || (Formatter.BytesToGb(memoryMetrics.Total) - (Formatter.BytesToGb(memoryMetrics.Used))) < minMemory)
+                    bool executeCleanup;
+                    
+                    if (cpuMetrics.CpuUsage > maxCpu)
+                    {
+                        Logger.Debug($"{node.Name}: CPU Usage is too high");
+                        Logger.Debug($"Usage:  {cpuMetrics.CpuUsage}");
+                        Logger.Debug($"Max CPU:  {maxCpu}");
+                        executeCleanup = true;
+                    }
+                    else if (Formatter.BytesToGb(memoryMetrics.Total) - Formatter.BytesToGb(memoryMetrics.Used) <
+                             minMemory / 1024D)
+                    {
+                        Logger.Debug($"{node.Name}: Memory Usage is too high");
+                        Logger.Debug($"Memory (Total):  {Formatter.BytesToGb(memoryMetrics.Total)}");
+                        Logger.Debug($"Memory (Used):  {Formatter.BytesToGb(memoryMetrics.Used)}");
+                        Logger.Debug(
+                            $"Memory (Free):  {Formatter.BytesToGb(memoryMetrics.Total) - Formatter.BytesToGb(memoryMetrics.Used)}");
+                        Logger.Debug($"Min Memory:  {minMemory}");
+                        executeCleanup = true;
+                    }
+                    else
+                        executeCleanup = false;
+                    
+                    if (executeCleanup)
                     {
                         var dockerMetrics = await nodeService.GetDockerMetrics(node);
 
@@ -140,6 +162,7 @@ public class CleanupService
 
                                         if (players == 0)
                                         {
+                                            Logger.Debug($"Restarted {server.Name} ({server.Uuid}) on node {node.Name}");
                                             await serverService.SetPowerState(server, PowerSignal.Restart);
                                             
                                             ServersCleaned++;
@@ -165,10 +188,12 @@ public class CleanupService
 
                                             if (handleJ2S)
                                             {
+                                                Logger.Debug($"Restarted (cleanup) {server.Name} ({server.Uuid}) on node {node.Name}");
                                                 await serverService.SetPowerState(server, PowerSignal.Restart);
                                             }
                                             else
                                             {
+                                                Logger.Debug($"Stopped {server.Name} ({server.Uuid}) on node {node.Name}");
                                                 await serverService.SetPowerState(server, PowerSignal.Stop);
                                             }
 

Moonlight/App/Services/Background/DiscordNotificationService.cs

@@ -1,8 +1,8 @@
 using Discord;
 using Discord.Webhook;
-using Logging.Net;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Events;
+using Moonlight.App.Helpers;
 using Moonlight.App.Services.Files;
 
 namespace Moonlight.App.Services.Background;

Moonlight/App/Services/Background/MalwareScanService.cs

@@ -0,0 +1,196 @@
+using Moonlight.App.ApiClients.Daemon.Resources;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Events;
+using Moonlight.App.Exceptions;
+using Moonlight.App.Helpers;
+using Moonlight.App.Models.Misc;
+using Moonlight.App.Repositories;
+
+namespace Moonlight.App.Services.Background;
+
+public class MalwareScanService
+{
+    private Repository<Server> ServerRepository;
+    private Repository<Node> NodeRepository;
+    private NodeService NodeService;
+    private ServerService ServerService;
+    
+    private readonly EventSystem Event;
+    private readonly IServiceScopeFactory ServiceScopeFactory;
+    
+    public bool IsRunning { get; private set; }
+    public readonly Dictionary<Server, MalwareScanResult[]> ScanResults;
+    public string Status { get; private set; } = "N/A";
+
+    public MalwareScanService(IServiceScopeFactory serviceScopeFactory, EventSystem eventSystem)
+    {
+        ServiceScopeFactory = serviceScopeFactory;
+        Event = eventSystem;
+
+        ScanResults = new();
+    }
+
+    public Task Start()
+    {
+        if (IsRunning)
+            throw new DisplayException("Malware scan is already running");
+        
+        Task.Run(Run);
+        
+        return Task.CompletedTask;
+    }
+
+    private async Task Run()
+    {
+        IsRunning = true;
+        Status = "Clearing last results";
+        await Event.Emit("malwareScan.status", IsRunning);
+
+        lock (ScanResults)
+        {
+            ScanResults.Clear();
+        }
+        
+        await Event.Emit("malwareScan.result");
+        
+        using var scope = ServiceScopeFactory.CreateScope();
+        
+        // Load services from di scope
+        NodeRepository = scope.ServiceProvider.GetRequiredService<Repository<Node>>();
+        ServerRepository = scope.ServiceProvider.GetRequiredService<Repository<Server>>();
+        NodeService = scope.ServiceProvider.GetRequiredService<NodeService>();
+        ServerService = scope.ServiceProvider.GetRequiredService<ServerService>();
+
+        var nodes = NodeRepository.Get().ToArray();
+        var containers = new List<Container>();
+
+        // Fetch and summarize all running containers from all nodes
+        Logger.Verbose("Fetching and summarizing all running containers from all nodes");
+        
+        Status = "Fetching and summarizing all running containers from all nodes";
+        await Event.Emit("malwareScan.status", IsRunning);
+        
+        foreach (var node in nodes)
+        {
+            var metrics = await NodeService.GetDockerMetrics(node);
+
+            foreach (var container in metrics.Containers)
+            {
+                containers.Add(container);
+            }
+        }
+
+        var containerServerMapped = new Dictionary<Server, Container>();
+
+        // Map all the containers to their corresponding server if existing
+        Logger.Verbose("Mapping all the containers to their corresponding server if existing");
+        
+        Status = "Mapping all the containers to their corresponding server if existing";
+        await Event.Emit("malwareScan.status", IsRunning);
+        
+        foreach (var container in containers)
+        {
+            if (Guid.TryParse(container.Name, out Guid uuid))
+            {
+                var server = ServerRepository
+                    .Get()
+                    .FirstOrDefault(x => x.Uuid == uuid);
+                
+                if(server == null)
+                    continue;
+                
+                containerServerMapped.Add(server, container);
+            }
+        }
+        
+        // Perform scan
+        var resultsMapped = new Dictionary<Server, MalwareScanResult[]>();
+        foreach (var mapping in containerServerMapped)
+        {
+            Logger.Verbose($"Scanning server {mapping.Key.Name} for malware");
+            
+            Status = $"Scanning server {mapping.Key.Name} for malware";
+            await Event.Emit("malwareScan.status", IsRunning);
+            
+            var results = await PerformScanOnServer(mapping.Key, mapping.Value);
+
+            if (results.Any())
+            {
+                resultsMapped.Add(mapping.Key, results);
+                Logger.Verbose($"{results.Length} findings on server {mapping.Key.Name}");
+            }
+        }
+        
+        Logger.Verbose($"Scan complete. Detected {resultsMapped.Count} servers with findings");
+        
+        IsRunning = false;
+        Status = $"Scan complete. Detected {resultsMapped.Count} servers with findings";
+        await Event.Emit("malwareScan.status", IsRunning);
+
+        lock (ScanResults)
+        {
+            foreach (var mapping in resultsMapped)
+            {
+                ScanResults.Add(mapping.Key, mapping.Value);
+            }
+        }
+        
+        await Event.Emit("malwareScan.result");
+    }
+
+    private async Task<MalwareScanResult[]> PerformScanOnServer(Server server, Container container)
+    {
+        var results = new List<MalwareScanResult>();
+        
+        // TODO: Move scans to an universal format / api
+        
+        // Define scans here
+        
+        async Task ScanSelfBot()
+        {
+            var access = await ServerService.CreateFileAccess(server, null!);
+            var fileElements = await access.Ls();
+
+            if (fileElements.Any(x => x.Name == "tokens.txt"))
+            {
+                results.Add(new ()
+                {
+                    Title = "Found SelfBot",
+                    Description = "Detected suspicious 'tokens.txt' file which may contain tokens for a selfbot",
+                    Author = "Marcel Baumgartner"
+                });
+            }
+        }
+
+        async Task ScanFakePlayerPlugins()
+        {
+            var access = await ServerService.CreateFileAccess(server, null!);
+            var fileElements = await access.Ls();
+
+            if (fileElements.Any(x => !x.IsFile && x.Name == "plugins")) // Check for plugins folder
+            {
+                await access.Cd("plugins");
+                fileElements = await access.Ls();
+
+                foreach (var fileElement in fileElements)
+                {
+                    if (fileElement.Name.ToLower().Contains("fake"))
+                    {
+                        results.Add(new()
+                        {
+                            Title = "Fake player plugin",
+                            Description = $"Suspicious plugin file: {fileElement.Name}",
+                            Author = "Marcel Baumgartner"
+                        });
+                    }
+                }
+            }
+        }
+
+        // Execute scans
+        await ScanSelfBot();
+        await ScanFakePlayerPlugins();
+
+        return results.ToArray();
+    }
+}

Moonlight/App/Services/ConfigService.cs

@@ -1,5 +1,4 @@
 using System.Text;
-using Logging.Net;
 using Microsoft.Extensions.Primitives;
 using Moonlight.App.Helpers;
 using Moonlight.App.Services.Files;
@@ -42,8 +41,6 @@ public class ConfigService : IConfiguration
 
     public void Reload()
     {
-        Logger.Info($"Reading config from '{PathBuilder.File("storage", "configs", "config.json")}'");
-        
         Configuration = new ConfigurationBuilder().AddJsonStream(
             new MemoryStream(Encoding.ASCII.GetBytes(
                     File.ReadAllText(
@@ -51,8 +48,6 @@ public class ConfigService : IConfiguration
                     )
                 )
             )).Build();
-
-        Logger.Info("Reloaded configuration file");
     }
 
     public IEnumerable<IConfigurationSection> GetChildren()

Moonlight/App/Services/DiscordBot/Commands/ClearChannelCommand.cs

@@ -1,6 +1,5 @@
 using Discord;
 using Discord.WebSocket;
-using Logging.Net;
 
 namespace Moonlight.App.Services.DiscordBot.Commands;
 

Moonlight/App/Services/DiscordBot/Commands/ServerListCommand.cs

@@ -1,6 +1,5 @@
 using Discord;
 using Discord.WebSocket;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;

Moonlight/App/Services/DiscordBot/DiscordBotService.cs

@@ -1,8 +1,7 @@
 using System.Diagnostics;
 using Discord;
-using Discord.Commands;
 using Discord.WebSocket;
-using Logging.Net;
+using Moonlight.App.Helpers;
 using Moonlight.App.Services.DiscordBot.Commands;
 using Moonlight.App.Services.DiscordBot.Modules;
 

Moonlight/App/Services/DiscordBot/Modules/RemoveCommandsModule.cs

@@ -1,6 +1,6 @@
 using System.Diagnostics;
 using Discord.WebSocket;
-using Logging.Net;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Services.DiscordBot.Modules;
 

Moonlight/App/Services/DiscordBot/Modules/ServerListComponentHandlerModule.cs

@@ -1,8 +1,8 @@
 using Discord;
 using Discord.WebSocket;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.ApiClients.Wings;
+using Moonlight.App.Helpers;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 

Moonlight/App/Services/DomainService.cs

@@ -5,13 +5,12 @@ using CloudFlare.Client.Api.Result;
 using CloudFlare.Client.Api.Zones;
 using CloudFlare.Client.Api.Zones.DnsRecord;
 using CloudFlare.Client.Enumerators;
-using Logging.Net;
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;
+using Moonlight.App.Helpers;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories.Domains;
-using Moonlight.App.Services.LogServices;
 using DnsRecord = Moonlight.App.Models.Misc.DnsRecord;
 
 namespace Moonlight.App.Services;
@@ -21,18 +20,15 @@ public class DomainService
     private readonly DomainRepository DomainRepository;
     private readonly SharedDomainRepository SharedDomainRepository;
     private readonly CloudFlareClient Client;
-    private readonly AuditLogService AuditLogService;
     private readonly string AccountId;
 
     public DomainService(
         ConfigService configService,
         DomainRepository domainRepository,
-        SharedDomainRepository sharedDomainRepository,
+        SharedDomainRepository sharedDomainRepository)
-        AuditLogService auditLogService)
     {
         DomainRepository = domainRepository;
         SharedDomainRepository = sharedDomainRepository;
-        AuditLogService = auditLogService;
 
         var config = configService
             .GetSection("Moonlight")
@@ -190,12 +186,8 @@ public class DomainService
                 Name = name
             }));
         }
-
+        
-        await AuditLogService.Log(AuditLogType.AddDomainRecord, x =>
+        //TODO: AuditLog
-        {
-            x.Add<Domain>(d.Id);
-            x.Add<DnsRecord>(dnsRecord.Name);
-        });
     }
 
     public async Task UpdateDnsRecord(Domain d, DnsRecord dnsRecord)
@@ -225,11 +217,7 @@ public class DomainService
                 }));
         }
         
-        await AuditLogService.Log(AuditLogType.UpdateDomainRecord, x =>
+        //TODO: AuditLog
-        {
-            x.Add<Domain>(d.Id);
-            x.Add<DnsRecord>(dnsRecord.Name);
-        });
     }
 
     public async Task DeleteDnsRecord(Domain d, DnsRecord dnsRecord)
@@ -240,11 +228,7 @@ public class DomainService
             await Client.Zones.DnsRecords.DeleteAsync(domain.SharedDomain.CloudflareId, dnsRecord.Id)
         );
         
-        await AuditLogService.Log(AuditLogType.DeleteDomainRecord, x =>
+        //TODO: AuditLog
-        {
-            x.Add<Domain>(d.Id);
-            x.Add<DnsRecord>(dnsRecord.Name);
-        });
     }
 
     private Domain EnsureData(Domain domain)

Moonlight/App/Services/Files/ResourceService.cs

@@ -15,6 +15,11 @@ public class ResourceService
     {
         return $"{AppUrl}/api/moonlight/resources/images/{name}";
     }
+    
+    public string BackgroundImage(string name)
+    {
+        return $"{AppUrl}/api/moonlight/resources/background/{name}";
+    }
 
     public string Avatar(User user)
     {

Moonlight/App/Services/Files/StorageService.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Moonlight.App.Helpers;
-using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Services.Files;
 

Moonlight/App/Services/LogServices/AuditLogService.cs

@@ -1,93 +0,0 @@
-using Moonlight.App.Database.Entities.LogsEntries;
-using Moonlight.App.Models.Log;
-using Moonlight.App.Models.Misc;
-using Moonlight.App.Repositories.LogEntries;
-using Moonlight.App.Services.Sessions;
-using Newtonsoft.Json;
-
-namespace Moonlight.App.Services.LogServices;
-
-public class AuditLogService
-{
-    private readonly AuditLogEntryRepository Repository;
-    private readonly IHttpContextAccessor HttpContextAccessor;
-
-    public AuditLogService(
-        AuditLogEntryRepository repository,
-        IHttpContextAccessor httpContextAccessor)
-    {
-        Repository = repository;
-        HttpContextAccessor = httpContextAccessor;
-    }
-
-    public Task Log(AuditLogType type, Action<AuditLogParameters> data)
-    {
-        var ip = GetIp();
-        var al = new AuditLogParameters();
-        data(al);
-        
-        var entry = new AuditLogEntry()
-        {
-            Ip = ip,
-            Type = type,
-            System = false,
-            JsonData = al.Build()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    public Task LogSystem(AuditLogType type, Action<AuditLogParameters> data)
-    {
-        var al = new AuditLogParameters();
-        data(al);
-        
-        var entry = new AuditLogEntry()
-        {
-            Type = type,
-            System = true,
-            JsonData = al.Build()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    private string GetIp()
-    {
-        if (HttpContextAccessor.HttpContext == null)
-            return "N/A";
-
-        if(HttpContextAccessor.HttpContext.Request.Headers.ContainsKey("X-Real-IP"))
-        {
-            return HttpContextAccessor.HttpContext.Request.Headers["X-Real-IP"]!;
-        }
-        
-        return HttpContextAccessor.HttpContext.Connection.RemoteIpAddress!.ToString();
-    }
-    
-    public class AuditLogParameters
-    {
-        private List<LogData> Data = new List<LogData>();
-
-        public void Add<T>(object? data)
-        {
-            if(data == null)
-                return;
-            
-            Data.Add(new LogData()
-            {
-                Type = typeof(T),
-                Value = data.ToString()
-            });
-        }
-
-        internal string Build()
-        {
-            return JsonConvert.SerializeObject(Data);
-        }
-    }
-}

Moonlight/App/Services/LogServices/ErrorLogService.cs

@@ -1,118 +0,0 @@
-using System.Diagnostics;
-using System.Reflection;
-using Moonlight.App.Database.Entities.LogsEntries;
-using Moonlight.App.Models.Log;
-using Moonlight.App.Repositories.LogEntries;
-using Moonlight.App.Services.Sessions;
-using Newtonsoft.Json;
-
-namespace Moonlight.App.Services.LogServices;
-
-public class ErrorLogService
-{
-    private readonly ErrorLogEntryRepository Repository;
-    private readonly IHttpContextAccessor HttpContextAccessor;
-    
-    public ErrorLogService(ErrorLogEntryRepository repository, IHttpContextAccessor httpContextAccessor)
-    {
-        Repository = repository;
-        HttpContextAccessor = httpContextAccessor;
-    }
-    
-    public Task Log(Exception exception, Action<ErrorLogParameters> data)
-    {
-        var ip = GetIp();
-        var al = new ErrorLogParameters();
-        data(al);
-        
-        var entry = new ErrorLogEntry()
-        {
-            Ip = ip,
-            System = false,
-            JsonData = al.Build(),
-            Class = NameOfCallingClass(),
-            Stacktrace = exception.ToStringDemystified()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    public Task LogSystem(Exception exception, Action<ErrorLogParameters> data)
-    {
-        var al = new ErrorLogParameters();
-        data(al);
-        
-        var entry = new ErrorLogEntry()
-        {
-            System = true,
-            JsonData = al.Build(),
-            Class = NameOfCallingClass(),
-            Stacktrace = exception.ToStringDemystified()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    private string NameOfCallingClass(int skipFrames = 4)
-    {
-        string fullName;
-        Type? declaringType;
-            
-        do
-        {
-            MethodBase method = new StackFrame(skipFrames, false).GetMethod()!;
-            declaringType = method.DeclaringType;
-            if (declaringType == null)
-            {
-                return method.Name;
-            }
-            skipFrames++;
-            if (declaringType.Name.Contains("<"))
-                fullName = declaringType.ReflectedType!.Name;
-            else
-                fullName = declaringType.Name;
-        }
-        while (declaringType.Module.Name.Equals("mscorlib.dll", StringComparison.OrdinalIgnoreCase) | fullName.Contains("Log"));
-
-        return fullName;
-    }
-    
-    private string GetIp()
-    {
-        if (HttpContextAccessor.HttpContext == null)
-            return "N/A";
-
-        if(HttpContextAccessor.HttpContext.Request.Headers.ContainsKey("X-Real-IP"))
-        {
-            return HttpContextAccessor.HttpContext.Request.Headers["X-Real-IP"]!;
-        }
-        
-        return HttpContextAccessor.HttpContext.Connection.RemoteIpAddress!.ToString();
-    }
-    
-    public class ErrorLogParameters
-    {
-        private List<LogData> Data = new List<LogData>();
-
-        public void Add<T>(object? data)
-        {
-            if(data == null)
-                return;
-
-            Data.Add(new LogData()
-            {
-                Type = typeof(T),
-                Value = data.ToString()
-            });
-        }
-
-        internal string Build()
-        {
-            return JsonConvert.SerializeObject(Data);
-        }
-    }
-}

Moonlight/App/Services/LogServices/LogService.cs

@@ -1,45 +0,0 @@
-using Logging.Net;
-using Moonlight.App.Helpers;
-using Moonlight.App.Models.Misc;
-
-namespace Moonlight.App.Services.LogServices;
-
-public class LogService
-{
-    public LogService()
-    {
-        Task.Run(ClearLog);
-    }
-
-    private async Task ClearLog()
-    {
-        while (true)
-        {
-            await Task.Delay(TimeSpan.FromMinutes(15));
-
-            if (GetMessages().Length > 500)
-            {
-                if (Logger.UsedLogger is CacheLogger cacheLogger)
-                {
-                    cacheLogger.Clear(250); //TODO: config
-                }
-                else
-                {
-                    Logger.Warn("Log service cannot access cache. Is Logging.Net using CacheLogger?");
-                }
-            }
-        }
-    }
-    
-    public LogEntry[] GetMessages()
-    {
-        if (Logger.UsedLogger is CacheLogger cacheLogger)
-        {
-            return cacheLogger.GetMessages();
-        }
-
-        Logger.Warn("Log service cannot access cache. Is Logging.Net using CacheLogger?");
-        
-        return Array.Empty<LogEntry>();
-    }
-}

Moonlight/App/Services/LogServices/SecurityLogService.cs

@@ -1,92 +0,0 @@
-using Moonlight.App.Database.Entities.LogsEntries;
-using Moonlight.App.Models.Log;
-using Moonlight.App.Models.Misc;
-using Moonlight.App.Repositories.LogEntries;
-using Moonlight.App.Services.Sessions;
-using Newtonsoft.Json;
-
-namespace Moonlight.App.Services.LogServices;
-
-public class SecurityLogService
-{
-    private readonly SecurityLogEntryRepository Repository;
-    private readonly IHttpContextAccessor HttpContextAccessor;
-
-    public SecurityLogService(SecurityLogEntryRepository repository, IHttpContextAccessor httpContextAccessor)
-    {
-        Repository = repository;
-        HttpContextAccessor = httpContextAccessor;
-    }
-
-    public Task Log(SecurityLogType type, Action<SecurityLogParameters> data)
-    {
-        var ip = GetIp();
-        var al = new SecurityLogParameters();
-        data(al);
-        
-        var entry = new SecurityLogEntry()
-        {
-            Ip = ip,
-            Type = type,
-            System = false,
-            JsonData = al.Build()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    public Task LogSystem(SecurityLogType type, Action<SecurityLogParameters> data)
-    {
-        var al = new SecurityLogParameters();
-        data(al);
-        
-        var entry = new SecurityLogEntry()
-        {
-            Type = type,
-            System = true,
-            JsonData = al.Build()
-        };
-
-        Repository.Add(entry);
-        
-        return Task.CompletedTask;
-    }
-    
-    private string GetIp()
-    {
-        if (HttpContextAccessor.HttpContext == null)
-            return "N/A";
-
-        if(HttpContextAccessor.HttpContext.Request.Headers.ContainsKey("X-Real-IP"))
-        {
-            return HttpContextAccessor.HttpContext.Request.Headers["X-Real-IP"]!;
-        }
-        
-        return HttpContextAccessor.HttpContext.Connection.RemoteIpAddress!.ToString();
-    }
-    
-    
-    public class SecurityLogParameters
-    {
-        private List<LogData> Data = new List<LogData>();
-
-        public void Add<T>(object? data)
-        {
-            if(data == null)
-                return;
-
-            Data.Add(new LogData()
-            {
-                Type = typeof(T),
-                Value = data.ToString()
-            });
-        }
-
-        internal string Build()
-        {
-            return JsonConvert.SerializeObject(Data);
-        }
-    }
-}

Moonlight/App/Services/Mail/MailService.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using MimeKit;
-using MimeKit;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;

Moonlight/App/Services/Mail/TrashMailDetectorService.cs

@@ -1,5 +1,5 @@
 using System.Net;
-using Logging.Net;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Services.Mail;
 

Moonlight/App/Services/MoonlightService.cs

@@ -0,0 +1,98 @@
+using Moonlight.App.Helpers;
+using Octokit;
+using Repository = LibGit2Sharp.Repository;
+
+namespace Moonlight.App.Services;
+
+public class MoonlightService
+{
+    private readonly ConfigService ConfigService;
+    public readonly DateTime StartTimestamp;
+    public readonly string AppVersion;
+    public readonly List<string[]> ChangeLog = new();
+
+    public MoonlightService(ConfigService configService)
+    {
+        ConfigService = configService;
+        StartTimestamp = DateTime.UtcNow;
+        
+        if (File.Exists("version") && !ConfigService.DebugMode)
+            AppVersion = File.ReadAllText("version");
+        else if (ConfigService.DebugMode)
+        {
+            string repositoryPath = Path.GetFullPath("..");
+            using var repo = new Repository(repositoryPath);
+            var commit = repo.Head.Tip;
+            AppVersion = commit.Sha;
+        }
+        else
+            AppVersion = "unknown";
+
+        Task.Run(FetchChangeLog);
+    }
+
+    private async Task FetchChangeLog()
+    {
+        if (ConfigService.DebugMode)
+        {
+            ChangeLog.Add(new[]
+            {
+                "Disabled",
+                "Fetching changelog from github is disabled in debug mode"
+            });
+            
+            return;
+        }
+
+        try
+        {
+            var client = new GitHubClient(new ProductHeaderValue("Moonlight"));
+            
+            var pullRequests = await client.PullRequest.GetAllForRepository("Moonlight-Panel", "Moonlight", new PullRequestRequest
+            {
+                State = ItemStateFilter.Closed,
+                SortDirection = SortDirection.Ascending,
+                SortProperty = PullRequestSort.Created
+            });
+
+            var groupedPullRequests = new Dictionary<DateTime, List<string>>();
+
+            foreach (var pullRequest in pullRequests)
+            {
+                if (pullRequest.MergedAt != null)
+                {
+                    var date = pullRequest.MergedAt.Value.Date;
+
+                    if (!groupedPullRequests.ContainsKey(date))
+                    {
+                        groupedPullRequests[date] = new List<string>();
+                    }
+
+                    groupedPullRequests[date].Add(pullRequest.Title);
+                }
+            }
+
+            int i = 1;
+            foreach (var group in groupedPullRequests)
+            {
+                var pullRequestsList = new List<string>();
+                var date = group.Key.ToString("dd.MM.yyyy");
+
+                pullRequestsList.Add($"Patch {i}, {date}");
+        
+                foreach (var pullRequest in group.Value)
+                {
+                    pullRequestsList.Add(pullRequest);
+                }
+
+                ChangeLog.Add(pullRequestsList.ToArray());
+                i++;
+            }
+        }
+        catch (Exception e)
+        {
+            Logger.Warn("Error fetching changelog");
+            Logger.Warn(e);
+        }
+    }
+}

Moonlight/App/Services/NodeService.cs

@@ -72,7 +72,7 @@ public class NodeService
     {
         try
         {
-            await GetSystemMetrics(node);
+            await GetStatus(node);
 
             return true;
         }

Moonlight/App/Services/Notifications/NotificationClientService.cs

@@ -1,43 +0,0 @@
-using System.Net.WebSockets;
-using System.Text;
-using Moonlight.App.Database.Entities;
-using Moonlight.App.Database.Entities.Notification;
-using Moonlight.App.Http.Controllers.Api.Moonlight.Notifications;
-using Moonlight.App.Repositories;
-using Moonlight.App.Services.Sessions;
-
-namespace Moonlight.App.Services.Notifications;
-
-public class NotificationClientService
-{
-    private readonly NotificationRepository NotificationRepository;
-    private readonly NotificationServerService NotificationServerService;
-    internal ListenController listenController;
-    
-    public NotificationClientService(NotificationRepository notificationRepository, NotificationServerService notificationServerService)
-    {
-        NotificationRepository = notificationRepository;
-        NotificationServerService = notificationServerService;
-    }
-
-    public User User => NotificationClient.User;
-    
-    public NotificationClient NotificationClient { get; set; }
-
-    public async Task SendAction(string action)
-    {
-        await listenController.ws.SendAsync(Encoding.UTF8.GetBytes(action), WebSocketMessageType.Text,
-            WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-    }
-
-    public void WebsocketReady(NotificationClient client)
-    {
-        NotificationClient = client;
-        NotificationServerService.AddClient(this);
-    }
-
-    public void WebsocketClosed()
-    {
-        NotificationServerService.RemoveClient(this);
-    }
-}

Moonlight/App/Services/Notifications/NotificationServerService.cs

@@ -1,79 +1,113 @@
-using Microsoft.EntityFrameworkCore;
+using System.Net.WebSockets;
+using System.Text;
+using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Database.Entities.Notification;
+using Moonlight.App.Events;
+using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 
 namespace Moonlight.App.Services.Notifications;
 
 public class NotificationServerService
 {
-    private UserRepository UserRepository;
+    private readonly List<ActiveNotificationClient> ActiveClients = new();
-    private NotificationRepository NotificationRepository;
 
     private readonly IServiceScopeFactory ServiceScopeFactory;
-    private IServiceScope ServiceScope;
+    private readonly EventSystem Event;
-    
+
-    public NotificationServerService(IServiceScopeFactory serviceScopeFactory)
+    public NotificationServerService(IServiceScopeFactory serviceScopeFactory, EventSystem eventSystem)
     {
         ServiceScopeFactory = serviceScopeFactory;
-        Task.Run(Run);
+        Event = eventSystem;
-    }
-    
-    private Task Run()
-    {
-        ServiceScope = ServiceScopeFactory.CreateScope();
-
-        UserRepository = ServiceScope
-            .ServiceProvider
-            .GetRequiredService<UserRepository>();
-
-        NotificationRepository = ServiceScope
-            .ServiceProvider
-            .GetRequiredService<NotificationRepository>();
-        
-        return Task.CompletedTask;
     }
 
-    private List<NotificationClientService> connectedClients = new();
+    public Task<ActiveNotificationClient[]> GetActiveClients()
-
-    public List<NotificationClientService> GetConnectedClients(User user)
     {
-        return connectedClients.Where(x => x.User == user).ToList();
+        lock (ActiveClients)
+        {
+            return Task.FromResult(ActiveClients.ToArray());
+        }
+    }
+
+    public Task<ActiveNotificationClient[]> GetUserClients(User user)
+    {
+        lock (ActiveClients)
+        {
+            return Task.FromResult(
+                ActiveClients
+                    .Where(x => x.Client.User.Id == user.Id)
+                    .ToArray()
+            );
+        }
     }
 
     public async Task SendAction(User user, string action)
     {
-        var clients = NotificationRepository.GetClients().Include(x => x.User).Where(x => x.User == user).ToList();
+        using var scope = ServiceScopeFactory.CreateScope();
+        var notificationClientRepository =
+            scope.ServiceProvider.GetRequiredService<Repository<NotificationClient>>();
+        
+        var clients = notificationClientRepository
+            .Get()
+            .Include(x => x.User)
+            .Where(x => x.User == user)
+            .ToList();
 
         foreach (var client in clients)
         {
-            var notificationAction = new NotificationAction()
+            ActiveNotificationClient[] connectedUserClients;
-            {
-                Action = action,
-                NotificationClient = client
-            };
-            
-            var connected = connectedClients.Where(x => x.NotificationClient.Id == client.Id).ToList();
 
-            if (connected.Count > 0)
+            lock (ActiveClients)
             {
-                var clientService = connected[0];
+                connectedUserClients = ActiveClients
-                await clientService.SendAction(action);
+                    .Where(x => x.Client.Id == user.Id)
+                    .ToArray();
+            }
+            
+            if (connectedUserClients.Length > 0)
+            {
+                await connectedUserClients[0].SendAction(action);
             }
             else
             {
-                NotificationRepository.AddAction(notificationAction);
+                var notificationAction = new NotificationAction()
+                {
+                    Action = action,
+                    NotificationClient = client
+                };
+                
+                var notificationActionsRepository =
+                    scope.ServiceProvider.GetRequiredService<Repository<NotificationAction>>();
+
+                notificationActionsRepository.Add(notificationAction);
             }
         }
     }
 
-    public void AddClient(NotificationClientService notificationClientService)
+    public async Task RegisterClient(WebSocket webSocket, NotificationClient notificationClient)
     {
-        connectedClients.Add(notificationClientService);
+        var newClient = new ActiveNotificationClient()
+        {
+            WebSocket = webSocket,
+            Client = notificationClient
+        };
+        
+        lock (ActiveClients)
+        {
+            ActiveClients.Add(newClient);
+        }
+
+        await Event.Emit("notifications.addClient", notificationClient);
     }
 
-    public void RemoveClient(NotificationClientService notificationClientService)
+    public async Task UnRegisterClient(NotificationClient client)
     {
-        connectedClients.Remove(notificationClientService);
+        lock (ActiveClients)
+        {
+            ActiveClients.RemoveAll(x => x.Client == client);
+        }
+        
+        await Event.Emit("notifications.removeClient", client);
     }
 }

Moonlight/App/Services/OneTimeJwtService.cs

@@ -4,9 +4,7 @@ using JWT.Builder;
 using JWT.Exceptions;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;
-using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
-using Moonlight.App.Services.LogServices;
 
 namespace Moonlight.App.Services;
 
@@ -14,15 +12,12 @@ public class OneTimeJwtService
 {
     private readonly ConfigService ConfigService;
     private readonly RevokeRepository RevokeRepository;
-    private readonly SecurityLogService SecurityLogService;
 
     public OneTimeJwtService(ConfigService configService,
-        RevokeRepository revokeRepository,
+        RevokeRepository revokeRepository)
-        SecurityLogService securityLogService)
     {
         ConfigService = configService;
         RevokeRepository = revokeRepository;
-        SecurityLogService = securityLogService;
     }
 
     public string Generate(Action<Dictionary<string, string>> options, TimeSpan? validTime = null)
@@ -76,10 +71,7 @@ public class OneTimeJwtService
         }
         catch (SignatureVerificationException)
         {
-            await SecurityLogService.LogSystem(SecurityLogType.ManipulatedJwt, x =>
+            Logger.Warn($"Detected a manipulated JWT: {token}", "security");
-            {
-                x.Add<string>(token);
-            });
             return null;
         }
         catch (Exception e)

Moonlight/App/Services/ServerService.cs

@@ -12,13 +12,13 @@ using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
-using Moonlight.App.Services.LogServices;
 using FileAccess = Moonlight.App.Helpers.Files.FileAccess;
 
 namespace Moonlight.App.Services;
 
 public class ServerService
 {
+    private readonly Repository<ServerVariable> ServerVariablesRepository;
     private readonly ServerRepository ServerRepository;
     private readonly UserRepository UserRepository;
     private readonly ImageRepository ImageRepository;
@@ -28,9 +28,6 @@ public class ServerService
     private readonly UserService UserService;
     private readonly ConfigService ConfigService;
     private readonly WingsJwtHelper WingsJwtHelper;
-    private readonly SecurityLogService SecurityLogService;
-    private readonly AuditLogService AuditLogService;
-    private readonly ErrorLogService ErrorLogService;
     private readonly NodeService NodeService;
     private readonly DateTimeService DateTimeService;
     private readonly EventSystem Event;
@@ -44,13 +41,11 @@ public class ServerService
         UserService userService,
         ConfigService configService,
         WingsJwtHelper wingsJwtHelper,
-        SecurityLogService securityLogService,
-        AuditLogService auditLogService,
-        ErrorLogService errorLogService,
         NodeService nodeService,
         NodeAllocationRepository nodeAllocationRepository,
         DateTimeService dateTimeService,
-        EventSystem eventSystem)
+        EventSystem eventSystem,
+        Repository<ServerVariable> serverVariablesRepository)
     {
         ServerRepository = serverRepository;
         WingsApiHelper = wingsApiHelper;
@@ -60,13 +55,11 @@ public class ServerService
         UserService = userService;
         ConfigService = configService;
         WingsJwtHelper = wingsJwtHelper;
-        SecurityLogService = securityLogService;
-        AuditLogService = auditLogService;
-        ErrorLogService = errorLogService;
         NodeService = nodeService;
         NodeAllocationRepository = nodeAllocationRepository;
         DateTimeService = dateTimeService;
         Event = eventSystem;
+        ServerVariablesRepository = serverVariablesRepository;
     }
 
     private Server EnsureNodeData(Server s)
@@ -103,11 +96,7 @@ public class ServerService
             Action = rawSignal
         });
 
-        await AuditLogService.Log(AuditLogType.ChangePowerState, x =>
+        //TODO: AuditLog
-        {
-            x.Add<Server>(server.Uuid);
-            x.Add<PowerSignal>(rawSignal);
-        });
     }
 
     public async Task<ServerBackup> CreateBackup(Server server)
@@ -136,12 +125,7 @@ public class ServerService
             Ignore = ""
         });
 
-        await AuditLogService.Log(AuditLogType.CreateBackup,
+        //TODO: AuditLog
-            x =>
-            {
-                x.Add<Server>(server.Uuid);
-                x.Add<ServerBackup>(backup.Uuid);
-            });
 
         return backup;
     }
@@ -178,12 +162,7 @@ public class ServerService
                 Adapter = "wings"
             });
 
-        await AuditLogService.Log(AuditLogType.RestoreBackup,
+        //TODO: AuditLog
-            x =>
-            {
-                x.Add<Server>(server.Uuid);
-                x.Add<ServerBackup>(serverBackup.Uuid);
-            });
     }
 
     public async Task DeleteBackup(Server server, ServerBackup serverBackup)
@@ -216,13 +195,7 @@ public class ServerService
 
         await Event.Emit("wings.backups.delete", backup);
 
-        await AuditLogService.Log(AuditLogType.DeleteBackup,
+        //TODO: AuditLog
-            x =>
-            {
-                x.Add<Server>(server.Uuid);
-                x.Add<ServerBackup>(backup.Uuid);
-            }
-        );
     }
 
     public async Task<string> DownloadBackup(Server s, ServerBackup serverBackup)
@@ -235,12 +208,7 @@ public class ServerService
             claims.Add("backup_uuid", serverBackup.Uuid.ToString());
         });
 
-        await AuditLogService.Log(AuditLogType.DownloadBackup,
+        //TODO: AuditLog
-            x =>
-            {
-                x.Add<Server>(server.Uuid);
-                x.Add<ServerBackup>(serverBackup.Uuid);
-            });
 
         if (server.Node.Ssl)
             return $"https://{server.Node.Fqdn}:{server.Node.HttpPort}/download/backup?token={token}";
@@ -342,17 +310,14 @@ public class ServerService
                 StartOnCompletion = false
             });
 
-            await AuditLogService.Log(AuditLogType.CreateServer, x => { x.Add<Server>(newServerData.Uuid); });
+            //TODO: AuditLog
-
+            
             return newServerData;
         }
         catch (Exception e)
         {
-            await ErrorLogService.Log(e, x =>
+            Logger.Error("Error creating server on wings");
-            {
+            Logger.Error(e);
-                x.Add<Server>(newServerData.Uuid);
-                x.Add<Node>(node.Id);
-            });
 
             ServerRepository.Delete(newServerData); //TODO Remove unsinged table stuff
 
@@ -366,7 +331,10 @@ public class ServerService
 
         await WingsApiHelper.Post(server.Node, $"api/servers/{server.Uuid}/reinstall", null);
 
-        await AuditLogService.Log(AuditLogType.ReinstallServer, x => { x.Add<Server>(server.Uuid); });
+        server.Installing = true;
+        ServerRepository.Update(server);
+        
+        //TODO: AuditLog
     }
 
     public async Task<Server> SftpServerLogin(int serverId, int id, string password)
@@ -375,7 +343,7 @@ public class ServerService
 
         if (server == null)
         {
-            await SecurityLogService.LogSystem(SecurityLogType.SftpBruteForce, x => { x.Add<int>(id); });
+            Logger.Warn($"Detected an sftp bruteforce attempt. ID: {id} Password: {password}", "security");
             throw new Exception("Server not found");
         }
 
@@ -401,17 +369,15 @@ public class ServerService
 
     public async Task Delete(Server s)
     {
-        throw new DisplayException("Deleting a server is currently a bit buggy. So its disabled for your safety");
+        throw new DisplayException("Deleting servers is currently disabled");
         
-        var server = EnsureNodeData(s);
+        var backups = await GetBackups(s);
-
-        var backups = await GetBackups(server);
 
         foreach (var backup in backups)
         {
             try
             {
-                await DeleteBackup(server, backup);
+                await DeleteBackup(s, backup);
             }
             catch (Exception)
             {
@@ -419,17 +385,25 @@ public class ServerService
             }
         }
 
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Variables)
+            .Include(x => x.Node)
+            .First(x => x.Id == s.Id);
+
         await WingsApiHelper.Delete(server.Node, $"api/servers/{server.Uuid}", null);
 
-        //TODO: Fix empty data models
+        foreach (var variable in server.Variables.ToArray())
-        
+        {
+            ServerVariablesRepository.Delete(variable);
+        }
+
         server.Allocations = new();
         server.MainAllocation = null;
         server.Variables = new();
         server.Backups = new();
 
         ServerRepository.Update(server);
-
         ServerRepository.Delete(server);
     }
 
@@ -439,4 +413,65 @@ public class ServerService
 
         return await NodeService.IsHostUp(server.Node);
     }
+
+    public async Task ArchiveServer(Server server)
+    {
+        if (server.IsArchived)
+            throw new DisplayException("Unable to archive an already archived server");
+        
+        // Archive server
+        
+        var backup = await CreateBackup(server);
+        server.IsArchived = true;
+        server.Archive = backup;
+        
+        ServerRepository.Update(server);
+
+        await Event.WaitForEvent<ServerBackup>("wings.backups.create", this, x => backup.Id == x.Id);
+
+        // Reset server
+        
+        var access = await CreateFileAccess(server, null!);
+        var files = await access.Ls();
+        foreach (var file in files)
+        {
+            try
+            {
+                await access.Delete(file);
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+        }
+        
+        await Event.Emit($"server.{server.Uuid}.archiveStatusChanged", server);
+    }
+
+    public async Task UnArchiveServer(Server s)
+    {
+        if (!s.IsArchived)
+            throw new DisplayException("Unable to unarchive a server which is not archived");
+
+        var server = ServerRepository
+            .Get()
+            .Include(x => x.Archive)
+            .First(x => x.Id == s.Id);
+
+        if (server.Archive == null)
+            throw new DisplayException("Archive from server not found");
+
+        if (!server.Archive.Created)
+            throw new DisplayException("Creating the server archive is in progress");
+
+        await RestoreBackup(server, server.Archive);
+
+        await Event.WaitForEvent<ServerBackup>("wings.backups.restore", this, 
+            x => x.Id == server.Archive.Id);
+
+        server.IsArchived = false;
+        ServerRepository.Update(server);
+
+        await Event.Emit($"server.{server.Uuid}.archiveStatusChanged", server);
+    }
 }

Moonlight/App/Services/Sessions/DynamicBackgroundService.cs

@@ -0,0 +1,38 @@
+using Moonlight.App.Services.Files;
+
+namespace Moonlight.App.Services.Sessions;
+
+public class DynamicBackgroundService
+{
+    public EventHandler OnBackgroundImageChanged { get; set; }
+    public string BackgroundImageUrl { get; private set; }
+    private string DefaultBackgroundImageUrl;
+
+    public DynamicBackgroundService(ResourceService resourceService)
+    {
+        DefaultBackgroundImageUrl = resourceService.BackgroundImage("main.jpg");
+        BackgroundImageUrl = DefaultBackgroundImageUrl;
+    }
+
+    public Task Change(string url)
+    {
+        if(BackgroundImageUrl == url) // Prevent unnecessary updates
+            return Task.CompletedTask;
+        
+        BackgroundImageUrl = url;
+        OnBackgroundImageChanged?.Invoke(this, null!);
+
+        return Task.CompletedTask;
+    }
+
+    public Task Reset()
+    {
+        if(BackgroundImageUrl == DefaultBackgroundImageUrl) // Prevent unnecessary updates
+            return Task.CompletedTask;
+        
+        BackgroundImageUrl = DefaultBackgroundImageUrl;
+        OnBackgroundImageChanged?.Invoke(this, null!);
+
+        return Task.CompletedTask;
+    }
+}

Moonlight/App/Services/Sessions/IdentityService.cs

@@ -2,12 +2,10 @@
 using JWT.Algorithms;
 using JWT.Builder;
 using JWT.Exceptions;
-using Logging.Net;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Helpers;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
-using Moonlight.App.Services.LogServices;
 using UAParser;
 
 namespace Moonlight.App.Services.Sessions;
@@ -16,8 +14,6 @@ public class IdentityService
 {
     private readonly UserRepository UserRepository;
     private readonly CookieService CookieService;
-    private readonly SecurityLogService SecurityLogService;
-    private readonly ErrorLogService ErrorLogService;
     private readonly IHttpContextAccessor HttpContextAccessor;
     private readonly string Secret;
     
@@ -27,15 +23,11 @@ public class IdentityService
         CookieService cookieService,
         UserRepository userRepository,
         IHttpContextAccessor httpContextAccessor,
-        ConfigService configService,
+        ConfigService configService)
-        SecurityLogService securityLogService,
-        ErrorLogService errorLogService)
     {
         CookieService = cookieService;
         UserRepository = userRepository;
         HttpContextAccessor = httpContextAccessor;
-        SecurityLogService = securityLogService;
-        ErrorLogService = errorLogService;
 
         Secret = configService
             .GetSection("Moonlight")
@@ -90,15 +82,13 @@ public class IdentityService
             }
             catch (SignatureVerificationException)
             {
-                await SecurityLogService.Log(SecurityLogType.ManipulatedJwt, x =>
+                Logger.Warn($"Detected a manipulated JWT: {token}", "security");
-                {
-                    x.Add<string>(token);
-                });
                 return null;
             }
             catch (Exception e)
             {
-                await ErrorLogService.Log(e, x => {});
+                Logger.Error("Error reading jwt");
+                Logger.Error(e);
                 return null;
             }
 
@@ -134,7 +124,8 @@ public class IdentityService
         }
         catch (Exception e)
         {
-            await ErrorLogService.Log(e, x => {});
+            Logger.Error("Unexpected error while processing token");
+            Logger.Error(e);
             return null;
         }
     }
@@ -159,8 +150,17 @@ public class IdentityService
 
         try
         {
+            var userAgent = HttpContextAccessor.HttpContext.Request.Headers.UserAgent.ToString();
+
+            if (userAgent.Contains("Moonlight.App"))
+            {
+                var version = userAgent.Remove(0, "Moonlight.App/".Length).Split(' ').FirstOrDefault();
+
+                return "Moonlight App " + version;
+            }
+            
             var uaParser = Parser.GetDefault();
-            var info = uaParser.Parse(HttpContextAccessor.HttpContext.Request.Headers.UserAgent);
+            var info = uaParser.Parse(userAgent);
 
             return $"{info.OS} - {info.Device}";
         }

Moonlight/App/Services/Sessions/KeyListenerService.cs

@@ -0,0 +1,38 @@
+using Microsoft.JSInterop;
+
+namespace Moonlight.App.Services.Sessions;
+
+public class KeyListenerService
+{
+    private readonly IJSRuntime _jsRuntime;
+    private DotNetObjectReference<KeyListenerService> _objRef;
+
+    public event EventHandler<string> KeyPressed;
+
+    public KeyListenerService(IJSRuntime jsRuntime)
+    {
+        _jsRuntime = jsRuntime;
+    }
+
+    public async Task Initialize()
+    {
+        _objRef = DotNetObjectReference.Create(this);
+        await _jsRuntime.InvokeVoidAsync("moonlight.keyListener.register", _objRef);
+    }
+
+    [JSInvokable]
+    public void OnKeyPress(string key)
+    {
+        KeyPressed?.Invoke(this, key);
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        try
+        {
+            await _jsRuntime.InvokeVoidAsync("moonlight.keyListener.unregister", _objRef);
+            _objRef.Dispose();
+        }
+        catch (Exception) { /* ignored */}
+    }
+}

Moonlight/App/Services/Sessions/SessionService.cs

@@ -9,6 +9,7 @@ namespace Moonlight.App.Services.Sessions;
 public class SessionService
 {
     private readonly SessionRepository SessionRepository;
+    private Repository<User> UserRepository;
     private readonly IdentityService IdentityService;
     private readonly NavigationManager NavigationManager;
     private readonly AlertService AlertService;
@@ -21,13 +22,15 @@ public class SessionService
         IdentityService identityService, 
         NavigationManager navigationManager,
         AlertService alertService,
-        DateTimeService dateTimeService)
+        DateTimeService dateTimeService,
+        Repository<User> userRepository)
     {
         SessionRepository = sessionRepository;
         IdentityService = identityService;
         NavigationManager = navigationManager;
         AlertService = alertService;
         DateTimeService = dateTimeService;
+        UserRepository = userRepository;
     }
 
     public async Task Register()
@@ -46,6 +49,12 @@ public class SessionService
         };
         
         SessionRepository.Add(OwnSession);
+
+        if (user != null) // Track last session init of user as last visited timestamp
+        {
+            user.LastVisitedAt = DateTimeService.GetCurrent();
+            UserRepository.Update(user);
+        }
     }
 
     public void Refresh()

Moonlight/App/Services/SmartTranslateService.cs

@@ -78,7 +78,7 @@ public class SmartTranslateService
         }
         catch (Exception ex)
         {
-            Logging.Net.Logger.Error(ex);
+            Logger.Error(ex);
             return key;
         }
     }

Moonlight/App/Services/Statistics/StatisticsCaptureService.cs

@@ -1,6 +1,5 @@
-using Logging.Net;
+using Moonlight.App.Database.Entities;
-using Moonlight.App.Database;
+using Moonlight.App.Helpers;
-using Moonlight.App.Database.Entities;
 using Moonlight.App.Repositories;
 using Moonlight.App.Services.Sessions;
 
@@ -66,8 +65,6 @@ public class StatisticsCaptureService
                 AddEntry("databasesCount", databasesRepo.Get().Count());
                 AddEntry("sessionsCount", sessionService.GetAll().Length);
             }
-            
-            Logger.Log("Statistics are weird");
         }
         catch (Exception e)
         {

Moonlight/App/Services/Statistics/StatisticsViewService.cs

@@ -7,20 +7,33 @@ namespace Moonlight.App.Services.Statistics;
 public class StatisticsViewService
 {
     private readonly StatisticsRepository StatisticsRepository;
+    private readonly Repository<User> UserRepository;
     private readonly DateTimeService DateTimeService;
     
-    public StatisticsViewService(StatisticsRepository statisticsRepository, DateTimeService dateTimeService)
+    public StatisticsViewService(StatisticsRepository statisticsRepository, DateTimeService dateTimeService, Repository<User> userRepository)
     {
         StatisticsRepository = statisticsRepository;
         DateTimeService = dateTimeService;
+        UserRepository = userRepository;
     }
 
     public StatisticsData[] GetData(string chart, StatisticsTimeSpan timeSpan)
     {
         var startDate = DateTimeService.GetCurrent() - TimeSpan.FromHours((int)timeSpan);
 
-        var objs = StatisticsRepository.Get().Where(x => x.Date > startDate && x.Chart == chart);
+        var objs = StatisticsRepository
+            .Get()
+            .Where(x => x.Date > startDate && x.Chart == chart);
 
         return objs.ToArray();
     }
+
+    public int GetActiveUsers(StatisticsTimeSpan timeSpan)
+    {
+        var startDate = DateTimeService.GetCurrent() - TimeSpan.FromHours((int)timeSpan);
+
+        return UserRepository
+            .Get()
+            .Count(x => x.LastVisitedAt > startDate);
+    }
 }

Moonlight/App/Services/SupportChat/SupportChatClientService.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
+using Microsoft.AspNetCore.Components.Forms;
-using Microsoft.AspNetCore.Components.Forms;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Events;
 using Moonlight.App.Services.Files;

Moonlight/App/Services/TotpService.cs

@@ -1,7 +1,4 @@
-using Moonlight.App.Database.Entities;
+using Moonlight.App.Repositories;
-using Moonlight.App.Models.Misc;
-using Moonlight.App.Repositories;
-using Moonlight.App.Services.LogServices;
 using Moonlight.App.Services.Sessions;
 using OtpNet;
 
@@ -11,16 +8,13 @@ public class TotpService
 {
     private readonly IdentityService IdentityService;
     private readonly UserRepository UserRepository;
-    private readonly AuditLogService AuditLogService;
 
     public TotpService(
         IdentityService identityService, 
-        UserRepository userRepository, 
+        UserRepository userRepository)
-        AuditLogService auditLogService)
     {
         IdentityService = identityService;
         UserRepository = userRepository;
-        AuditLogService = auditLogService;
     }
 
     public Task<bool> Verify(string secret, string code)
@@ -52,10 +46,7 @@ public class TotpService
         
         UserRepository.Update(user);
 
-        await AuditLogService.Log(AuditLogType.EnableTotp, x =>
+        //TODO: AuditLog
-        {
-            x.Add<User>(user.Email);
-        });
     }
 
     public async Task EnforceTotpLogin()
@@ -74,10 +65,7 @@ public class TotpService
 
         UserRepository.Update(user);
         
-        await AuditLogService.Log(AuditLogType.DisableTotp,x =>
+        //TODO: AuditLog
-        {
-            x.Add<User>(user.Email);
-        });
     }
 
     private string GenerateSecret()

Moonlight/App/Services/UserService.cs

@@ -5,7 +5,6 @@ using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;
 using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
-using Moonlight.App.Services.LogServices;
 using Moonlight.App.Services.Mail;
 using Moonlight.App.Services.Sessions;
 
@@ -15,8 +14,6 @@ public class UserService
 {
     private readonly UserRepository UserRepository;
     private readonly TotpService TotpService;
-    private readonly SecurityLogService SecurityLogService;
-    private readonly AuditLogService AuditLogService;
     private readonly MailService MailService;
     private readonly IdentityService IdentityService;
     private readonly IpLocateService IpLocateService;
@@ -27,9 +24,7 @@ public class UserService
     public UserService(
         UserRepository userRepository,
         TotpService totpService,
-        ConfigService configService, 
+        ConfigService configService,
-        SecurityLogService securityLogService,
-        AuditLogService auditLogService,
         MailService mailService,
         IdentityService identityService,
         IpLocateService ipLocateService,
@@ -37,8 +32,6 @@ public class UserService
     {
         UserRepository = userRepository;
         TotpService = totpService;
-        SecurityLogService = securityLogService;
-        AuditLogService = auditLogService;
         MailService = mailService;
         IdentityService = identityService;
         IpLocateService = ipLocateService;
@@ -85,10 +78,7 @@ public class UserService
 
         await MailService.SendMail(user!, "register", values => {});
         
-        await AuditLogService.Log(AuditLogType.Register, x =>
+        //TODO: AuditLog
-        {
-            x.Add<User>(user.Email);
-        });
 
         return await GenerateToken(user);
     }
@@ -102,11 +92,7 @@ public class UserService
 
         if (user == null)
         {
-            await SecurityLogService.Log(SecurityLogType.LoginFail, x =>
+            Logger.Warn($"Failed login attempt. Email: {email} Password: {password}", "security");
-            {
-                x.Add<User>(email);
-                x.Add<string>(password);
-            });
             throw new DisplayException("Email and password combination not found");
         }
 
@@ -115,11 +101,7 @@ public class UserService
             return user.TotpEnabled;
         }
 
-        await SecurityLogService.Log(SecurityLogType.LoginFail, x =>
+        Logger.Warn($"Failed login attempt. Email: {email} Password: {password}", "security");
-        {
-            x.Add<User>(email);
-            x.Add<string>(password);
-        });
         throw new DisplayException("Email and password combination not found");;
     }
 
@@ -144,28 +126,18 @@ public class UserService
 
             if (totpCodeValid)
             {
-                await AuditLogService.Log(AuditLogType.Login, x =>
+                //TODO: AuditLog
-                {
-                    x.Add<User>(email);
-                });
                 return await GenerateToken(user, true);
             }
             else
             {
-                await SecurityLogService.Log(SecurityLogType.LoginFail, x =>
+                Logger.Warn($"Failed login attempt. Email: {email} Password: {password}", "security");
-                {
-                    x.Add<User>(email);
-                    x.Add<string>(password);
-                });
                 throw new DisplayException("2FA code invalid");
             }
         }
         else
         {
-            await AuditLogService.Log(AuditLogType.Login, x =>
+            //TODO: AuditLog
-            {
-                x.Add<User>(email);
-            });
             return await GenerateToken(user!, true);
         }
     }
@@ -178,10 +150,7 @@ public class UserService
 
         if (isSystemAction)
         {
-            await AuditLogService.LogSystem(AuditLogType.ChangePassword, x=>
+            //TODO: AuditLog
-            {
-                x.Add<User>(user.Email);
-            });
         }
         else
         {
@@ -194,10 +163,7 @@ public class UserService
                 values.Add("Location", location);
             });
 
-            await AuditLogService.Log(AuditLogType.ChangePassword, x =>
+            //TODO: AuditLog
-            {
-                x.Add<User>(user.Email);
-            });
         }
     }
 
@@ -207,28 +173,18 @@ public class UserService
 
         if (user == null)
         {
-            await SecurityLogService.LogSystem(SecurityLogType.SftpBruteForce, x =>
+            Logger.Warn($"Detected an sftp bruteforce attempt. ID: {id} Password: {password}", "security");
-            {
-                x.Add<int>(id);
-            });
             
             throw new Exception("Invalid username");
         }
         
         if (BCrypt.Net.BCrypt.Verify(password, user.Password))
         {
-            await AuditLogService.LogSystem(AuditLogType.Login, x =>
+            //TODO: AuditLog
-            {
-                x.Add<User>(user.Email);
-            });
             return user;
         }
         
-        await SecurityLogService.LogSystem(SecurityLogType.SftpBruteForce, x =>
+        Logger.Warn($"Detected an sftp bruteforce attempt. ID: {id} Password: {password}", "security");
-        {
-            x.Add<int>(id);
-            x.Add<string>(password);
-        });
         throw new Exception("Invalid userid or password");
     }
 
@@ -271,7 +227,7 @@ public class UserService
         var newPassword = StringHelper.GenerateString(16);
         await ChangePassword(user, newPassword, true);
 
-        await AuditLogService.Log(AuditLogType.PasswordReset, x => {});
+        //TODO: AuditLog
 
         var location = await IpLocateService.GetLocation();
 

Moonlight/App/Services/WebSpaceService.cs

@@ -1,4 +1,5 @@
-using Microsoft.EntityFrameworkCore;
+using DnsClient;
+using Microsoft.EntityFrameworkCore;
 using Moonlight.App.ApiClients.CloudPanel;
 using Moonlight.App.ApiClients.CloudPanel.Requests;
 using Moonlight.App.Database.Entities;
@@ -18,7 +19,8 @@ public class WebSpaceService
 
     private readonly CloudPanelApiHelper CloudPanelApiHelper;
 
-    public WebSpaceService(Repository<CloudPanel> cloudPanelRepository, Repository<WebSpace> webSpaceRepository, CloudPanelApiHelper cloudPanelApiHelper, Repository<MySqlDatabase> databaseRepository)
+    public WebSpaceService(Repository<CloudPanel> cloudPanelRepository, Repository<WebSpace> webSpaceRepository,
+        CloudPanelApiHelper cloudPanelApiHelper, Repository<MySqlDatabase> databaseRepository)
     {
         CloudPanelRepository = cloudPanelRepository;
         WebSpaceRepository = webSpaceRepository;
@@ -37,7 +39,7 @@ public class WebSpaceService
         var ftpPassword = StringHelper.GenerateString(16);
 
         var phpVersion = "8.1"; // TODO: Add config option or smth
-        
+
         var w = new WebSpace()
         {
             CloudPanel = cloudPanel,
@@ -72,11 +74,21 @@ public class WebSpaceService
 
     public async Task Delete(WebSpace w)
     {
-        var website = EnsureData(w);
+        var webSpace = WebSpaceRepository
-        
+            .Get()
-        await CloudPanelApiHelper.Delete(website.CloudPanel, $"site/{website.Domain}", null);
+            .Include(x => x.Databases)
-        
+            .Include(x => x.CloudPanel)
-        WebSpaceRepository.Delete(website);
+            .Include(x => x.Owner)
+            .First(x => x.Id == w.Id);
+
+        foreach (var database in webSpace.Databases.ToArray())
+        {
+            await DeleteDatabase(webSpace, database);
+        }
+
+        await CloudPanelApiHelper.Delete(webSpace.CloudPanel, $"site/{webSpace.Domain}", null);
+
+        WebSpaceRepository.Delete(webSpace);
     }
 
     public async Task<bool> IsHostUp(CloudPanel cloudPanel)
@@ -99,7 +111,7 @@ public class WebSpaceService
 
         return false;
     }
-    
+
     public async Task<bool> IsHostUp(WebSpace w)
     {
         var webSpace = EnsureData(w);
@@ -111,6 +123,52 @@ public class WebSpaceService
     {
         var webspace = EnsureData(w);
 
+        var dns = new LookupClient(new LookupClientOptions()
+        {
+            CacheFailedResults = false,
+            UseCache = false
+        });
+
+        var ipOfWebspaceQuery = await dns.QueryAsync(
+            webspace.Domain,
+            QueryType.A
+        );
+
+        var ipOfWebspaceWwwQuery = await dns.QueryAsync(
+            "www." + webspace.Domain,
+            QueryType.CNAME
+        );
+
+        var ipOfWebspace = ipOfWebspaceQuery.Answers.ARecords().FirstOrDefault();
+        var ipOfWebspaceWww = ipOfWebspaceWwwQuery.Answers.CnameRecords().FirstOrDefault();
+
+        if (ipOfWebspace == null)
+            throw new DisplayException($"Unable to find any a records for {webspace.Domain}", true);
+
+        if (ipOfWebspaceWww == null)
+            throw new DisplayException($"Unable to find any cname records for www.{webspace.Domain}", true);
+
+        var ipOfHostQuery = await dns.QueryAsync(
+            webspace.CloudPanel.Host,
+            QueryType.A
+        );
+
+        var ipOfHost = ipOfHostQuery.Answers.ARecords().FirstOrDefault();
+
+
+        if (ipOfHost == null)
+            throw new DisplayException("Unable to find a record of host system");
+
+        if (ipOfHost.Address.ToString() != ipOfWebspace.Address.ToString())
+            throw new DisplayException("The dns records of your webspace do not point to the host system");
+
+        Logger.Debug($"{ipOfWebspaceWww.CanonicalName.Value}");
+
+        if (ipOfWebspaceWww.CanonicalName.Value != webspace.CloudPanel.Host + ".")
+            throw new DisplayException(
+                $"The dns record www.{webspace.Domain} does not point to {webspace.CloudPanel.Host}", true);
+
+
         await CloudPanelApiHelper.Post(webspace.CloudPanel, "letsencrypt/install/certificate", new InstallLetsEncrypt()
         {
             DomainName = webspace.Domain
@@ -148,7 +206,7 @@ public class WebSpaceService
             DatabaseUserName = database.UserName,
             DatabaseUserPassword = database.Password
         });
-        
+
         webspace.Databases.Add(database);
         WebSpaceRepository.Update(webspace);
     }
@@ -156,7 +214,7 @@ public class WebSpaceService
     public async Task DeleteDatabase(WebSpace w, MySqlDatabase database)
     {
         var webspace = EnsureData(w);
-        
+
         await CloudPanelApiHelper.Delete(webspace.CloudPanel, $"db/{database.UserName}", null);
 
         webspace.Databases.Remove(database);
@@ -170,7 +228,8 @@ public class WebSpaceService
         var webspace = EnsureData(w);
 
         return Task.FromResult<FileAccess>(
-            new SftpFileAccess(webspace.CloudPanel.Host, webspace.UserName, webspace.Password, 22, true, $"/htdocs/{webspace.Domain}")
+            new SftpFileAccess(webspace.CloudPanel.Host, webspace.UserName, webspace.Password, 22, true,
+                $"/htdocs/{webspace.Domain}")
         );
     }
 
@@ -182,7 +241,7 @@ public class WebSpaceService
                 .Include(x => x.CloudPanel)
                 .Include(x => x.Owner)
                 .First(x => x.Id == webSpace.Id);
-        
+
         return webSpace;
     }
 }

Moonlight/Moonlight.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="6.0.5" />
     <PackageReference Include="Blazor-ApexCharts" Version="0.9.16-beta" />
     <PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
     <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
@@ -20,10 +21,11 @@
     <PackageReference Include="CurrieTechnologies.Razor.SweetAlert2" Version="5.4.0" />
     <PackageReference Include="Discord.Net" Version="3.10.0" />
     <PackageReference Include="Discord.Net.Webhook" Version="3.10.0" />
+    <PackageReference Include="DnsClient" Version="1.7.0" />
     <PackageReference Include="FluentFTP" Version="46.0.2" />
     <PackageReference Include="GravatarSharp.Core" Version="1.0.1.2" />
     <PackageReference Include="JWT" Version="10.0.2" />
-    <PackageReference Include="Logging.Net" Version="1.1.3" />
+    <PackageReference Include="LibGit2Sharp" Version="0.27.2" />
     <PackageReference Include="MailKit" Version="4.0.0" />
     <PackageReference Include="Mappy.Net" Version="1.0.2" />
     <PackageReference Include="Markdig" Version="0.31.0" />
@@ -39,13 +41,17 @@
     <PackageReference Include="MineStat" Version="3.1.1" />
     <PackageReference Include="MySqlBackup.NET" Version="2.3.8" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3-beta1" />
+    <PackageReference Include="Octokit" Version="6.0.0" />
     <PackageReference Include="Otp.NET" Version="1.3.0" />
     <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="7.0.0" />
     <PackageReference Include="QRCoder" Version="1.4.3" />
     <PackageReference Include="RestSharp" Version="109.0.0-preview.1" />
+    <PackageReference Include="Serilog" Version="3.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.1-dev-00910" />
+    <PackageReference Include="Serilog.Sinks.File" Version="5.0.1-dev-00947" />
     <PackageReference Include="SSH.NET" Version="2020.0.2" />
     <PackageReference Include="UAParser" Version="3.1.47" />
-    <PackageReference Include="XtermBlazor" Version="1.6.1" />
+    <PackageReference Include="XtermBlazor" Version="1.8.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -73,6 +79,25 @@
     <Folder Include="App\ApiClients\CloudPanel\Resources\" />
     <Folder Include="App\Http\Middleware" />
     <Folder Include="storage\backups\" />
+    <Folder Include="storage\resources\public\background\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AdditionalFiles Include="Shared\Views\Server\Settings\DotnetFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\DotnetVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\FabricVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ForgeVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavaFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavaRuntimeVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavascriptFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\JavascriptVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\Join2StartSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PaperVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PythonFileSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\PythonVersionSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerDeleteSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerRenameSetting.razor" />
+    <AdditionalFiles Include="Shared\Views\Server\Settings\ServerResetSetting.razor" />
   </ItemGroup>
 
 </Project>

Moonlight/Pages/_Layout.cshtml

@@ -105,9 +105,7 @@
 
 <script src="https://www.google.com/recaptcha/api.js"></script>
 
-<script src="https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.5.0/lib/xterm-addon-fit.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.7.0/lib/xterm-addon-fit.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/xterm-addon-search@0.8.2/lib/xterm-addon-search.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/xterm-addon-web-links@0.5.0/lib/xterm-addon-web-links.min.js"></script>
 
 <script src="/_content/BlazorMonaco/lib/monaco-editor/min/vs/loader.js"></script>
 <script>require.config({ paths: { 'vs': '/_content/BlazorMonaco/lib/monaco-editor/min/vs' } });</script>

Moonlight/Program.cs

@@ -1,12 +1,14 @@
 using BlazorDownloadFile;
 using BlazorTable;
 using CurrieTechnologies.Razor.SweetAlert2;
-using Logging.Net;
+using HealthChecks.UI.Client;
 using Moonlight.App.ApiClients.CloudPanel;
 using Moonlight.App.ApiClients.Daemon;
+using Moonlight.App.ApiClients.Modrinth;
 using Moonlight.App.ApiClients.Paper;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.Database;
+using Moonlight.App.Diagnostics.HealthChecks;
 using Moonlight.App.Events;
 using Moonlight.App.Helpers;
 using Moonlight.App.Helpers.Wings;
@@ -16,35 +18,51 @@ using Moonlight.App.Repositories.Domains;
 using Moonlight.App.Repositories.LogEntries;
 using Moonlight.App.Repositories.Servers;
 using Moonlight.App.Services;
+using Moonlight.App.Services.Addon;
 using Moonlight.App.Services.Background;
 using Moonlight.App.Services.DiscordBot;
 using Moonlight.App.Services.Files;
 using Moonlight.App.Services.Interop;
-using Moonlight.App.Services.LogServices;
 using Moonlight.App.Services.Mail;
 using Moonlight.App.Services.Minecraft;
 using Moonlight.App.Services.Notifications;
 using Moonlight.App.Services.Sessions;
 using Moonlight.App.Services.Statistics;
 using Moonlight.App.Services.SupportChat;
+using Serilog;
+using Serilog.Sinks.SystemConsole.Themes;
 
 namespace Moonlight
 {
     public class Program
     {
-        // App version. Change for release
-        public static readonly string AppVersion = $"InDev {Formatter.FormatDateOnly(DateTime.Now.Date)}";
-
         public static async Task Main(string[] args)
         {
-            Logger.UsedLogger = new CacheLogger();
+            // This will also copy all default config files
+            var configService = new ConfigService(new StorageService());
 
+            if (configService.DebugMode)
+            {
+                Log.Logger = new LoggerConfiguration()
+                    .MinimumLevel.Verbose()
+                    .Enrich.FromLogContext()
+                    .WriteTo.Console(
+                        outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u3}] {SourceContext} {Message:lj}{NewLine}{Exception}")
+                    .CreateLogger();
+            }
+            else
+            {
+                Log.Logger = new LoggerConfiguration()
+                    .MinimumLevel.Information()
+                    .Enrich.FromLogContext()
+                    .WriteTo.Console(
+                        outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u3}] {SourceContext} {Message:lj}{NewLine}{Exception}")
+                    .CreateLogger();
+            }
+            
             Logger.Info($"Working dir: {Directory.GetCurrentDirectory()}");
 
             Logger.Info("Running pre-init tasks");
-            
-            // This will also copy all default config files
-            var configService = new ConfigService(new StorageService());
             var databaseCheckupService = new DatabaseCheckupService(configService);
                 
             await databaseCheckupService.Perform();
@@ -66,6 +84,10 @@ namespace Moonlight
                     options.HandshakeTimeout = TimeSpan.FromSeconds(10);
                 });
             builder.Services.AddHttpContextAccessor();
+            builder.Services.AddHealthChecks()
+                .AddCheck<DatabaseHealthCheck>("Database")
+                .AddCheck<NodeHealthCheck>("Nodes")
+                .AddCheck<DaemonHealthCheck>("Daemons");
 
             // Databases
             builder.Services.AddDbContext<DataContext>();
@@ -113,7 +135,6 @@ namespace Moonlight
             builder.Services.AddScoped<OneTimeJwtService>();
             builder.Services.AddSingleton<NotificationServerService>();
             builder.Services.AddScoped<NotificationAdminService>();
-            builder.Services.AddScoped<NotificationClientService>();
             builder.Services.AddScoped<ModalService>();
             builder.Services.AddScoped<SmartDeployService>();
             builder.Services.AddScoped<WebSpaceService>();
@@ -128,15 +149,14 @@ namespace Moonlight
             builder.Services.AddScoped<ReCaptchaService>();
             builder.Services.AddScoped<IpBanService>();
             builder.Services.AddSingleton<OAuth2Service>();
+            builder.Services.AddScoped<DynamicBackgroundService>();
+            builder.Services.AddScoped<ServerAddonPluginService>();
+            builder.Services.AddScoped<KeyListenerService>();
 
             builder.Services.AddScoped<SubscriptionService>();
             builder.Services.AddScoped<SubscriptionAdminService>();
 
             // Loggers
-            builder.Services.AddScoped<SecurityLogService>();
-            builder.Services.AddScoped<AuditLogService>();
-            builder.Services.AddScoped<ErrorLogService>();
-            builder.Services.AddScoped<LogService>();
             builder.Services.AddScoped<MailService>();
             builder.Services.AddSingleton<TrashMailDetectorService>();
 
@@ -155,12 +175,17 @@ namespace Moonlight
             builder.Services.AddSingleton<HostSystemHelper>();
             builder.Services.AddScoped<DaemonApiHelper>();
             builder.Services.AddScoped<CloudPanelApiHelper>();
+            builder.Services.AddScoped<ModrinthApiHelper>();
 
             // Background services
             builder.Services.AddSingleton<DiscordBotService>();
             builder.Services.AddSingleton<StatisticsCaptureService>();
             builder.Services.AddSingleton<DiscordNotificationService>();
             builder.Services.AddSingleton<CleanupService>();
+            builder.Services.AddSingleton<MalwareScanService>();
+            
+            // Other
+            builder.Services.AddSingleton<MoonlightService>();
 
             // Third party services
             builder.Services.AddBlazorTable();
@@ -186,12 +211,19 @@ namespace Moonlight
 
             app.MapBlazorHub();
             app.MapFallbackToPage("/_Host");
+            app.MapHealthChecks("/_health", new()
+            {
+                ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
+            });
 
             // AutoStart services
             _ = app.Services.GetRequiredService<CleanupService>();
             _ = app.Services.GetRequiredService<DiscordBotService>();
             _ = app.Services.GetRequiredService<StatisticsCaptureService>();
             _ = app.Services.GetRequiredService<DiscordNotificationService>();
+            _ = app.Services.GetRequiredService<MalwareScanService>();
+            
+            _ = app.Services.GetRequiredService<MoonlightService>();
 
             // Discord bot service
             //var discordBotService = app.Services.GetRequiredService<DiscordBotService>();

Moonlight/Properties/launchSettings.json

@@ -1,18 +1,11 @@
 {
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:26548",
-      "sslPort": 44339
-    }
-  },
   "profiles": {
     "Moonlight": {
       "commandName": "Project",
       "launchBrowser": true,
       "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
@@ -22,7 +15,8 @@
       "launchBrowser": true,
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development",
-        "ML_SQL_DEBUG": "true"
+        "ML_SQL_DEBUG": "true",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
@@ -32,17 +26,25 @@
       "launchBrowser": false,
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development",
-        "ML_SQL_DEBUG": "true"
+        "ML_SQL_DEBUG": "true",
+        "ML_DEBUG": "true"
       },
       "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118",
       "dotnetRunMessages": true
     },
-    "Docker": {
+    "Watch": {
-      "commandName": "Docker",
+      "commandName": "Executable",
-      "launchBrowser": false,
+      "executablePath": "dotnet",
-      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}",
+      "workingDirectory": "$(ProjectDir)",
-      "publishAllPorts": true,
+      "hotReloadEnabled": true,
-      "useSSL": true
+      "hotReloadProfile": "aspnetcore",
+      "commandLineArgs": "watch run",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "ML_DEBUG": "true"
+      },
+      "applicationUrl": "http://moonlight.testy:5118;https://localhost:7118;http://localhost:5118"
     }
   }
 }

Moonlight/Shared/Components/Alerts/NotFoundAlert.razor

@@ -0,0 +1,31 @@
+<div class="mx-auto">
+    <div class="card">
+        <div class="d-flex justify-content-center pt-5">
+            <img height="300" width="300" src="/assets/media/svg/notfound.svg" alt="Not found"/>
+        </div>
+        <span class="card-title text-center fs-3">
+            <TL>The requested resource was not found</TL>
+        </span>
+        <p class="card-body text-center fs-4 text-gray-800">
+            <TL>We were not able to find the requested resource. This can have following reasons</TL>
+
+            <div class="mt-4 d-flex flex-column align-items-center">
+                <li class="d-flex align-items-center py-2">
+                    <span class="bullet me-5"></span> <TL>The resource was deleted</TL>
+                </li>
+                <li class="d-flex align-items-center py-2">
+                    <span class="bullet me-5"></span> <TL>You have to permission to access this resource</TL>
+                </li>
+                <li class="d-flex align-items-center py-2">
+                    <span class="bullet me-5"></span> <TL>You may have entered invalid data</TL>
+                </li>
+                <li class="d-flex align-items-center py-2">
+                    <span class="bullet me-5"></span> <TL>A unknown bug occured</TL>
+                </li>
+                <li class="d-flex align-items-center py-2">
+                    <span class="bullet me-5"></span> <TL>An api was down and not proper handled</TL>
+                </li>
+            </div>
+        </p>
+    </div>
+</div>

Moonlight/Shared/Components/Auth/Login.razor

@@ -8,11 +8,11 @@
 @using Moonlight.App.Services.Interop
 @using Moonlight.App.Services
 @using Moonlight.App.Exceptions
-@using Logging.Net
 @using Moonlight.App.Database.Entities
 @using Moonlight.App.Models.Misc
 @using Moonlight.App.Services.Sessions
 @using System.ComponentModel.DataAnnotations
+@using Moonlight.App.Helpers
 @using Moonlight.App.Models.Forms
 
 @inject AlertService AlertService

Moonlight/Shared/Components/ErrorBoundaries/ComponentErrorBoundary.razor

@@ -1,66 +0,0 @@
-@using Logging.Net
-@using Moonlight.App.Services.LogServices
-@using Moonlight.App.Services.Sessions
-
-@inherits ErrorBoundary
-
-@inject ErrorLogService ErrorLogService
-
-@if (CurrentException is null)
-{
-    @ChildContent
-}
-else if (ErrorContent is not null)
-{
-    <div class="card card-flush h-md-100">
-        <div class="card-body d-flex flex-column justify-content-between mt-9 bgi-no-repeat bgi-size-cover bgi-position-x-center pb-0">
-            <div class="mb-10">
-                <div class="fs-2hx fw-bold text-gray-800 text-center mb-13">
-                    <span class="me-2">
-                        <TL>Ooops. This component is crashed</TL>
-                    </span>
-                </div>
-                <div class="text-center">
-                    <TL>This component is crashed. The error has been reported to the moonlight team</TL>
-                </div>
-            </div>
-        </div>
-    </div>
-}
-else
-{
-    <div class="card card-flush h-md-100">
-        <div class="card-body d-flex flex-column justify-content-between mt-9 bgi-no-repeat bgi-size-cover bgi-position-x-center pb-0">
-            <div class="mb-10">
-                <div class="fs-2hx fw-bold text-gray-800 text-center mb-13">
-                    <span class="me-2">
-                        <TL>Ooops. This component is crashed</TL>
-                    </span>
-                </div>
-                <div class="text-center">
-                    <TL>This component is crashed. The error has been reported to the moonlight team</TL>
-                </div>
-            </div>
-        </div>
-    </div>
-}
-
-@code
-{
-    List<Exception> receivedExceptions = new();
-
-    protected override async Task OnErrorAsync(Exception exception)
-    {
-        receivedExceptions.Add(exception);
-
-        await ErrorLogService.Log(exception, x => {});
-
-        await base.OnErrorAsync(exception);
-    }
-
-    public new void Recover()
-    {
-        receivedExceptions.Clear();
-        base.Recover();
-    }
-}

Moonlight/Shared/Components/ErrorBoundaries/GlobalErrorBoundary.razor

@@ -1,5 +1,5 @@
-@using Logging.Net
+@using Moonlight.App.Services.Sessions
-@using Moonlight.App.Services.Sessions
+@using Moonlight.App.Helpers
 
 @inherits ErrorBoundary
 

Moonlight/Shared/Components/ErrorBoundaries/PageErrorBoundary.razor

@@ -1,5 +1,5 @@
-@using Logging.Net
+@using Moonlight.App.Exceptions
-@using Moonlight.App.Exceptions
+@using Moonlight.App.Helpers
 @using Moonlight.App.Services
 @using Moonlight.App.Services.Interop
 @using Moonlight.App.Services.Sessions

Moonlight/Shared/Components/ErrorBoundaries/SoftErrorBoundary.razor

@@ -1,12 +1,15 @@
 @using Moonlight.App.Services.Interop
 @using Moonlight.App.Exceptions
 @using Moonlight.App.Services
-@using Logging.Net
 @using Moonlight.App.ApiClients.CloudPanel
+@using Moonlight.App.ApiClients.Daemon
+@using Moonlight.App.ApiClients.Modrinth
 @using Moonlight.App.ApiClients.Wings
+@using Moonlight.App.Helpers
 @inherits ErrorBoundaryBase
 
 @inject AlertService AlertService
+@inject ConfigService ConfigService
 @inject SmartTranslateService SmartTranslateService
 
 @if (Crashed)
@@ -37,14 +40,25 @@ else
     
     protected override async Task OnErrorAsync(Exception exception)
     {
-        Logger.Warn(exception);
+        if (ConfigService.DebugMode)
+        {
+            Logger.Verbose(exception);
+        }
         
         if (exception is DisplayException displayException)
         {
-            await AlertService.Error(
+            if (displayException.DoNotTranslate)
-                SmartTranslateService.Translate("Error"),
+            {
-                SmartTranslateService.Translate(displayException.Message)
+                await AlertService.Error(
-                );
+                    displayException.Message
+                    );
+            }
+            else
+            {
+                await AlertService.Error(
+                    SmartTranslateService.Translate(displayException.Message)
+                    );
+            }
         }
         else if (exception is CloudflareException cloudflareException)
         {
@@ -56,7 +70,7 @@ else
         else if (exception is WingsException wingsException)
         {
             await AlertService.Error(
-                SmartTranslateService.Translate("Error from daemon"),
+                SmartTranslateService.Translate("Error from wings"),
                 wingsException.Message
                 );
             
@@ -64,6 +78,22 @@ else
             
             Logger.Warn($"Wings exception status code: {wingsException.StatusCode}");
         }
+        else if (exception is DaemonException daemonException)
+        {
+            await AlertService.Error(
+                SmartTranslateService.Translate("Error from daemon"),
+                daemonException.Message
+                );
+
+            Logger.Warn($"Wings exception status code: {daemonException.StatusCode}");
+        }
+        else if (exception is ModrinthException modrinthException)
+        {
+            await AlertService.Error(
+                SmartTranslateService.Translate("Error from modrinth"),
+                modrinthException.Message
+                );
+        }
         else if (exception is CloudPanelException cloudPanelException)
         {
             await AlertService.Error(
@@ -77,6 +107,7 @@ else
         }
         else
         {
+            Logger.Warn(exception);
             Crashed = true;
             await InvokeAsync(StateHasChanged);
         }

Moonlight/Shared/Components/FileManagerPartials/FileEditor.razor

@@ -1,10 +1,15 @@
 @using BlazorMonaco
 @using Moonlight.App.Services
+@using Moonlight.App.Services.Interop
+@using Moonlight.App.Services.Sessions
 @using Moonlight.Shared.Components.Partials
 
 @inject SmartTranslateService TranslationService
+@inject KeyListenerService KeyListenerService
 @inject IJSRuntime JsRuntime
 
+@implements IDisposable
+
 <div class="card bg-black rounded">
     <div class="card-body">
         <MonacoEditor CssClass="h-100" @ref="Editor" Id="vseditor" ConstructionOptions="(x) => EditorOptions"/>
@@ -65,6 +70,16 @@
             },
             AutoIndent = true
         };
+        
+        KeyListenerService.KeyPressed += KeyPressed;
+    }
+
+    private async void KeyPressed(object? sender, string e)
+    {
+        if (e == "saveShortcut")
+        {
+            await Submit();
+        }
     }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
@@ -111,4 +126,10 @@
     {
         return await Editor.GetValue();
     }
+
+    public void Dispose()
+    {
+        Editor.Dispose();
+        KeyListenerService.KeyPressed -= KeyPressed;
+    }
 }

Moonlight/Shared/Components/FileManagerPartials/FileManager.razor

@@ -1,6 +1,5 @@
 @using Moonlight.App.Helpers.Files
 @using Moonlight.App.Helpers
-@using Logging.Net
 @using Moonlight.App.Services
 @using Moonlight.App.Services.Interop
 @using BlazorDownloadFile
@@ -17,7 +16,7 @@
                 InitialData="@EditorInitialData"
                 Language="@EditorLanguage"
                 OnCancel="() => Cancel()"
-                OnSubmit="(_) => Cancel(true)"
+                OnSubmit="(_) => Save()"
                 HideControls="false">
     </FileEditor>
 }
@@ -254,6 +253,13 @@ else
         await InvokeAsync(StateHasChanged);
         return false;
     }
+    
+    private async void Save()
+    {
+        var data = await Editor.GetData();
+        await Access.Write(EditingFile, data);
+        await ToastService.Success(SmartTranslateService.Translate("Successfully saved file"));
+    }
 
     private async void Cancel(bool save = false)
     {

Moonlight/Shared/Components/FileManagerPartials/FilePath.razor

@@ -1,5 +1,4 @@
 @using Moonlight.App.Helpers.Files
-@using Logging.Net
 
 <div class="badge badge-lg badge-light-primary">
     <div class="d-flex align-items-center flex-wrap">

Moonlight/Shared/Components/FileManagerPartials/FileUpload.razor

@@ -1,7 +1,7 @@
 @using Moonlight.App.Helpers.Files
 @using Moonlight.App.Services
 @using Moonlight.App.Services.Interop
-@using Logging.Net
+@using Moonlight.App.Helpers
 
 @inject ToastService ToastService
 @inject SmartTranslateService SmartTranslateService