Improved CancellationToken usage, Added more logging to Workers, Added Code-comments (please future me, be thankful)

2025-09-10 11:58:19 +02:00 · 2025-09-02 19:36:06 +02:00
parent 6fa166363a
commit 55f04710a7
16 changed files with 235 additions and 121 deletions
--- a/API/Workers/BaseWorker.cs
+++ b/API/Workers/BaseWorker.cs
@@ -26,7 +26,8 @@ public abstract class BaseWorker : Identifiable
    public IEnumerable<BaseWorker> MissingDependencies => DependsOn.Where(d => d.State < WorkerExecutionState.Completed);
    public bool AllDependenciesFulfilled => DependsOn.All(d => d.State >= WorkerExecutionState.Completed);
    internal WorkerExecutionState State { get; private set; }
-    protected CancellationTokenSource CancellationTokenSource = new ();
+    private CancellationTokenSource _cancellationTokenSource = new ();
+    protected CancellationToken CancellationToken => _cancellationTokenSource.Token;
    protected ILog Log { get; init; }

    /// <summary>
@@ -36,7 +37,7 @@ public abstract class BaseWorker : Identifiable
    {
        Log.Debug($"Cancelled {this}");
        this.State = WorkerExecutionState.Cancelled;
-        CancellationTokenSource.Cancel();
+        _cancellationTokenSource.Cancel();
    }

    /// <summary>
@@ -46,7 +47,7 @@ public abstract class BaseWorker : Identifiable
    {
        Log.Debug($"Failed {this}");
        this.State = WorkerExecutionState.Failed;
-        CancellationTokenSource.Cancel();
+        _cancellationTokenSource.Cancel();
    }

    public BaseWorker(IEnumerable<BaseWorker>? dependsOn = null)
@@ -75,7 +76,7 @@ public abstract class BaseWorker : Identifiable
    {
        // Start the worker
        Log.Debug($"Checking {this}");
-        this.CancellationTokenSource = new(TimeSpan.FromMinutes(10));
+        this._cancellationTokenSource = new(TimeSpan.FromMinutes(10));
        this.State = WorkerExecutionState.Waiting;
        
        // Wait for dependencies, start them if necessary
@@ -111,7 +112,7 @@ public abstract class BaseWorker : Identifiable
    private BaseWorker[] WaitForDependencies()
    {
        Log.Info($"Waiting for {MissingDependencies.Count()} Dependencies {this}:\n\t{string.Join("\n\t", MissingDependencies.Select(d => d.ToString()))}");
-        while (CancellationTokenSource.IsCancellationRequested == false && MissingDependencies.Any())
+        while (_cancellationTokenSource.IsCancellationRequested == false && MissingDependencies.Any())
        {
            Thread.Sleep(Tranga.Settings.WorkCycleTimeoutMs);  
        }
--- a/API/Workers/MangaDownloadWorkers/DownloadChapterFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/DownloadChapterFromMangaconnectorWorker.cs
@@ -13,28 +13,41 @@ using static System.IO.UnixFileMode;

 namespace API.Workers;

+/// <summary>
+/// Downloads single chapter for Manga from Mangaconnector
+/// </summary>
+/// <param name="chId"></param>
+/// <param name="dependsOn"></param>
 public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> chId, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn)
 {
    internal readonly string MangaConnectorIdId = chId.Key;
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        if(await DbContext.MangaConnectorToChapter.FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationTokenSource.Token) is not { } mangaConnectorId)
+        Log.Debug($"Downloading chapter for MangaConnectorId {MangaConnectorIdId}...");
+        // Getting MangaConnector info
+        if (await DbContext.MangaConnectorToChapter
+                .Include(id => id.Obj)
+                .ThenInclude(c => c.ParentManga)
+                .ThenInclude(m => m.Library)
+                .FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
+        {
+            Log.Error("Could not get MangaConnectorId.");
            return []; //TODO Exception?
+        }
        if (!Tranga.TryGetMangaConnector(mangaConnectorId.MangaConnectorName, out MangaConnector? mangaConnector))
+        {
+            Log.Error("Could not get MangaConnector.");
            return []; //TODO Exception?
+        }
+        Log.Debug($"Downloading chapter for MangaConnectorId {mangaConnectorId}...");
        
-        await DbContext.Entry(mangaConnectorId).Navigation(nameof(MangaConnectorId<Chapter>.Obj)).LoadAsync(CancellationTokenSource.Token);
        Chapter chapter = mangaConnectorId.Obj;
        if (chapter.Downloaded)
        {
            Log.Info("Chapter was already downloaded.");
            return [];
        }
-        
-        await DbContext.Entry(chapter).Navigation(nameof(Chapter.ParentManga)).LoadAsync(CancellationTokenSource.Token);
-        await DbContext.Entry(chapter.ParentManga).Navigation(nameof(Manga.Library)).LoadAsync(CancellationTokenSource.Token);
-
        if (chapter.ParentManga.LibraryId is null)
        {
            Log.Info($"Library is not set for {chapter.ParentManga} {chapter}");
@@ -97,9 +110,8 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        
        Log.Debug($"Creating ComicInfo.xml {chapter}");
        foreach (CollectionEntry collectionEntry in DbContext.Entry(chapter.ParentManga).Collections)
-            await collectionEntry.LoadAsync(CancellationTokenSource.Token);
-        await DbContext.Entry(chapter.ParentManga).Navigation(nameof(Manga.Library)).LoadAsync(CancellationTokenSource.Token);
-        await File.WriteAllTextAsync(Path.Join(tempFolder, "ComicInfo.xml"), chapter.GetComicInfoXmlString(), CancellationTokenSource.Token);
+            await collectionEntry.LoadAsync(CancellationToken);
+        await File.WriteAllTextAsync(Path.Join(tempFolder, "ComicInfo.xml"), chapter.GetComicInfoXmlString(), CancellationToken);
        
        Log.Debug($"Packaging images to archive {chapter}");
        //ZIP-it and ship-it
@@ -107,9 +119,12 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            File.SetUnixFileMode(saveArchiveFilePath, UserRead | UserWrite | UserExecute | GroupRead | GroupWrite | GroupExecute | OtherRead | OtherExecute);
        Directory.Delete(tempFolder, true); //Cleanup
+
+        DbContext.Entry(chapter).Property(c => c.Downloaded).CurrentValue = true;
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
        
-        chapter.Downloaded = true;
-        await DbContext.Sync(CancellationTokenSource.Token);
+        Log.Debug($"Downloaded chapter {chapter}.");

        return [];
    }
@@ -164,7 +179,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        }
        
        //TODO MangaConnector Selection
-        await DbContext.Entry(manga).Collection(m => m.MangaConnectorIds).LoadAsync(CancellationTokenSource.Token);
+        await DbContext.Entry(manga).Collection(m => m.MangaConnectorIds).LoadAsync(CancellationToken);
        MangaConnectorId<Manga> mangaConnectorId = manga.MangaConnectorIds.First();
        if (!Tranga.TryGetMangaConnector(mangaConnectorId.MangaConnectorName, out MangaConnector? mangaConnector))
        {
@@ -173,7 +188,7 @@ public class DownloadChapterFromMangaconnectorWorker(MangaConnectorId<Chapter> c
        }

        Log.Info($"Copying cover to {publicationFolder}");
-        await DbContext.Entry(mangaConnectorId).Navigation(nameof(MangaConnectorId<Manga>.Obj)).LoadAsync(CancellationTokenSource.Token);
+        await DbContext.Entry(mangaConnectorId).Navigation(nameof(MangaConnectorId<Manga>.Obj)).LoadAsync(CancellationToken);
        string? fileInCache = manga.CoverFileNameInCache ?? mangaConnector.SaveCoverImageToCache(mangaConnectorId);
        if (fileInCache is null)
        {
--- a/API/Workers/MangaDownloadWorkers/DownloadCoverFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/DownloadCoverFromMangaconnectorWorker.cs
@@ -4,23 +4,42 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Downloads the cover for Manga from Mangaconnector
+/// </summary>
 public class DownloadCoverFromMangaconnectorWorker(MangaConnectorId<Manga> mcId, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn)
 {
    internal readonly string MangaConnectorIdId = mcId.Key;
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        if (await DbContext.MangaConnectorToManga.FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId) is not { } mangaConnectorId)
+        Log.Debug($"Getting Cover for MangaConnectorId {MangaConnectorIdId}...");
+        // Getting MangaConnector info
+        if (await DbContext.MangaConnectorToManga
+                .Include(id => id.Obj)
+                .FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
+        {
+            Log.Error("Could not get MangaConnectorId.");
            return []; //TODO Exception?
+        }
        if (!Tranga.TryGetMangaConnector(mangaConnectorId.MangaConnectorName, out MangaConnector? mangaConnector))
+        {
+            Log.Error("Could not get MangaConnector.");
            return []; //TODO Exception?
-        
-        await DbContext.Entry(mangaConnectorId).Navigation(nameof(MangaConnectorId<Manga>.Obj)).LoadAsync(CancellationTokenSource.Token);
-        Manga manga = mangaConnectorId.Obj;
-        
-        manga.CoverFileNameInCache = mangaConnector.SaveCoverImageToCache(mangaConnectorId);
+        }
+        Log.Debug($"Getting Cover for MangaConnectorId {mangaConnectorId}...");

-        await DbContext.Sync(CancellationTokenSource.Token);
+        string? coverFileName = mangaConnector.SaveCoverImageToCache(mangaConnectorId);
+        if (coverFileName is null)
+        {
+            Log.Error($"Could not get Cover for MangaConnectorId {mangaConnectorId}.");
+            return [];
+        }
+        DbContext.Entry(mangaConnectorId.Obj).Property(m => m.CoverFileNameInCache).CurrentValue = coverFileName;
+
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        
        return [];
    }
    
--- a/API/Workers/MangaDownloadWorkers/RetrieveMangaChaptersFromMangaconnectorWorker.cs
+++ b/API/Workers/MangaDownloadWorkers/RetrieveMangaChaptersFromMangaconnectorWorker.cs
@@ -4,35 +4,51 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Retrieves the metadata of available chapters on the Mangaconnector
+/// </summary>
+/// <param name="mcId"></param>
+/// <param name="language"></param>
+/// <param name="dependsOn"></param>
 public class RetrieveMangaChaptersFromMangaconnectorWorker(MangaConnectorId<Manga> mcId, string language, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn)
 {
    internal readonly string MangaConnectorIdId = mcId.Key;
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        if (await DbContext.MangaConnectorToManga.FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId) is not { } mangaConnectorId)
+        Log.Debug($"Getting Chapters for MangaConnectorId {MangaConnectorIdId}...");
+        // Getting MangaConnector info
+        if (await DbContext.MangaConnectorToManga
+                .Include(id => id.Obj)
+                .FirstOrDefaultAsync(c => c.Key == MangaConnectorIdId, CancellationToken) is not { } mangaConnectorId)
+        {
+            Log.Error("Could not get MangaConnectorId.");
            return []; //TODO Exception?
+        }
        if (!Tranga.TryGetMangaConnector(mangaConnectorId.MangaConnectorName, out MangaConnector? mangaConnector))
+        {
+            Log.Error("Could not get MangaConnector.");
            return []; //TODO Exception?
+        }
+        Log.Debug($"Getting Chapters for MangaConnectorId {mangaConnectorId}...");
        
-        await DbContext.Entry(mangaConnectorId).Navigation(nameof(MangaConnectorId<Manga>.Obj)).LoadAsync(CancellationTokenSource.Token);
        Manga manga = mangaConnectorId.Obj;
-        await DbContext.Entry(manga).Collection(m => m.Chapters).LoadAsync(CancellationTokenSource.Token);
+        // Load existing Chapters (in database)
+        await DbContext.Entry(manga).Collection(m => m.Chapters).LoadAsync(CancellationToken);
        
        // This gets all chapters that are not downloaded
-        (Chapter, MangaConnectorId<Chapter>)[] allChapters =
+        (Chapter chapter, MangaConnectorId<Chapter> chapterId)[] allChapters =
            mangaConnector.GetChapters(mangaConnectorId, language).DistinctBy(c => c.Item1.Key).ToArray();
+        
+        int beforeAmount = manga.Chapters.Count;
+        Log.Debug($"Got {allChapters.Length} chapters from connector.");
+        DbContext.Entry(manga).Collection(m => m.Chapters).CurrentValue = manga.Chapters.UnionBy(allChapters.Select(c => c.chapter), c => c.Key);
+        int afterAmount = manga.Chapters.Count;
+        
+        Log.Debug($"Got {afterAmount} new chapters.");

-        int addedChapters = 0;
-        foreach ((Chapter chapter, MangaConnectorId<Chapter> mcId) newChapter in allChapters)
-        {
-            if (Tranga.AddChapterToContext(newChapter, DbContext, out Chapter? addedChapter, CancellationTokenSource.Token) == false)
-                continue;
-            manga.Chapters.Add(addedChapter);
-        }
-        Log.Info($"{manga.Chapters.Count} existing + {addedChapters} new chapters.");
-
-        await DbContext.Sync(CancellationTokenSource.Token);
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");

        return [];
    }
--- a/API/Workers/MoveMangaLibraryWorker.cs
+++ b/API/Workers/MoveMangaLibraryWorker.cs
@@ -3,6 +3,9 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Moves a Manga to a different Library
+/// </summary>
 public class MoveMangaLibraryWorker(Manga manga, FileLibrary toLibrary, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn)
 {
@@ -10,20 +13,32 @@ public class MoveMangaLibraryWorker(Manga manga, FileLibrary toLibrary, IEnumera
    internal readonly string LibraryId = toLibrary.Key;
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        if (await DbContext.Mangas.FirstOrDefaultAsync(m => m.Key == MangaId, CancellationTokenSource.Token) is not { } manga)
+        Log.Debug("Moving Manga...");
+        // Get Manga (with Chapters and Library)
+        if (await DbContext.Mangas
+                .Include(m => m.Chapters)
+                .Include(m => m.Library)
+                .FirstOrDefaultAsync(m => m.Key == MangaId, CancellationToken) is not { } manga)
+        {
+            Log.Error("Could not find Manga.");
            return []; //TODO Exception?
-        if (await DbContext.FileLibraries.FirstOrDefaultAsync(l => l.Key == LibraryId, CancellationTokenSource.Token) is not { } toLibrary)
+        }
+        // Get new Library
+        if (await DbContext.FileLibraries.FirstOrDefaultAsync(l => l.Key == LibraryId, CancellationToken) is not { } toLibrary)
+        {
+            Log.Error("Could not find Library.");
            return []; //TODO Exception?
+        }
        
-        await DbContext.Entry(manga).Collection(m => m.Chapters).LoadAsync(CancellationTokenSource.Token);
-        await DbContext.Entry(manga).Navigation(nameof(Manga.Library)).LoadAsync(CancellationTokenSource.Token);
-        
+        // Save old Path (to later move chapters)
        Dictionary<Chapter, string> oldPath = manga.Chapters.ToDictionary(c => c, c => c.FullArchiveFilePath);
-        manga.Library = toLibrary;
-
-        if (await DbContext.Sync(CancellationTokenSource.Token) is { success: false })
+        // Set new Path
+        DbContext.Entry(manga).Property(m => m.Library).CurrentValue = toLibrary;
+        
+        if (await DbContext.Sync(CancellationToken) is { success: false })
            return [];

+        // Create Jobs to move chapters from old to new Path
        return manga.Chapters.Select(c => new MoveFileOrFolderWorker(c.FullArchiveFilePath, oldPath[c])).ToArray<BaseWorker>();
    }

--- a/API/Workers/PeriodicWorkers/CheckForNewChaptersWorker.cs
+++ b/API/Workers/PeriodicWorkers/CheckForNewChaptersWorker.cs
@@ -3,23 +3,28 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Creates Jobs to update available Chapters for all Manga that are marked for Download
+/// </summary>
 public class CheckForNewChaptersWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
 {
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromMinutes(60);
    
-    protected override Task<BaseWorker[]> DoWorkInternal()
+    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        IQueryable<MangaConnectorId<Manga>> connectorIdsManga = DbContext.MangaConnectorToManga
+        Log.Debug("Checking for new chapters...");
+        List<MangaConnectorId<Manga>> connectorIdsManga = await DbContext.MangaConnectorToManga
            .Include(id => id.Obj)
-            .Where(id => id.UseForDownload);
+            .Where(id => id.UseForDownload)
+            .ToListAsync(CancellationToken);
+        Log.Debug($"Creating {connectorIdsManga.Count} update jobs...");

-        List<BaseWorker> newWorkers = new();
-        foreach (MangaConnectorId<Manga> mangaConnectorId in connectorIdsManga)
-            newWorkers.Add(new RetrieveMangaChaptersFromMangaconnectorWorker(mangaConnectorId, Tranga.Settings.DownloadLanguage));
-        
-        return new Task<BaseWorker[]>(() => newWorkers.ToArray());
+        List<BaseWorker> newWorkers = connectorIdsManga.Select(id => new RetrieveMangaChaptersFromMangaconnectorWorker(id, Tranga.Settings.DownloadLanguage))
+            .ToList<BaseWorker>();
+
+        return newWorkers.ToArray();
    }

 }
--- a/API/Workers/PeriodicWorkers/MaintenanceWorkers/RemoveOldNotificationsWorker.cs
+++ b/API/Workers/PeriodicWorkers/MaintenanceWorkers/RemoveOldNotificationsWorker.cs
@@ -1,7 +1,11 @@
 using API.Schema.NotificationsContext;
+using Microsoft.EntityFrameworkCore;

 namespace API.Workers.MaintenanceWorkers;

+/// <summary>
+/// Removes sent notifications from database
+/// </summary>
 public class RemoveOldNotificationsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<NotificationsContext>(dependsOn), IPeriodic
 {
@@ -10,10 +14,14 @@ public class RemoveOldNotificationsWorker(TimeSpan? interval = null, IEnumerable
    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        IQueryable<Notification> toRemove = DbContext.Notifications.Where(n => n.IsSent || DateTime.UtcNow - n.Date > Interval);
+        Log.Debug("Removing old notifications...");
+        List<Notification> toRemove = await DbContext.Notifications.Where(n => n.IsSent).ToListAsync(CancellationToken);
+        Log.Debug($"Removing {toRemove.Count} old notifications...");
        DbContext.RemoveRange(toRemove);
        
-        await DbContext.Sync(CancellationTokenSource.Token);
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        
        return [];
    }

--- a/API/Workers/PeriodicWorkers/SendNotificationsWorker.cs
+++ b/API/Workers/PeriodicWorkers/SendNotificationsWorker.cs
@@ -1,8 +1,14 @@
 using API.Schema.NotificationsContext;
 using API.Schema.NotificationsContext.NotificationConnectors;
+using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Send notifications to NotificationConnectors
+/// </summary>
+/// <param name="interval"></param>
+/// <param name="dependsOn"></param>
 public class SendNotificationsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<NotificationsContext>(dependsOn), IPeriodic
 {
@@ -10,19 +16,26 @@ public class SendNotificationsWorker(TimeSpan? interval = null, IEnumerable<Base
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromMinutes(1);
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        NotificationConnector[] connectors = DbContext.NotificationConnectors.ToArray();
-        Notification[] notifications = DbContext.Notifications.Where(n => n.IsSent == false).ToArray();
+        Log.Debug("Sending notifications...");
+        List<NotificationConnector> connectors = await DbContext.NotificationConnectors.ToListAsync(CancellationToken);
+        List<Notification> unsentNotifications = await DbContext.Notifications.Where(n => n.IsSent == false).ToListAsync(CancellationToken);
        
-        foreach (Notification notification in notifications)
+        Log.Debug($"Sending {unsentNotifications.Count} notifications to {connectors.Count} connectors...");
+        
+        unsentNotifications.ForEach(notification =>
        {
-            foreach (NotificationConnector connector in connectors)
+            connectors.ForEach(connector =>
            {
                connector.SendNotification(notification.Title, notification.Message);
-                notification.IsSent = true;
-            }
-        }
+                DbContext.Entry(notification).Property(n => n.IsSent).CurrentValue = true;
+            });
+        });
        
-        await DbContext.Sync(CancellationTokenSource.Token);
+        Log.Debug("Notifications sent.");
+        
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+            
        return [];
    }

--- a/API/Workers/PeriodicWorkers/StartNewChapterDownloadsWorker.cs
+++ b/API/Workers/PeriodicWorkers/StartNewChapterDownloadsWorker.cs
@@ -3,22 +3,26 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Create new Workers for Chapters on Manga marked for Download, that havent been downloaded yet.
+/// </summary>
 public class StartNewChapterDownloadsWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
 {

    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromMinutes(1);
-    protected override Task<BaseWorker[]> DoWorkInternal()
+    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        IQueryable<MangaConnectorId<Chapter>> mangaConnectorIds = DbContext.MangaConnectorToChapter
+        // Get missing chapters
+        List<MangaConnectorId<Chapter>> missingChapters = await DbContext.MangaConnectorToChapter
            .Include(id => id.Obj)
-            .Where(id => id.Obj.Downloaded == false && id.UseForDownload);
+            .Where(id => id.Obj.Downloaded == false && id.UseForDownload)
+            .ToListAsync(CancellationToken);
        
-        List<BaseWorker> newWorkers = new();
-        foreach (MangaConnectorId<Chapter> mangaConnectorId in mangaConnectorIds)
-            newWorkers.Add(new DownloadChapterFromMangaconnectorWorker(mangaConnectorId));
+        // Create new jobs
+        List<BaseWorker> newWorkers = missingChapters.Select(mcId => new DownloadChapterFromMangaconnectorWorker(mcId)).ToList<BaseWorker>();
        
-        return new Task<BaseWorker[]>(() => newWorkers.ToArray());
+        return newWorkers.ToArray();
    }
 }
--- a/API/Workers/PeriodicWorkers/UpdateChaptersDownloadedWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateChaptersDownloadedWorker.cs
@@ -3,6 +3,9 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Updates the database to reflect changes made on disk
+/// </summary>
 public class UpdateChaptersDownloadedWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
 {
@@ -10,10 +13,14 @@ public class UpdateChaptersDownloadedWorker(TimeSpan? interval = null, IEnumerab
    public TimeSpan Interval { get; set; } = interval??TimeSpan.FromMinutes(60);
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        foreach (Chapter dbContextChapter in DbContext.Chapters.Include(c => c.ParentManga))
-            dbContextChapter.Downloaded = dbContextChapter.CheckDownloaded();
+        Log.Debug("Checking chapter files...");
+        List<Chapter> chapters = await DbContext.Chapters.Include(c => c.ParentManga).ToListAsync(CancellationToken);
+        Log.Debug($"Checking {chapters.Count} chapters...");
+        chapters.ForEach(chapter => DbContext.Entry(chapter).Property(c => c.Downloaded).CurrentValue = chapter.CheckDownloaded());

-        await DbContext.Sync(CancellationTokenSource.Token);
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");
+        
        return [];
    }
 }
--- a/API/Workers/PeriodicWorkers/UpdateCoversWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateCoversWorker.cs
@@ -1,7 +1,13 @@
 using API.Schema.MangaContext;
+using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Creates Workers to update covers for Manga
+/// </summary>
+/// <param name="interval"></param>
+/// <param name="dependsOn"></param>
 public class UpdateCoversWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
 {
@@ -9,11 +15,10 @@ public class UpdateCoversWorker(TimeSpan? interval = null, IEnumerable<BaseWorke
    public DateTime LastExecution { get; set; } = DateTime.UnixEpoch;
    public TimeSpan Interval { get; set; } = interval ?? TimeSpan.FromHours(6);
    
-    protected override Task<BaseWorker[]> DoWorkInternal()
+    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        List<BaseWorker> workers = new();
-        foreach (MangaConnectorId<Manga> mangaConnectorId in DbContext.MangaConnectorToManga)
-            workers.Add(new DownloadCoverFromMangaconnectorWorker(mangaConnectorId));
-        return new Task<BaseWorker[]>(() => workers.ToArray());
+        List<MangaConnectorId<Manga>> manga = await DbContext.MangaConnectorToManga.Where(mcId => mcId.UseForDownload).ToListAsync(CancellationToken);
+        List<BaseWorker> newWorkers = manga.Select(m => new DownloadCoverFromMangaconnectorWorker(m)).ToList<BaseWorker>();
+        return newWorkers.ToArray();
    }
 }
--- a/API/Workers/PeriodicWorkers/UpdateMetadataWorker.cs
+++ b/API/Workers/PeriodicWorkers/UpdateMetadataWorker.cs
@@ -4,6 +4,11 @@ using Microsoft.EntityFrameworkCore;

 namespace API.Workers;

+/// <summary>
+/// Updates Metadata for all Manga
+/// </summary>
+/// <param name="interval"></param>
+/// <param name="dependsOn"></param>
 public class UpdateMetadataWorker(TimeSpan? interval = null, IEnumerable<BaseWorker>? dependsOn = null)
    : BaseWorkerWithContext<MangaContext>(dependsOn), IPeriodic
 {
@@ -13,18 +18,27 @@ public class UpdateMetadataWorker(TimeSpan? interval = null, IEnumerable<BaseWor
    
    protected override async Task<BaseWorker[]> DoWorkInternal()
    {
-        IQueryable<string> mangaIds = DbContext.MangaConnectorToManga
-            .Where(m => m.UseForDownload)
-            .Select(m => m.ObjId);
-        IQueryable<MetadataEntry> metadataEntriesToUpdate = DbContext.MetadataEntries
-            .Include(e => e.MetadataFetcher)
-            .Where(e =>
-                mangaIds.Any(id => id == e.MangaId));
-        
-        foreach (MetadataEntry metadataEntry in metadataEntriesToUpdate)
-            await metadataEntry.MetadataFetcher.UpdateMetadata(metadataEntry, DbContext, CancellationTokenSource.Token);
+        Log.Debug("Updating metadata...");
+        // Get MetadataEntries of Manga marked for download
+        List<MetadataEntry> metadataEntriesToUpdate = await DbContext.MangaConnectorToManga
+            .Where(m => m.UseForDownload) // Get marked Manga
+            .Join(
+                DbContext.MetadataEntries.Include(e => e.MetadataFetcher).Include(e => e.Manga),
+                mcId => mcId.ObjId,
+                e => e.MangaId,
+                (mcId, e) => e) // return MetadataEntry
+            .ToListAsync(CancellationToken);
+        Log.Debug($"Updating metadata of {metadataEntriesToUpdate.Count} manga...");

-        await DbContext.Sync(CancellationTokenSource.Token);
+        foreach (MetadataEntry metadataEntry in metadataEntriesToUpdate)
+        {
+            Log.Debug($"Updating metadata of {metadataEntry}...");
+            await metadataEntry.MetadataFetcher.UpdateMetadata(metadataEntry, DbContext, CancellationToken);
+        }
+        Log.Debug("Updated metadata.");
+
+        if(await DbContext.Sync(CancellationToken) is { success: false } e)
+            Log.Error($"Failed to save database changes: {e.exceptionMessage}");

        return [];
    }