Merge pull request #204 from Moonlight-Panel/SwitchToNewConfigSystem

Switched to new config system

.gitattributes

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

.github/workflows/test-docker-build.yml

@@ -0,0 +1,18 @@
+name: Test Build
+
+on:
+    push:
+        branches: [ "main" ]
+    pull_request:
+        types:
+            - closed
+        branches: [ "main" ]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v2
+            - name: Build Docker image
+              run: docker build -t moonlightpanel/moonlight:${{ github.sha }} -f Moonlight/Dockerfile .

.gitignore

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

Moonlight/App/ApiClients/Daemon/DaemonApiHelper.cs

@@ -1,5 +1,4 @@
 using Moonlight.App.Database.Entities;
-using Moonlight.App.Exceptions;
 using Newtonsoft.Json;
 using RestSharp;
 
@@ -14,26 +13,13 @@ public class DaemonApiHelper
         Client = new();
     }
     
-    private string GetApiUrl(Node node)
-    {
-        /* SSL not implemented in moonlight daemon
-        if(node.Ssl)
-            return $"https://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-        else
-            return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";*/
-        
-        return $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
-    }
-    
     public async Task<T> Get<T>(Node node, string resource)
     {
-        RestRequest request = new(GetApiUrl(node) + resource);
+        var request = await CreateRequest(node, resource);
 
-        request.AddHeader("Content-Type", "application/json");
-        request.AddHeader("Accept", "application/json");
-        request.AddHeader("Authorization", node.Token);
+        request.Method = Method.Get;
         
-        var response = await Client.GetAsync(request);
+        var response = await Client.ExecuteAsync(request);
 
         if (!response.IsSuccessful)
         {
@@ -52,4 +38,69 @@ public class DaemonApiHelper
 
         return JsonConvert.DeserializeObject<T>(response.Content!)!;
     }
+    
+    public async Task Post(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Post;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+    
+    public async Task Delete(Node node, string resource, object body)
+    {
+        var request = await CreateRequest(node, resource);
+
+        request.Method = Method.Delete;
+
+        request.AddParameter("text/plain", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
+
+        var response = await Client.ExecuteAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            if (response.StatusCode != 0)
+            {
+                throw new DaemonException(
+                    $"An error occured: ({response.StatusCode}) {response.Content}",
+                    (int)response.StatusCode
+                );
+            }
+            else
+            {
+                throw new Exception($"An internal error occured: {response.ErrorMessage}");
+            }
+        }
+    }
+
+    private Task<RestRequest> CreateRequest(Node node, string resource)
+    {
+        var url = $"http://{node.Fqdn}:{node.MoonlightDaemonPort}/";
+        
+        RestRequest request = new(url + resource);
+
+        request.AddHeader("Content-Type", "application/json");
+        request.AddHeader("Accept", "application/json");
+        request.AddHeader("Authorization", node.Token);
+        
+        return Task.FromResult(request);
+    }
 }

Moonlight/App/ApiClients/Daemon/Requests/Mount.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Mount
+{
+    public string Server { get; set; } = "";
+    public string ServerPath { get; set; } = "";
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Requests/Unmount.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Requests;
+
+public class Unmount
+{
+    public string Path { get; set; } = "";
+}

Moonlight/App/ApiClients/Daemon/Resources/Container.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class Container
+{
+    public string Name { get; set; } = "";
+    public long Memory { get; set; }
+    public double Cpu { get; set; }
+    public long NetworkIn { get; set; }
+    public long NetworkOut { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/ContainerStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class ContainerStats
-{
-    public List<Container> Containers { get; set; } = new();
-    
-    public class Container
-    {
-        public string Name { get; set; }
-        public long Memory { get; set; }
-        public double Cpu { get; set; }
-        public long NetworkIn { get; set; }
-        public long NetworkOut { get; set; }
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/CpuMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class CpuMetrics
+{
+    public string CpuModel { get; set; } = "";
+    public double CpuUsage { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/CpuStats.cs

@@ -1,8 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class CpuStats
-{
-    public double Usage { get; set; }
-    public int Cores { get; set; }
-    public string Model { get; set; } = "";
-}

Moonlight/App/ApiClients/Daemon/Resources/DiskMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DiskMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/DiskStats.cs

@@ -1,9 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class DiskStats
-{
-    public long FreeBytes { get; set; }
-    public string DriveFormat { get; set; }
-    public string Name { get; set; }
-    public long TotalSize { get; set; }
-}

Moonlight/App/ApiClients/Daemon/Resources/DockerMetrics.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class DockerMetrics
+{
+    public Container[] Containers { get; set; } = Array.Empty<Container>();
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class MemoryMetrics
+{
+    public long Used { get; set; }
+    public long Total { get; set; }
+}

Moonlight/App/ApiClients/Daemon/Resources/MemoryStats.cs

@@ -1,15 +0,0 @@
-namespace Moonlight.App.ApiClients.Daemon.Resources;
-
-public class MemoryStats
-{
-    public List<MemoryStick> Sticks { get; set; } = new();
-    public double Free { get; set; }
-    public double Used { get; set; }
-    public double Total { get; set; }
-    
-    public class MemoryStick
-    {
-        public int Size { get; set; }
-        public string Type { get; set; } = "";
-    }
-}

Moonlight/App/ApiClients/Daemon/Resources/SystemMetrics.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.ApiClients.Daemon.Resources;
+
+public class SystemMetrics
+{
+    public string OsName { get; set; } = "";
+    public long Uptime { get; set; }
+}

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 = 300000
+        };
+
+        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/ApiClients/Wings/WingsApiHelper.cs

@@ -209,7 +209,7 @@ public class WingsApiHelper
 
         var request = new RestRequest(url)
         {
-            Timeout = 60 * 15
+            Timeout = 300000
         };
 
         request.AddHeader("Content-Type", "application/json");

Moonlight/App/Configuration/ConfigV1.cs

@@ -0,0 +1,226 @@
+namespace Moonlight.App.Configuration;
+
+using System;
+using Newtonsoft.Json;
+
+public class ConfigV1
+{
+    [JsonProperty("Moonlight")] public MoonlightData Moonlight { get; set; } = new();
+
+    public class MoonlightData
+    {
+        [JsonProperty("AppUrl")] public string AppUrl { get; set; } = "http://your-moonlight-url-without-slash";
+
+        [JsonProperty("Database")] public DatabaseData Database { get; set; } = new();
+
+        [JsonProperty("DiscordBotApi")] public DiscordBotData DiscordBotApi { get; set; } = new();
+
+        [JsonProperty("DiscordBot")] public DiscordBotData DiscordBot { get; set; } = new();
+
+        [JsonProperty("Domains")] public DomainsData Domains { get; set; } = new();
+
+        [JsonProperty("Html")] public HtmlData Html { get; set; } = new();
+
+        [JsonProperty("Marketing")] public MarketingData Marketing { get; set; } = new();
+
+        [JsonProperty("OAuth2")] public OAuth2Data OAuth2 { get; set; } = new();
+
+        [JsonProperty("Security")] public SecurityData Security { get; set; } = new();
+
+        [JsonProperty("Mail")] public MailData Mail { get; set; } = new();
+
+        [JsonProperty("Cleanup")] public CleanupData Cleanup { get; set; } = new();
+
+        [JsonProperty("Subscriptions")] public SubscriptionsData Subscriptions { get; set; } = new();
+
+        [JsonProperty("DiscordNotifications")]
+        public DiscordNotificationsData DiscordNotifications { get; set; } = new();
+
+        [JsonProperty("Statistics")] public StatisticsData Statistics { get; set; } = new();
+
+        [JsonProperty("Rating")] public RatingData Rating { get; set; } = new();
+
+        [JsonProperty("SmartDeploy")] public SmartDeployData SmartDeploy { get; set; } = new();
+
+        [JsonProperty("Sentry")] public SentryData Sentry { get; set; } = new();
+    }
+
+    public class CleanupData
+    {
+        [JsonProperty("Cpu")] public long Cpu { get; set; } = 90;
+
+        [JsonProperty("Memory")] public long Memory { get; set; } = 8192;
+
+        [JsonProperty("Wait")] public long Wait { get; set; } = 15;
+
+        [JsonProperty("Uptime")] public long Uptime { get; set; } = 6;
+
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("MinUptime")] public long MinUptime { get; set; } = 10;
+    }
+
+    public class DatabaseData
+    {
+        [JsonProperty("Database")] public string Database { get; set; } = "moonlight_db";
+
+        [JsonProperty("Host")] public string Host { get; set; } = "your.database.host";
+
+        [JsonProperty("Password")] public string Password { get; set; } = "secret";
+
+        [JsonProperty("Port")] public long Port { get; set; } = 3306;
+
+        [JsonProperty("Username")] public string Username { get; set; } = "moonlight_user";
+    }
+
+    public class DiscordBotData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("Token")] public string Token { get; set; } = "discord token here";
+
+        [JsonProperty("PowerActions")] public bool PowerActions { get; set; } = false;
+        [JsonProperty("SendCommands")] public bool SendCommands { get; set; } = false;
+    }
+
+    public class DiscordNotificationsData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("WebHook")] public string WebHook { get; set; } = "http://your-discord-webhook-url";
+    }
+
+    public class DomainsData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+        [JsonProperty("AccountId")] public string AccountId { get; set; } = "cloudflare acc id";
+
+        [JsonProperty("Email")] public string Email { get; set; } = "cloudflare@acc.email";
+
+        [JsonProperty("Key")] public string Key { get; set; } = "secret";
+    }
+
+    public class HtmlData
+    {
+        [JsonProperty("Headers")] public HeadersData Headers { get; set; } = new();
+    }
+
+    public class HeadersData
+    {
+        [JsonProperty("Color")] public string Color { get; set; } = "#4b27e8";
+
+        [JsonProperty("Description")] public string Description { get; set; } = "the next generation hosting panel";
+
+        [JsonProperty("Keywords")] public string Keywords { get; set; } = "moonlight";
+
+        [JsonProperty("Title")] public string Title { get; set; } = "Moonlight - endelon.link";
+    }
+
+    public class MailData
+    {
+        [JsonProperty("Email")] public string Email { get; set; } = "username@your.mail.host";
+
+        [JsonProperty("Server")] public string Server { get; set; } = "your.mail.host";
+
+        [JsonProperty("Password")] public string Password { get; set; } = "secret";
+
+        [JsonProperty("Port")] public int Port { get; set; } = 465;
+
+        [JsonProperty("Ssl")] public bool Ssl { get; set; } = true;
+    }
+
+    public class MarketingData
+    {
+        [JsonProperty("BrandName")] public string BrandName { get; set; } = "Endelon Hosting";
+
+        [JsonProperty("Imprint")] public string Imprint { get; set; } = "https://your-site.xyz/imprint";
+
+        [JsonProperty("Privacy")] public string Privacy { get; set; } = "https://your-site.xyz/privacy";
+        [JsonProperty("About")] public string About { get; set; } = "https://your-site.xyz/about";
+        [JsonProperty("Website")] public string Website { get; set; } = "https://your-site.xyz";
+    }
+
+    public class OAuth2Data
+    {
+        [JsonProperty("OverrideUrl")] public string OverrideUrl { get; set; } = "https://only-for-development.cases";
+
+        [JsonProperty("EnableOverrideUrl")] public bool EnableOverrideUrl { get; set; } = false;
+
+        [JsonProperty("Providers")]
+        public OAuth2ProviderData[] Providers { get; set; } = Array.Empty<OAuth2ProviderData>();
+    }
+
+    public class OAuth2ProviderData
+    {
+        [JsonProperty("Id")] public string Id { get; set; }
+
+        [JsonProperty("ClientId")] public string ClientId { get; set; }
+
+        [JsonProperty("ClientSecret")] public string ClientSecret { get; set; }
+    }
+
+    public class RatingData
+    {
+        [JsonProperty("Enabled")] public bool Enabled { get; set; } = false;
+
+        [JsonProperty("Url")] public string Url { get; set; } = "https://link-to-google-or-smth";
+
+        [JsonProperty("MinRating")] public int MinRating { get; set; } = 4;
+
+        [JsonProperty("DaysSince")] public int DaysSince { get; set; } = 5;
+    }
+
+    public class SecurityData
+    {
+        [JsonProperty("Token")] public string Token { get; set; } = Guid.NewGuid().ToString();
+
+        [JsonProperty("ReCaptcha")] public ReCaptchaData ReCaptcha { get; set; }
+    }
+
+    public class ReCaptchaData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("SiteKey")] public string SiteKey { get; set; } = "recaptcha site key here";
+
+        [JsonProperty("SecretKey")] public string SecretKey { get; set; } = "recaptcha secret here";
+    }
+
+    public class SentryData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("Dsn")] public string Dsn { get; set; } = "http://your-sentry-url-here";
+    }
+
+    public class SmartDeployData
+    {
+        [JsonProperty("Server")] public SmartDeployServerData Server { get; set; } = new();
+    }
+
+    public class SmartDeployServerData
+    {
+        [JsonProperty("EnableOverride")] public bool EnableOverride { get; set; } = false;
+
+        [JsonProperty("OverrideNode")] public long OverrideNode { get; set; } = 1;
+    }
+
+    public class StatisticsData
+    {
+        [JsonProperty("Enabled")] public bool Enabled { get; set; } = false;
+
+        [JsonProperty("Wait")] public long Wait { get; set; } = 15;
+    }
+
+    public class SubscriptionsData
+    {
+        [JsonProperty("SellPass")] public SellPassData SellPass { get; set; } = new();
+    }
+
+    public class SellPassData
+    {
+        [JsonProperty("Enable")] public bool Enable { get; set; } = false;
+
+        [JsonProperty("Url")] public string Url { get; set; } = "https://not-implemented-yet";
+    }
+}

Moonlight/App/Database/DataContext.cs

@@ -52,14 +52,14 @@ public class DataContext : DbContext
         if (!optionsBuilder.IsConfigured)
         {
             var config = ConfigService
-                .GetSection("Moonlight")
-                .GetSection("Database");
+                .Get()
+                .Moonlight.Database;
 
-            var connectionString = $"host={config.GetValue<string>("Host")};" +
-                                   $"port={config.GetValue<int>("Port")};" +
-                                   $"database={config.GetValue<string>("Database")};" +
-                                   $"uid={config.GetValue<string>("Username")};" +
-                                   $"pwd={config.GetValue<string>("Password")}";
+            var connectionString = $"host={config.Host};" +
+                                   $"port={config.Port};" +
+                                   $"database={config.Database};" +
+                                   $"uid={config.Username};" +
+                                   $"pwd={config.Password}";
             
             optionsBuilder.UseMySql(
                 connectionString,

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

@@ -24,6 +24,8 @@ public class User
     
     public string Country { get; set; } = "";
 
+    public string ServerListLayoutJson { get; set; } = "";
+
     // States
     
     public UserStatus Status { get; set; } = UserStatus.Unverified;
@@ -31,6 +33,7 @@ public class User
     public bool SupportPending { get; set; } = false;
     public bool HasRated { get; set; } = false;
     public int Rating { get; set; } = 0;
+    public bool StreamerMode { get; set; } = false;
     
     // Security
     public bool TotpEnabled { get; set; } = false;
@@ -43,6 +46,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/20230623235512_AddedServerListLayoutToUser.cs

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

Moonlight/App/Database/Migrations/20230625190428_AddedStreamerMode.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Moonlight.App.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedStreamerMode : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "StreamerMode",
+                table: "Users",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "StreamerMode",
+                table: "Users");
+        }
+    }
+}

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");
@@ -765,6 +780,10 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Rating")
                         .HasColumnType("int");
 
+                    b.Property<string>("ServerListLayoutJson")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
                     b.Property<string>("State")
                         .IsRequired()
                         .HasColumnType("longtext");
@@ -772,6 +791,9 @@ namespace Moonlight.App.Database.Migrations
                     b.Property<int>("Status")
                         .HasColumnType("int");
 
+                    b.Property<bool>("StreamerMode")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<int>("SubscriptionDuration")
                         .HasColumnType("int");
 
@@ -928,6 +950,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 +976,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,11 +1,10 @@
 using System.Diagnostics;
-using Logging.Net;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.Events;
 
 public class EventSystem
 {
-    private Dictionary<int, object> Storage = new();
     private List<Subscriber> Subscribers = new();
 
     private readonly bool Debug = false;
@@ -33,16 +32,8 @@ public class EventSystem
         return Task.CompletedTask;
     }
 
-    public Task Emit(string id, object? d = null)
+    public Task Emit(string id, object? data = null)
     {
-        int hashCode = -1;
-
-        if (d != null)
-        {
-            hashCode = d.GetHashCode();
-            Storage.TryAdd(hashCode, d);
-        }
-
         Subscriber[] subscribers;
 
         lock (Subscribers)
@@ -58,23 +49,6 @@ public class EventSystem
         {
             tasks.Add(new Task(() =>
             {
-                int storageId = hashCode + 0; // To create a copy of the hash code
-
-                object? data = null;
-
-                if (storageId != -1)
-                {
-                    if (Storage.TryGetValue(storageId, out var value))
-                    {
-                        data = value;
-                    }
-                    else
-                    {
-                        Logger.Warn($"Object with the hash '{storageId}' was not present in the storage");
-                        return;
-                    }
-                }
-
                 var stopWatch = new Stopwatch();
                 stopWatch.Start();
 
@@ -115,7 +89,6 @@ public class EventSystem
         Task.Run(() =>
         {
             Task.WaitAll(tasks.ToArray());
-            Storage.Remove(hashCode);
 
             if(Debug)
                 Logger.Debug($"Completed all event tasks for '{id}' and removed object from storage");
@@ -139,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
@@ -20,6 +22,11 @@ public class DisplayException : Exception
     {
     }
     
+    public DisplayException(string message, bool doNotTranslate) : base(message)
+    {
+        DoNotTranslate = doNotTranslate;
+    }
+
     public DisplayException(string message, Exception inner) : base(message, inner)
     {
     }

Moonlight/App/Extensions/JSRuntimeExtensions.cs

@@ -0,0 +1,30 @@
+using Microsoft.JSInterop;
+
+namespace Moonlight.App.Extensions;
+
+public static class JSRuntimeExtensions
+{
+    public static async Task InvokeVoidSafeAsync(this IJSRuntime jsRuntime, string method, params object[] args)
+    {
+        try
+        {
+            await jsRuntime.InvokeVoidAsync(method, args);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+    }
+    
+    public static void InvokeVoidSafe(this IJSRuntime jsRuntime, string method, params object[] args)
+    {
+        try
+        {
+            jsRuntime.InvokeVoidAsync(method, args);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+    }
+}

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/DatabaseCheckup.cs

@@ -1,94 +0,0 @@
-using System.Diagnostics;
-using Logging.Net;
-using Microsoft.EntityFrameworkCore;
-using Moonlight.App.Database;
-using Moonlight.App.Services;
-using Moonlight.App.Services.Files;
-using MySql.Data.MySqlClient;
-
-namespace Moonlight.App.Helpers;
-
-public class DatabaseCheckup
-{
-    public static void Perform()
-    {
-        // This will also copy all default config files
-        var context = new DataContext(new ConfigService(new StorageService()));
-
-        Logger.Info("Checking database");
-        
-        if (!context.Database.CanConnect())
-        {
-            Logger.Fatal("-----------------------------------------------");
-            Logger.Fatal("Unable to connect to mysql database");
-            Logger.Fatal("Please make sure the configuration is correct");
-            Logger.Fatal("");
-            Logger.Fatal("Moonlight will wait 1 minute, then exit");
-            Logger.Fatal("-----------------------------------------------");
-            
-            Thread.Sleep(TimeSpan.FromMinutes(1));
-            Environment.Exit(10324);
-        }
-
-        Logger.Info("Checking for pending migrations");
-
-        var migrations = context.Database
-            .GetPendingMigrations()
-            .ToArray();
-        
-        if (migrations.Any())
-        {
-            Logger.Info($"{migrations.Length} migrations pending. Updating now");
-            
-            BackupDatabase();
-            
-            Logger.Info("Applying migrations");
-            
-            context.Database.Migrate();
-            
-            Logger.Info("Successfully applied migrations");
-        }
-        else
-        {
-            Logger.Info("Database is up-to-date. No migrations have been performed");
-        }
-    }
-
-    public static void BackupDatabase()
-    {
-        Logger.Info("Creating backup from database");
-        
-        var configService = new ConfigService(new StorageService());
-        var dateTimeService = new DateTimeService();
-        
-        var config = configService
-            .GetSection("Moonlight")
-            .GetSection("Database");
-
-        var connectionString = $"host={config.GetValue<string>("Host")};" +
-                               $"port={config.GetValue<int>("Port")};" +
-                               $"database={config.GetValue<string>("Database")};" +
-                               $"uid={config.GetValue<string>("Username")};" +
-                               $"pwd={config.GetValue<string>("Password")}";
-        
-        string file = PathBuilder.File("storage", "backups", $"{dateTimeService.GetCurrentUnix()}-mysql.sql");
-        
-        Logger.Info($"Saving it to: {file}");
-        Logger.Info("Starting backup...");
-
-        var sw = new Stopwatch();
-        sw.Start();
-
-        using MySqlConnection conn = new MySqlConnection(connectionString);
-        using MySqlCommand cmd = new MySqlCommand();
-        using MySqlBackup mb = new MySqlBackup(cmd);
-        
-        cmd.Connection = conn;
-        conn.Open();
-        mb.ExportToFile(file);
-        conn.Close();
-
-        sw.Stop();
-        Logger.Info($"Done. {sw.Elapsed.TotalSeconds}s");
-    }
-}

Moonlight/App/Helpers/DatabaseCheckupService.cs

@@ -0,0 +1,110 @@
+using System.Diagnostics;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.App.Database;
+using Moonlight.App.Services;
+using Moonlight.App.Services.Files;
+using MySql.Data.MySqlClient;
+
+namespace Moonlight.App.Helpers;
+
+public class DatabaseCheckupService
+{
+    private readonly ConfigService ConfigService;
+
+    public DatabaseCheckupService(ConfigService configService)
+    {
+        ConfigService = configService;
+    }
+
+    public async Task Perform()
+    {
+        var context = new DataContext(ConfigService);
+
+        Logger.Info("Checking database");
+        
+        if (!await context.Database.CanConnectAsync())
+        {
+            Logger.Fatal("-----------------------------------------------");
+            Logger.Fatal("Unable to connect to mysql database");
+            Logger.Fatal("Please make sure the configuration is correct");
+            Logger.Fatal("");
+            Logger.Fatal("Moonlight will wait 1 minute, then exit");
+            Logger.Fatal("-----------------------------------------------");
+            
+            Thread.Sleep(TimeSpan.FromMinutes(1));
+            Environment.Exit(10324);
+        }
+
+        Logger.Info("Checking for pending migrations");
+
+        var migrations = (await context.Database
+            .GetPendingMigrationsAsync())
+            .ToArray();
+
+        if (migrations.Any())
+        {
+            Logger.Info($"{migrations.Length} migrations pending. Updating now");
+            
+            await BackupDatabase();
+            
+            Logger.Info("Applying migrations");
+            
+            await context.Database.MigrateAsync();
+            
+            Logger.Info("Successfully applied migrations");
+        }
+        else
+        {
+            Logger.Info("Database is up-to-date. No migrations have been performed");
+        }
+    }
+
+    public async Task BackupDatabase()
+    {
+        Logger.Info("Creating backup from database");
+        
+        var configService = new ConfigService(new StorageService());
+        var dateTimeService = new DateTimeService();
+
+        var config = configService.Get().Moonlight.Database;
+
+        var connectionString = $"host={config.Host};" +
+                               $"port={config.Port};" +
+                               $"database={config.Database};" +
+                               $"uid={config.Username};" +
+                               $"pwd={config.Password}";
+        
+        string file = PathBuilder.File("storage", "backups", $"{dateTimeService.GetCurrentUnix()}-mysql.sql");
+        
+        Logger.Info($"Saving it to: {file}");
+        Logger.Info("Starting backup...");
+
+        try
+        {
+            var sw = new Stopwatch();
+            sw.Start();
+
+            await using MySqlConnection conn = new MySqlConnection(connectionString);
+            await using MySqlCommand cmd = new MySqlCommand();
+            using MySqlBackup mb = new MySqlBackup(cmd);
+        
+            cmd.Connection = conn;
+            await conn.OpenAsync();
+            mb.ExportToFile(file);
+            await conn.CloseAsync();
+
+            sw.Stop();
+            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/Files/WingsFileAccess.cs

@@ -3,6 +3,7 @@ using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.ApiClients.Wings.Requests;
 using Moonlight.App.ApiClients.Wings.Resources;
 using Moonlight.App.Database.Entities;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Services;
 using RestSharp;
 
@@ -110,7 +111,7 @@ public class WingsFileAccess : FileAccess
         request.AddParameter("name", "files");
         request.AddParameter("filename", name);
         request.AddHeader("Content-Type", "multipart/form-data");
-        request.AddHeader("Origin", ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl"));
+        request.AddHeader("Origin", ConfigService.Get().Moonlight.AppUrl);
         request.AddFile("files", () =>
         {
             return new StreamProgressHelper(dataStream)
@@ -211,13 +212,27 @@ public class WingsFileAccess : FileAccess
 
     public override async Task Decompress(FileData fileData)
     {
-        var req = new DecompressFile()
+        try
         {
-            Root = CurrentPath,
-            File = fileData.Name
-        };
+            var req = new DecompressFile()
+            {
+                Root = CurrentPath,
+                File = fileData.Name
+            };
 
-        await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
+            await WingsApiHelper.Post(Server.Node, $"api/servers/{Server.Uuid}/files/decompress", req);
+        }
+        catch (Exception e)
+        {
+            if (e.Message.ToLower().Contains("canceled"))
+            {
+                // ignore, maybe do smth better here, like showing a waiting thing or so
+            }
+            else
+            {
+                throw;
+            }
+        }
     }
 
     public override Task<string> GetLaunchUrl()

Moonlight/App/Helpers/Formatter.cs

@@ -8,7 +8,26 @@ public static class Formatter
     {
         TimeSpan t = TimeSpan.FromMilliseconds(uptime);
 
-        return $"{t.Hours}h {t.Minutes}m {t.Seconds}s";
+        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";
+        }
+    }
+    
+    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)
@@ -109,4 +128,12 @@ public static class Formatter
             return (i / (1024D * 1024D)).Round(2) + " GB";
         }
     }
+    
+    public static double BytesToGb(long bytes)
+    {
+        const double gbMultiplier = 1024 * 1024 * 1024; // 1 GB = 1024 MB * 1024 KB * 1024 B
+
+        double gigabytes = (double)bytes / gbMultiplier;
+        return gigabytes;
+    }
 }

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/Retry.cs

@@ -0,0 +1,66 @@
+namespace Moonlight.App.Helpers;
+
+public class Retry
+{
+    private List<Type> RetryExceptionTypes;
+    private List<Func<Exception, bool>> RetryFilters;
+    private int RetryTimes = 1;
+
+    public Retry()
+    {
+        RetryExceptionTypes = new();
+        RetryFilters = new();
+    }
+
+    public Retry Times(int times)
+    {
+        RetryTimes = times;
+        return this;
+    }
+
+    public Retry At(Func<Exception, bool> filter)
+    {
+        RetryFilters.Add(filter);
+        return this;
+    }
+
+    public Retry At<T>()
+    {
+        RetryExceptionTypes.Add(typeof(T));
+        return this;
+    }
+
+    public async Task Call(Func<Task> method)
+    {
+        int triesLeft = RetryTimes;
+        
+        do
+        {
+            try
+            {
+                await method.Invoke();
+                return;
+            }
+            catch (Exception e)
+            {
+                if(triesLeft < 1) // Throw if no tries left
+                    throw;
+                
+                if (RetryExceptionTypes.Any(x => x.FullName == e.GetType().FullName))
+                {
+                    triesLeft--;
+                    continue;
+                }
+
+                if (RetryFilters.Any(x => x.Invoke(e)))
+                {
+                    triesLeft--;
+                    continue;
+                }
+
+                // Throw if not filtered -> unknown/unhandled
+                throw;
+            }
+        } while (triesLeft >= 0);
+    }
+}

Moonlight/App/Helpers/Wings/Data/ConsoleMessage.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ConsoleMessage
+{
+    public string Content { get; set; } = "";
+    public bool IsInternal { get; set; } = false;
+}

Moonlight/App/Helpers/Wings/Data/ServerResource.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+
+namespace Moonlight.App.Helpers.Wings.Data;
+
+public class ServerResource
+{
+    [JsonProperty("memory_bytes")]
+    public long MemoryBytes { get; set; }
+
+    [JsonProperty("memory_limit_bytes")]
+    public long MemoryLimitBytes { get; set; }
+
+    [JsonProperty("cpu_absolute")]
+    public float CpuAbsolute { get; set; }
+
+    [JsonProperty("network")]
+    public NetworkData Network { get; set; }
+
+    [JsonProperty("uptime")]
+    public double Uptime { get; set; }
+
+    [JsonProperty("state")]
+    public string State { get; set; }
+
+    [JsonProperty("disk_bytes")]
+    public long DiskBytes { get; set; }
+
+    public class NetworkData
+    {
+        [JsonProperty("rx_bytes")]
+        public long RxBytes { get; set; }
+
+        [JsonProperty("tx_bytes")]
+        public long TxBytes { get; set; }
+    }
+}

Moonlight/App/Helpers/Wings/Enums/ConsoleState.cs

@@ -0,0 +1,8 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ConsoleState
+{
+    Disconnected,
+    Connecting,
+    Connected
+}

Moonlight/App/Helpers/Wings/Enums/ServerState.cs

@@ -0,0 +1,10 @@
+namespace Moonlight.App.Helpers.Wings.Enums;
+
+public enum ServerState
+{
+    Starting,
+    Running,
+    Stopping,
+    Offline,
+    Installing
+}

Moonlight/App/Helpers/Wings/Events/BaseEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class BaseEvent
+{
+    public string Event { get; set; } = "";
+    public string[] Args { get; set; } = Array.Empty<string>();
+}

Moonlight/App/Helpers/Wings/Events/SendTokenEvent.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Helpers.Wings.Events;
+
+public class SendTokenEvent
+{
+    public string Event { get; set; } = "auth";
+    public List<string> Args = new();
+}

Moonlight/App/Helpers/Wings/WingsConsole.cs

@@ -0,0 +1,389 @@
+using System.Net.WebSockets;
+using System.Text;
+using Moonlight.App.Helpers.Wings.Data;
+using Moonlight.App.Helpers.Wings.Enums;
+using Moonlight.App.Helpers.Wings.Events;
+using Newtonsoft.Json;
+using ConsoleMessage = Moonlight.App.Helpers.Wings.Data.ConsoleMessage;
+
+namespace Moonlight.App.Helpers.Wings;
+
+public class WingsConsole : IDisposable
+{
+    private ClientWebSocket WebSocket;
+    public List<ConsoleMessage> Messages;
+    private Task? ConsoleTask;
+
+    private string Socket = "";
+    private string Origin = "";
+    private string Token = "";
+    
+    private bool Disconnecting;
+
+    public ConsoleState ConsoleState { get; private set; }
+    public ServerState ServerState { get; private set; }
+    public ServerResource Resource { get; private set; }
+
+    public EventHandler<ConsoleState> OnConsoleStateUpdated { get; set; }
+    public EventHandler<ServerState> OnServerStateUpdated { get; set; }
+    public EventHandler<ServerResource> OnResourceUpdated { get; set; }
+    public EventHandler<ConsoleMessage> OnMessage { get; set; }
+    public Func<WingsConsole, Task<string>> OnRequestNewToken { get; set; }
+
+    public WingsConsole()
+    {
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+    }
+
+    public Task Connect(string origin, string socket, string token)
+    {
+        Disconnecting = false;
+        WebSocket = new();
+        ConsoleState = ConsoleState.Disconnected;
+        ServerState = ServerState.Offline;
+        Messages = new();
+        
+        Resource = new()
+        {
+            Network = new()
+            {
+                RxBytes = 0,
+                TxBytes = 0
+            },
+            State = "offline",
+            Uptime = 0,
+            CpuAbsolute = 0,
+            DiskBytes = 0,
+            MemoryBytes = 0,
+            MemoryLimitBytes = 0
+        };
+        
+        Socket = socket;
+        Origin = origin;
+        Token = token;
+
+        WebSocket.Options.SetRequestHeader("Origin", Origin);
+        WebSocket.Options.SetRequestHeader("Authorization", "Bearer " + Token);
+
+        ConsoleTask = Task.Run(async () =>
+        {
+            try
+            {
+                await Work();
+            }
+            catch (Exception e)
+            {
+                Logger.Warn("Error connecting to wings console");
+                Logger.Warn(e);
+            }
+        });
+
+        return Task.CompletedTask;
+    }
+
+    private async Task Work()
+    {
+        await UpdateConsoleState(ConsoleState.Connecting);
+
+        await WebSocket.ConnectAsync(
+            new Uri(Socket),
+            CancellationToken.None
+        );
+
+        if (WebSocket.State != WebSocketState.Connecting && WebSocket.State != WebSocketState.Open)
+        {
+            await SaveMessage("Unable to connect to websocket", true);
+            await UpdateConsoleState(ConsoleState.Disconnected);
+            return;
+        }
+
+        await UpdateConsoleState(ConsoleState.Connected);
+
+        await Send(new SendTokenEvent()
+        {
+            Args = { Token }
+        });
+
+        while (WebSocket.State == WebSocketState.Open)
+        {
+            try
+            {
+                var raw = await ReceiveRaw();
+                
+                if(string.IsNullOrEmpty(raw))
+                    continue;
+                
+                var eventData = JsonConvert.DeserializeObject<BaseEvent>(raw);
+
+                if (eventData == null)
+                {
+                    await SaveMessage("Unable to parse event", true);
+                    continue;
+                }
+
+                switch (eventData.Event)
+                {
+                    case "jwt error":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Received a jwt error. Disconnected", true);
+                        break;
+
+                    case "token expired":
+                        if (WebSocket != null)
+                        {
+                            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+                            WebSocket.Dispose();
+                        }
+                        
+                        await UpdateServerState(ServerState.Offline);
+                        await UpdateConsoleState(ConsoleState.Disconnected);
+
+                        await SaveMessage("Token expired", true);
+                        
+                        break;
+
+                    case "token expiring":
+                        await SaveMessage("Token will expire soon. Generating a new one", true);
+
+                        Token = await OnRequestNewToken.Invoke(this);
+
+                        await Send(new SendTokenEvent()
+                        {
+                            Args = { Token }
+                        });
+                        break;
+
+                    case "auth success":
+                        // Send intents
+                        await SendRaw("{\"event\":\"send logs\",\"args\":[null]}");
+                        await SendRaw("{\"event\":\"send stats\",\"args\":[null]}");
+                        break;
+
+                    case "stats":
+                        var stats = JsonConvert.DeserializeObject<ServerResource>(eventData.Args[0]);
+
+                        if (stats == null)
+                            break;
+
+                        var serverState = ParseServerState(stats.State);
+
+                        if (ServerState != serverState)
+                            await UpdateServerState(serverState);
+
+                        await UpdateResource(stats);
+                        break;
+
+                    case "status":
+                        var serverStateParsed = ParseServerState(eventData.Args[0]);
+
+                        if (ServerState != serverStateParsed)
+                            await UpdateServerState(serverStateParsed);
+                        break;
+
+                    case "console output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install output":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "daemon message":
+                        foreach (var line in eventData.Args)
+                        {
+                            await SaveMessage(line);
+                        }
+
+                        break;
+
+                    case "install started":
+                        await UpdateServerState(ServerState.Installing);
+                        break;
+
+                    case "install completed":
+                        await UpdateServerState(ServerState.Offline);
+                        break;
+                }
+            }
+            catch(JsonReaderException){}
+            catch (Exception e)
+            {
+                if (!Disconnecting)
+                {
+                    Logger.Warn("Error while performing websocket actions");
+                    Logger.Warn(e);
+
+                    await SaveMessage("A unknown error occured while processing websocket", true);
+                }
+            }
+        }
+    }
+
+    private Task UpdateConsoleState(ConsoleState consoleState)
+    {
+        ConsoleState = consoleState;
+        OnConsoleStateUpdated?.Invoke(this, consoleState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateServerState(ServerState serverState)
+    {
+        ServerState = serverState;
+        OnServerStateUpdated?.Invoke(this, serverState);
+
+        return Task.CompletedTask;
+    }
+    private Task UpdateResource(ServerResource resource)
+    {
+        Resource = resource;
+        OnResourceUpdated?.Invoke(this, Resource);
+
+        return Task.CompletedTask;
+    }
+
+    private Task SaveMessage(string content, bool internalMessage = false)
+    {
+        var msg = new ConsoleMessage()
+        {
+            Content = content,
+            IsInternal = internalMessage
+        };
+
+        lock (Messages)
+        {
+            Messages.Add(msg);
+        }
+
+        OnMessage?.Invoke(this, msg);
+
+        return Task.CompletedTask;
+    }
+    
+    private ServerState ParseServerState(string raw)
+    {
+        switch (raw)
+        {
+            case "offline":
+                return ServerState.Offline;
+            case "starting":
+                return ServerState.Starting;
+            case "running":
+                return ServerState.Running;
+            case "stopping":
+                return ServerState.Stopping;
+            case "installing":
+                return ServerState.Installing;
+            default:
+                return ServerState.Offline;
+        }
+    }
+    
+    public async Task EnterCommand(string content)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"send command\",\"args\":[\"" + content + "\"]}");
+        }
+    }
+
+    public async Task SetPowerState(string state)
+    {
+        if (ConsoleState == ConsoleState.Connected)
+        {
+            await SendRaw("{\"event\":\"set state\",\"args\":[\"" + state + "\"]}");
+        }
+    }
+
+    private async Task Send(object data)
+    {
+        await SendRaw(JsonConvert.SerializeObject(data));
+    }
+    
+    private async Task SendRaw(string data)
+    {
+        if (WebSocket.State == WebSocketState.Open)
+        {
+            byte[] byteContentBuffer = Encoding.UTF8.GetBytes(data);
+            await WebSocket.SendAsync(new ArraySegment<byte>(byteContentBuffer), WebSocketMessageType.Text, true,
+                CancellationToken.None);
+        }
+    }
+
+    private async Task<string> ReceiveRaw()
+    {
+        ArraySegment<byte> receivedBytes = new ArraySegment<byte>(new byte[1024]);
+        WebSocketReceiveResult result = await WebSocket.ReceiveAsync(receivedBytes, CancellationToken.None);
+        return Encoding.UTF8.GetString(receivedBytes.Array!, 0, result.Count);
+    }
+
+    public async Task Disconnect()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                await WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None);
+            
+            WebSocket.Dispose();
+        }
+
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+
+    public void Dispose()
+    {
+        Disconnecting = true;
+        Messages.Clear();
+
+        if (WebSocket != null)
+        {
+            if (WebSocket.State == WebSocketState.Connecting || WebSocket.State == WebSocketState.Open)
+                WebSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None).Wait();
+            
+            WebSocket.Dispose();
+        }
+        
+        if(ConsoleTask != null && ConsoleTask.IsCompleted)
+            ConsoleTask.Dispose();
+    }
+}

Moonlight/App/Helpers/Wings/WingsConsoleHelper.cs

@@ -7,37 +7,34 @@ using Moonlight.App.Database.Entities;
 using Moonlight.App.Repositories.Servers;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsConsoleHelper
 {
     private readonly ServerRepository ServerRepository;
-    private readonly WingsJwtHelper WingsJwtHelper;
     private readonly string AppUrl;
 
     public WingsConsoleHelper(
         ServerRepository serverRepository,
-        ConfigService configService,
-        WingsJwtHelper wingsJwtHelper)
+        ConfigService configService)
     {
         ServerRepository = serverRepository;
-        WingsJwtHelper = wingsJwtHelper;
 
-        AppUrl = configService.GetSection("Moonlight").GetValue<string>("AppUrl");
+        AppUrl = configService.Get().Moonlight.AppUrl;
     }
 
-    public async Task ConnectWings(PteroConsole.NET.PteroConsole pteroConsole, Server server)
+    public async Task ConnectWings(WingsConsole console, Server server)
     {
         var serverData = ServerRepository
             .Get()
             .Include(x => x.Node)
             .First(x => x.Id == server.Id);
         
-        var token = GenerateToken(serverData);
+        var token = await GenerateToken(serverData);
 
         if (serverData.Node.Ssl)
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"wss://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -45,7 +42,7 @@ public class WingsConsoleHelper
         }
         else
         {
-            await pteroConsole.Connect(
+            await console.Connect(
                 AppUrl,
                 $"ws://{serverData.Node.Fqdn}:{serverData.Node.HttpPort}/api/servers/{serverData.Uuid}/ws",
                 token
@@ -53,7 +50,7 @@ public class WingsConsoleHelper
         }
     }
 
-    public string GenerateToken(Server server)
+    public async Task<string> GenerateToken(Server server)
     {
         var serverData = ServerRepository
             .Get()
@@ -66,7 +63,7 @@ public class WingsConsoleHelper
 
         using (MD5 md5 = MD5.Create())
         {
-            var inputBytes = Encoding.ASCII.GetBytes(userid + serverData.Uuid.ToString());
+            var inputBytes = Encoding.ASCII.GetBytes(userid + server.Uuid.ToString());
             var outputBytes = md5.ComputeHash(inputBytes);
 
             var identifier = Convert.ToHexString(outputBytes).ToLower();
@@ -77,7 +74,7 @@ public class WingsConsoleHelper
                 .WithAlgorithm(new HMACSHA256Algorithm())
                 .WithSecret(secret)
                 .AddClaim("user_id", userid)
-                .AddClaim("server_uuid", serverData.Uuid.ToString())
+                .AddClaim("server_uuid", server.Uuid.ToString())
                 .AddClaim("permissions", new[]
                 {
                     "*",

Moonlight/App/Helpers/Wings/WingsJwtHelper.cs

@@ -4,7 +4,7 @@ using JWT.Algorithms;
 using JWT.Builder;
 using Moonlight.App.Services;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsJwtHelper
 {
@@ -15,7 +15,7 @@ public class WingsJwtHelper
     {
         ConfigService = configService;
 
-        AppUrl = ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl");
+        AppUrl = ConfigService.Get().Moonlight.AppUrl;
     }
 
     public string Generate(string secret, Action<Dictionary<string, string>> claimsAction)

Moonlight/App/Helpers/Wings/WingsServerConverter.cs

@@ -5,7 +5,7 @@ using Moonlight.App.Http.Resources.Wings;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 
-namespace Moonlight.App.Helpers;
+namespace Moonlight.App.Helpers.Wings;
 
 public class WingsServerConverter
 {

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

@@ -0,0 +1,176 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.App.ApiClients.Wings;
+using Moonlight.App.ApiClients.Wings.Resources;
+using Moonlight.App.Database.Entities;
+using Moonlight.App.Http.Requests.DiscordBot.Requests;
+using Moonlight.App.Repositories;
+using Moonlight.App.Services;
+
+namespace Moonlight.App.Http.Controllers.Api.Moonlight;
+
+[ApiController]
+[Route("api/moonlight/discordbot")]
+public class DiscordBotController : Controller
+{
+    private readonly Repository<User> UserRepository;
+    private readonly Repository<Server> ServerRepository;
+    private readonly ServerService ServerService;
+    private readonly string Token = "";
+    private readonly bool Enable;
+
+    public DiscordBotController(
+        Repository<User> userRepository,
+        Repository<Server> serverRepository,
+        ServerService serverService,
+        ConfigService configService)
+    {
+        UserRepository = userRepository;
+        ServerRepository = serverRepository;
+        ServerService = serverService;
+
+        var config = configService
+            .Get()
+            .Moonlight.DiscordBotApi;
+
+        Enable = config.Enable;
+
+        if (Enable)
+        {
+            Token = config.Token;
+        }
+    }
+    
+    [HttpGet("{id}/link")]
+    public async Task<ActionResult> GetLink(ulong id)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        if (await GetUserFromDiscordId(id) == null)
+        {
+            return BadRequest();
+        }
+
+        return Ok();
+    }
+
+    [HttpGet("{id}/servers")]
+    public async Task<ActionResult<Server[]>> GetServers(ulong id)
+    {
+        if (!await IsAuth(Request))
+            return StatusCode(403);
+        
+        var user = await GetUserFromDiscordId(id);
+
+        if (user == null)
+            return BadRequest();
+
+        return ServerRepository
+            .Get()
+            .Include(x => x.Owner)
+            .Include(x => x.Image)
+            .Where(x => x.Owner.Id == user.Id)
+            .ToArray();
+    }
+
+    [HttpPost("{id}/servers/{uuid}")]
+    public async Task<ActionResult> SetPowerState(ulong id, Guid uuid, [FromBody] SetPowerSignal signal)
+    {
+        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)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        if (Enum.TryParse(signal.Signal, true, out PowerSignal powerSignal))
+        {
+            await ServerService.SetPowerState(server, powerSignal);
+            return Ok();
+        }
+        else
+            return BadRequest();
+    }
+
+    [HttpGet("{id}/servers/{uuid}/details")]
+    public async Task<ActionResult<ServerDetails>> GetServerDetails(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)
+            .FirstOrDefault(x => x.Owner.Id == user.Id && x.Uuid == uuid);
+
+        if (server == null)
+            return NotFound();
+
+        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)
+    {
+        var user = UserRepository
+            .Get()
+            .FirstOrDefault(x => x.DiscordId == discordId);
+
+        return Task.FromResult(user);
+    }
+
+    private Task<bool> IsAuth(HttpRequest request)
+    {
+        if (!Enable)
+            return Task.FromResult(false);
+        
+        if (string.IsNullOrEmpty(request.Headers.Authorization))
+            return Task.FromResult(false);
+        
+        if(request.Headers.Authorization == Token)
+            return Task.FromResult(true);
+        
+        return Task.FromResult(false);
+    }
+}

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 bool active = true;
-    private bool isAuth = false;
+    private WebSocket WebSocket;
     private NotificationClient Client;
+    private CancellationTokenSource CancellationTokenSource = new();
+
+    private User? CurrentUser;
 
-    private readonly IdentityService IdentityService;
-    private readonly NotificationRepository NotificationRepository;
     private readonly OneTimeJwtService OneTimeJwtService;
-    private readonly NotificationClientService NotificationClientService;
     private readonly NotificationServerService NotificationServerService;
+    private readonly Repository<NotificationClient> NotificationClientRepository;
 
-    public ListenController(IdentityService identityService, 
-        NotificationRepository notificationRepository, 
+    public ListenController(
         OneTimeJwtService oneTimeJwtService,
-        NotificationClientService notificationClientService,
-        NotificationServerService notificationServerService)
+        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();
-            ws = webSocket;
-            await Echo();
+            WebSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+
+            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]; 
-            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))
+            try
             {
-                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');
 
-            active = ws.State == WebSocketState.Open;
+                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();
+            }
         }
+
+        await NotificationServerService.UnRegisterClient(Client);
     }
 
     private async Task HandleRequest(string text, string action)
     {
-        if (!isAuth && 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)
+        if (CurrentUser == null && action != "login")
         {
+            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}";
-            var bytes = Encoding.UTF8.GetBytes(error);
-            await ws.SendAsync(bytes, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
+            await Send("{\"status\":false}");
             return;
         }
 
-        var _clientId = dict["clientId"];
-        var clientId = int.Parse(_clientId);
+        if (!int.TryParse(dict["clientId"], out int 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;
-        await InitWebsocket();
+        CurrentUser = Client.User;
 
-        string success = "{\"status\":true}";
-        var byt = Encoding.UTF8.GetBytes(success);
-        await ws.SendAsync(byt, WebSocketMessageType.Text, WebSocketMessageFlags.EndOfMessage, CancellationToken.None);
-    }
+        await NotificationServerService.RegisterClient(WebSocket, Client);
 
-    private async Task InitWebsocket()
-    {
-        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,
-            JsonConvert.SerializeObject(new NotificationById() {Action = "hide", notification = id}));
+        await NotificationServerService.SendAction(
+            CurrentUser!,
+            JsonConvert.SerializeObject(
+                new NotificationById()
+                {
+                    Action = "hide", Notification = model.Notification
+                }
+            )
+        );
     }
 }

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

@@ -1,6 +1,7 @@
-using Logging.Net;
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc;
+using Moonlight.App.Helpers;
 using Moonlight.App.Services;
+using Moonlight.App.Services.Sessions;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 
@@ -11,12 +12,41 @@ public class OAuth2Controller : Controller
     private readonly UserService UserService;
     private readonly OAuth2Service OAuth2Service;
     private readonly DateTimeService DateTimeService;
+    private readonly IdentityService IdentityService;
 
-    public OAuth2Controller(UserService userService, OAuth2Service oAuth2Service, DateTimeService dateTimeService)
+    public OAuth2Controller(
+        UserService userService,
+        OAuth2Service oAuth2Service,
+        DateTimeService dateTimeService,
+        IdentityService identityService)
     {
         UserService = userService;
         OAuth2Service = oAuth2Service;
         DateTimeService = dateTimeService;
+        IdentityService = identityService;
+    }
+
+    [HttpGet("{id}/start")]
+    public async Task<ActionResult> Start([FromRoute] string id)
+    {
+        try
+        {
+            if (OAuth2Service.Providers.ContainsKey(id))
+            {
+                return Redirect(await OAuth2Service.GetUrl(id));
+            }
+            
+            Logger.Warn($"Someone tried to start an oauth2 flow using the id '{id}' which is not registered");
+
+            return Redirect("/");
+        }
+        catch (Exception e)
+        {
+            Logger.Warn($"Error starting oauth2 flow for id: {id}");
+            Logger.Warn(e);
+            
+            return Redirect("/");
+        }
     }
 
     [HttpGet("{id}")]
@@ -24,6 +54,18 @@ public class OAuth2Controller : Controller
     {
         try
         {
+            var currentUser = await IdentityService.Get();
+
+            if (currentUser != null)
+            {
+                if (await OAuth2Service.CanBeLinked(id))
+                {
+                    await OAuth2Service.LinkToUser(id, currentUser, code);
+                    
+                    return Redirect("/profile");
+                }
+            }
+            
             var user = await OAuth2Service.HandleCode(id, code);
 
             Response.Cookies.Append("token", await UserService.GenerateToken(user), new()

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

@@ -1,10 +1,6 @@
-using Logging.Net;
-using Microsoft.AspNetCore.Mvc;
+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;
 
 namespace Moonlight.App.Http.Controllers.Api.Moonlight;
 
@@ -12,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,
-        BucketService bucketService)
+    public ResourcesController(BucketService bucketService)
     {
-        SecurityLogService = securityLogService;
         BucketService = bucketService;
     }
 
@@ -27,10 +20,7 @@ public class ResourcesController : Controller
     {
         if (name.Contains(".."))
         {
-            await SecurityLogService.Log(SecurityLogType.PathTransversal, x =>
-            {
-                x.Add<string>(name);
-            });
+            Logger.Warn($"Detected an attempted path transversal. Path: {name}", "security");
             
             return NotFound();
         }
@@ -45,15 +35,32 @@ 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 =>
-            {
-                x.Add<string>(name);
-            });
+            Logger.Warn($"Detected an attempted path transversal. Path: {name}", "security");
             
             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/Http/Controllers/Api/Remote/ServersController.cs

@@ -2,6 +2,7 @@
 using Microsoft.EntityFrameworkCore;
 using Moonlight.App.Events;
 using Moonlight.App.Helpers;
+using Moonlight.App.Helpers.Wings;
 using Moonlight.App.Http.Resources.Wings;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;

Moonlight/App/Http/Requests/DiscordBot/Requests/SetPowerSignal.cs

@@ -0,0 +1,8 @@
+using Moonlight.App.ApiClients.Wings;
+
+namespace Moonlight.App.Http.Requests.DiscordBot.Requests;
+
+public class SetPowerSignal
+{
+    public string Signal { get; set; }
+}

Moonlight/App/LogMigrator/LogMigrator.cs

@@ -1,5 +1,4 @@
-using Logging.Net;
-using ILogger = Microsoft.Extensions.Logging.ILogger;
+using Moonlight.App.Helpers;
 
 namespace Moonlight.App.LogMigrator;
 
@@ -28,19 +27,39 @@ public class LogMigrator : ILogger
         switch (logLevel)
         {
             case LogLevel.Critical:
-                Logger.Fatal($"[{Name}] {formatter(state, exception)}");
+                Logger.Fatal(formatter(state, exception));
+                
+                if(exception != null)
+                    Logger.Fatal(exception);
+                
                 break;
             case LogLevel.Warning:
-                Logger.Warn($"[{Name}] {formatter(state, exception)}");
+                Logger.Warn(formatter(state, exception));
+                
+                if(exception != null)
+                    Logger.Warn(exception);
+                
                 break;
             case LogLevel.Debug:
-                Logger.Debug($"[{Name}] {formatter(state, exception)}");
+                Logger.Debug(formatter(state, exception));
+                
+                if(exception != null)
+                    Logger.Debug(exception);
+                
                 break;
             case LogLevel.Error:
-                Logger.Error($"[{Name}] {formatter(state, exception)}");
+                Logger.Error(formatter(state, exception));
+                
+                if(exception != null)
+                    Logger.Error(exception);
+                
                 break;
             case LogLevel.Information:
-                Logger.Info($"[{Name}] {formatter(state, exception)}");
+                Logger.Info(formatter(state, exception));
+                
+                if(exception != null)
+                    Logger.Info(exception);
+                
                 break;
         }
     }

Moonlight/App/LogMigrator/SentryDiagnosticsLogger.cs

@@ -0,0 +1,71 @@
+using Moonlight.App.Helpers;
+using Sentry;
+using Sentry.Extensibility;
+
+namespace Moonlight.App.LogMigrator;
+
+public class SentryDiagnosticsLogger : IDiagnosticLogger
+{
+    private readonly SentryLevel Level;
+
+    public SentryDiagnosticsLogger(SentryLevel level)
+    {
+        Level = level;
+    }
+
+    public bool IsEnabled(SentryLevel level)
+    {
+        if ((int)level >= (int)Level)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    public void Log(SentryLevel logLevel, string message, Exception? exception = null, params object?[] args)
+    {
+        switch (logLevel)
+        {
+            case SentryLevel.Debug:
+                Logger.Debug(string.Format(message, args));
+                
+                if(exception != null)
+                    Logger.Debug(exception);
+                
+                break;
+            
+            case SentryLevel.Info:
+                Logger.Info(string.Format(message, args));
+                
+                if(exception != null)
+                    Logger.Info(exception);
+                
+                break;
+            
+            case SentryLevel.Warning:
+                Logger.Warn(string.Format(message, args));
+                
+                if(exception != null)
+                    Logger.Warn(exception);
+                
+                break;
+            
+            case SentryLevel.Error:
+                Logger.Error(string.Format(message, args));
+                
+                if(exception != null)
+                    Logger.Error(exception);
+                
+                break;
+            
+            case SentryLevel.Fatal:
+                Logger.Fatal(string.Format(message, args));
+                
+                if(exception != null)
+                    Logger.Fatal(exception);
+                
+                break;
+        }
+    }
+}

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/Forms/UserPreferencesDataModel.cs

@@ -0,0 +1,6 @@
+namespace Moonlight.App.Models.Forms;
+
+public class UserPreferencesDataModel
+{
+    public bool StreamerMode { get; set; } = false;
+}

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/Misc/RunningServer.cs

@@ -6,5 +6,5 @@ namespace Moonlight.App.Models.Misc;
 public class RunningServer
 {
     public Server Server { get; set; }
-    public ContainerStats.Container Container { get; set; }
+    public Container Container { get; set; }
 }

Moonlight/App/Models/Misc/ServerGroup.cs

@@ -0,0 +1,7 @@
+namespace Moonlight.App.Models.Misc;
+
+public class ServerGroup
+{
+    public string Name { get; set; } = "";
+    public List<string> Servers { get; set; } = new();
+}

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/OAuth2Provider.cs

@@ -9,7 +9,9 @@ public abstract class OAuth2Provider
     public string Url { get; set; }
     public IServiceScopeFactory ServiceScopeFactory { get; set; }
     public string DisplayName { get; set; }
+    public bool CanBeLinked { get; set; } = false;
     
     public abstract Task<string> GetUrl();
     public abstract Task<User> HandleCode(string code);
+    public abstract Task LinkToUser(User user, string code);
 }

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;
@@ -12,6 +11,11 @@ namespace Moonlight.App.OAuth2.Providers;
 
 public class DiscordOAuth2Provider : OAuth2Provider
 {
+    public DiscordOAuth2Provider()
+    {
+        CanBeLinked = true;
+    }
+    
     public override Task<string> GetUrl()
     {
         string url = $"https://discord.com/api/oauth2/authorize?client_id={Config.ClientId}" +
@@ -82,6 +86,13 @@ public class DiscordOAuth2Provider : OAuth2Provider
 
         var email = getData.GetValue<string>("email");
         var id = getData.GetValue<ulong>("id");
+        var verified = getData.GetValue<bool>("verified");
+
+        if (!verified)
+        {
+            Logger.Warn("A user tried to use an unverified discord account to login", "security");
+            throw new DisplayException("You can only use verified discord accounts for oauth signin");
+        }
         
         // Handle data
         
@@ -119,4 +130,74 @@ public class DiscordOAuth2Provider : OAuth2Provider
             return user;
         }
     }
+
+    public override async Task LinkToUser(User user, string code)
+    {
+        // Endpoints
+        
+        var endpoint = Url + "/api/moonlight/oauth2/discord";
+        var discordUserDataEndpoint = "https://discordapp.com/api/users/@me";
+        var discordEndpoint = "https://discordapp.com/api/oauth2/token";
+
+        // Generate access token
+        
+        using var client = new RestClient();
+        var request = new RestRequest(discordEndpoint);
+
+        request.AddParameter("client_id", Config.ClientId);
+        request.AddParameter("client_secret", Config.ClientSecret);
+        request.AddParameter("grant_type", "authorization_code");
+        request.AddParameter("code", code);
+        request.AddParameter("redirect_uri", endpoint);
+        
+        var response = await client.ExecutePostAsync(request);
+
+        if (!response.IsSuccessful)
+        {
+            Logger.Warn("Error verifying oauth2 code");
+            Logger.Warn(response.ErrorMessage);
+            throw new DisplayException("An error occured while verifying oauth2 code");
+        }
+        
+        // parse response
+        
+        var data = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(response.Content!))
+        ).Build();
+
+        var accessToken = data.GetValue<string>("access_token");
+        
+        // Now, we will call the discord api with our access token to get the data we need
+
+        var getRequest = new RestRequest(discordUserDataEndpoint);
+        getRequest.AddHeader("Authorization", $"Bearer {accessToken}");
+
+        var getResponse = await client.ExecuteGetAsync(getRequest);
+        
+        if (!getResponse.IsSuccessful)
+        {
+            Logger.Warn("An unexpected error occured while fetching user data from remote api");
+            Logger.Warn(getResponse.ErrorMessage);
+            
+            throw new DisplayException("An unexpected error occured while fetching user data from remote api");
+        }
+        
+        // Parse response
+        
+        var getData = new ConfigurationBuilder().AddJsonStream(
+            new MemoryStream(Encoding.ASCII.GetBytes(getResponse.Content!))
+        ).Build();
+
+        var id = getData.GetValue<ulong>("id");
+        
+        // Handle data
+        
+        using var scope = ServiceScopeFactory.CreateScope();
+        
+        var userRepo = scope.ServiceProvider.GetRequiredService<Repository<User>>();
+
+        user.DiscordId = id;
+        
+        userRepo.Update(user);
+    }
 }

Moonlight/App/OAuth2/Providers/GoogleOAuth2Provider.cs

@@ -1,10 +1,8 @@
 using System.Text;
-using Logging.Net;
 using Moonlight.App.ApiClients.Google.Requests;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Exceptions;
 using Moonlight.App.Helpers;
-using Moonlight.App.Models.Misc;
 using Moonlight.App.Repositories;
 using Moonlight.App.Services;
 using RestSharp;
@@ -13,6 +11,11 @@ namespace Moonlight.App.OAuth2.Providers;
 
 public class GoogleOAuth2Provider : OAuth2Provider
 {
+    public GoogleOAuth2Provider()
+    {
+        CanBeLinked = false;
+    }
+    
     public override Task<string> GetUrl()
     {
         var endpoint = Url + "/api/moonlight/oauth2/google";
@@ -127,4 +130,9 @@ public class GoogleOAuth2Provider : OAuth2Provider
             return user;
         }
     }
+
+    public override Task LinkToUser(User user, string code)
+    {
+        throw new NotImplementedException();
+    }
 }

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,10 +1,10 @@
-using Logging.Net;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
 using MineStatLib;
 using Moonlight.App.ApiClients.Daemon.Resources;
 using Moonlight.App.ApiClients.Wings;
 using Moonlight.App.Database.Entities;
 using Moonlight.App.Events;
+using Moonlight.App.Helpers;
 using Moonlight.App.Repositories;
 using Moonlight.App.Repositories.Servers;
 using Newtonsoft.Json;
@@ -43,15 +43,15 @@ public class CleanupService
         CompletedAt = DateTimeService.GetCurrent();
         IsRunning = false;
 
-        var config = ConfigService.GetSection("Moonlight").GetSection("Cleanup");
+        var config = ConfigService.Get().Moonlight.Cleanup;
 
-        if (!config.GetValue<bool>("Enable") || ConfigService.DebugMode)
+        if (!config.Enable || ConfigService.DebugMode)
         {
             Logger.Info("Disabling cleanup service");
             return;
         }
         
-        Timer = new(TimeSpan.FromMinutes(config.GetValue<int>("Wait")));
+        Timer = new(TimeSpan.FromMinutes(config.Wait));
 
         Task.Run(Run);
     }
@@ -63,12 +63,12 @@ public class CleanupService
             IsRunning = true;
             
             using var scope = ServiceScopeFactory.CreateScope();
-            var config = ConfigService.GetSection("Moonlight").GetSection("Cleanup");
+            var config = ConfigService.Get().Moonlight.Cleanup;
 
-            var maxCpu = config.GetValue<int>("Cpu");
-            var minMemory = config.GetValue<int>("Memory");
-            var maxUptime = config.GetValue<int>("Uptime");
-            var minUptime = config.GetValue<int>("MinUptime");
+            var maxCpu = config.Cpu;
+            var minMemory = config.Memory;
+            var maxUptime = config.Uptime;
+            var minUptime = config.MinUptime;
 
             var nodeRepository = scope.ServiceProvider.GetRequiredService<NodeRepository>();
             var nodeService = scope.ServiceProvider.GetRequiredService<NodeService>();
@@ -81,12 +81,35 @@ public class CleanupService
             {
                 try
                 {
-                    var cpuStats = await nodeService.GetCpuStats(node);
-                    var memoryStats = await nodeService.GetMemoryStats(node);
+                    var cpuMetrics = await nodeService.GetCpuMetrics(node);
+                    var memoryMetrics = await nodeService.GetMemoryMetrics(node);
 
-                    if (cpuStats.Usage > maxCpu || memoryStats.Free < minMemory)
+                    bool executeCleanup;
+                    
+                    if (cpuMetrics.CpuUsage > maxCpu)
                     {
-                        var containerStats = await nodeService.GetContainerStats(node);
+                        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);
 
                         var serverRepository = scope.ServiceProvider.GetRequiredService<ServerRepository>();
                         var imageRepository = scope.ServiceProvider.GetRequiredService<ImageRepository>();
@@ -101,9 +124,9 @@ public class CleanupService
                             )
                             .ToArray();
                         
-                        var containerMappedToServers = new Dictionary<ContainerStats.Container, Server>();
+                        var containerMappedToServers = new Dictionary<Container, Server>();
 
-                        foreach (var container in containerStats.Containers)
+                        foreach (var container in dockerMetrics.Containers)
                         {
                             if (Guid.TryParse(container.Name, out Guid uuid))
                             {
@@ -139,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++;
@@ -164,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;
@@ -22,14 +22,14 @@ public class DiscordNotificationService
         Event = eventSystem;
         ResourceService = resourceService;
 
-        var config = configService.GetSection("Moonlight").GetSection("DiscordNotifications");
+        var config = configService.Get().Moonlight.DiscordNotifications;
 
-        if (config.GetValue<bool>("Enable"))
+        if (config.Enable)
         {
             Logger.Info("Discord notifications enabled");
             
-            Client = new(config.GetValue<string>("WebHook"));
-            AppUrl = configService.GetSection("Moonlight").GetValue<string>("AppUrl");
+            Client = new(config.WebHook);
+            AppUrl = configService.Get().Moonlight.AppUrl;
 
             Event.On<User>("supportChat.new", this, OnNewSupportChat);
             Event.On<SupportChatMessage>("supportChat.message", this, OnSupportChatMessage);

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,16 +1,14 @@
-using System.Text;
-using Logging.Net;
-using Microsoft.Extensions.Primitives;
+using Moonlight.App.Configuration;
 using Moonlight.App.Helpers;
 using Moonlight.App.Services.Files;
+using Newtonsoft.Json;
 
 namespace Moonlight.App.Services;
 
-public class ConfigService : IConfiguration
+public class ConfigService
 {
     private readonly StorageService StorageService;
-
-    private IConfiguration Configuration;
+    private ConfigV1 Configuration;
 
     public bool DebugMode { get; private set; } = false;
     public bool SqlDebugMode { get; private set; } = false;
@@ -42,37 +40,22 @@ public class ConfigService : IConfiguration
 
     public void Reload()
     {
-        Logger.Info($"Reading config from '{PathBuilder.File("storage", "configs", "config.json")}'");
+        var path = PathBuilder.File("storage", "configs", "config.json");
         
-        Configuration = new ConfigurationBuilder().AddJsonStream(
-            new MemoryStream(Encoding.ASCII.GetBytes(
-                    File.ReadAllText(
-                        PathBuilder.File("storage", "configs", "config.json")
-                    )
-                )
-            )).Build();
+        if (!File.Exists(path))
+        {
+            File.WriteAllText(path, "{}");
+        }
 
-        Logger.Info("Reloaded configuration file");
+        Configuration = JsonConvert.DeserializeObject<ConfigV1>(
+            File.ReadAllText(path)
+        ) ?? new ConfigV1();
+        
+        File.WriteAllText(path, JsonConvert.SerializeObject(Configuration));
     }
 
-    public IEnumerable<IConfigurationSection> GetChildren()
+    public ConfigV1 Get()
     {
-        return Configuration.GetChildren();
-    }
-
-    public IChangeToken GetReloadToken()
-    {
-        return Configuration.GetReloadToken();
-    }
-
-    public IConfigurationSection GetSection(string key)
-    {
-        return Configuration.GetSection(key);
-    }
-
-    public string this[string key]
-    {
-        get => Configuration[key];
-        set => Configuration[key] = value;
+        return Configuration;
     }
 }

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;
@@ -30,7 +29,7 @@ public class ServerListCommand : BaseModule
         {
             embed = dcs.EmbedBuilderModule.StandardEmbed("Sorry ;( \n Please first create and/or link a Account to Discord! \n Press the Button to register/log in.", Color.Red, command.User);
             components = new ComponentBuilder();
-            components.WithButton("Click Here", style: ButtonStyle.Link, url: ConfigService.GetSection("Moonlight").GetValue<String>("AppUrl"));
+            components.WithButton("Click Here", style: ButtonStyle.Link, url: ConfigService.Get().Moonlight.AppUrl);
         
             await command.RespondAsync(embed: embed.Build(), components: components.Build(), ephemeral: true);
             return;
@@ -58,7 +57,7 @@ public class ServerListCommand : BaseModule
         components.WithButton("Panel",
             emote: Emote.Parse("<a:Earth:1092814004113657927>"),
             style: ButtonStyle.Link,
-            url: $"{ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl")}");
+            url: $"{ConfigService.Get().Moonlight.AppUrl}");
         
         if (servers.Count > 25)
         {

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;
 
@@ -45,10 +44,10 @@ public DiscordBotService(
         ServiceScope = ServiceScopeFactory.CreateScope();
 
         var discordConfig = ConfigService
-            .GetSection("Moonlight")
-            .GetSection("DiscordBot");
+            .Get()
+            .Moonlight.DiscordBot;
 
-        if (!discordConfig.GetValue<bool>("Enable"))
+        if (!discordConfig.Enable)
             return;
 
         Client.Log += Log;
@@ -68,7 +67,7 @@ public DiscordBotService(
 
         await ActivityStatusModule.UpdateActivityStatusList();
 
-        await Client.LoginAsync(TokenType.Bot, discordConfig.GetValue<string>("Token"));
+        await Client.LoginAsync(TokenType.Bot, discordConfig.Token);
         await Client.StartAsync();
 
         await Task.Delay(-1);

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

@@ -87,8 +87,8 @@ public class EmbedBuilderModule : BaseModule
         int[] randomNumbers = new int[] { 1, 3, 8, 11, 20 };
         
         if (randomNumbers.Contains(random.Next(1, 24)))
-            return new EmbedAuthorBuilder().WithName(Client.CurrentUser.Username + " - The Rick version").WithUrl(ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl")).WithIconUrl("https://cdn.discordapp.com/attachments/750696464014901268/1092783310129860618/rick.gif");
+            return new EmbedAuthorBuilder().WithName(Client.CurrentUser.Username + " - The Rick version").WithUrl(ConfigService.Get().Moonlight.AppUrl).WithIconUrl("https://cdn.discordapp.com/attachments/750696464014901268/1092783310129860618/rick.gif");
         
-        return new EmbedAuthorBuilder().WithName(Client.CurrentUser.Username).WithUrl(ConfigService.GetSection("Moonlight").GetValue<string>("AppUrl")).WithIconUrl(Client.CurrentUser.GetAvatarUrl());
+        return new EmbedAuthorBuilder().WithName(Client.CurrentUser.Username).WithUrl(ConfigService.Get().Moonlight.AppUrl).WithIconUrl(Client.CurrentUser.GetAvatarUrl());
     }
 }