Misc Polish and Fixes (#1542)

* Moved LibraryWatcher to utilize a queue for calculating the change event to ensure the Watcher doesn't get overwhelmed on large moves.

* Fixed a security vulnerability (https://huntr.dev/bounties/8a3e652f-d6bf-436e-877e-0eaf5c69ef95/). This will be disclosed in Stable release changelog.

* Tweaked the log message template

* Removed some dead code from Configuration json patcher

* Fixed a bug with the ComicInfo finding to properly handle root level.

Fixed a bug where sometimes scanner wouldn't choose the first file with ComicInfo for filling out information.

* Added new setting for managing how many logs files are allowed, just like how backups work.

* Added unit tests for new CleanupLogs code

* Fixed a bug where manga reader background color wasn't actually sending from the UI

* Added new stats for tracking to help understand usage in the app and what features are used or not.

* Fixed Stats url

* Fixed a bug where volumes that had larger than 1 difference wouldn't properly return next/prev chapter (for continuous reader)

* Remove a redundant test step in build pipeline, since it's already done at PR stage.

* Updated dockerfile to use the new Heath check endpoint

* Allow force to pass through to scan loop

* Removed some old config stuff from a safety check on config in entrypoint.sh

* Fixed broken unit tests due to new RBS check and how we setup mock data.

.github/workflows/sonar-scan.yml

@@ -123,7 +123,7 @@ jobs:
 
   develop:
     name: Build Nightly Docker if Develop push
-    needs: [ build, test, version ]
+    needs: [ build, version ]
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
     steps:
@@ -232,7 +232,7 @@ jobs:
 
   stable:
     name: Build Stable Docker if Main push
-    needs: [ build, test ]
+    needs: [ build ]
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
     steps:

API.Tests/Services/CleanupServiceTests.cs

@@ -38,6 +38,7 @@ public class CleanupServiceTests
     private const string CacheDirectory = "C:/kavita/config/cache/";
     private const string CoverImageDirectory = "C:/kavita/config/covers/";
     private const string BackupDirectory = "C:/kavita/config/backups/";
+    private const string LogDirectory = "C:/kavita/config/logs/";
     private const string BookmarkDirectory = "C:/kavita/config/bookmarks/";
 
 
@@ -84,6 +85,9 @@ private async Task<bool> SeedDb()
         setting = await _context.ServerSetting.Where(s => s.Key == ServerSettingKey.BookmarkDirectory).SingleAsync();
         setting.Value = BookmarkDirectory;
 
+        setting = await _context.ServerSetting.Where(s => s.Key == ServerSettingKey.TotalLogs).SingleAsync();
+        setting.Value = "10";
+
         _context.ServerSetting.Update(setting);
 
         _context.Library.Add(new Library()
@@ -412,6 +416,59 @@ public async Task CleanupBackups_LeaveLestExpired()
 
     #endregion
 
+    #region CleanupLogs
+
+    [Fact]
+    public async Task CleanupLogs_LeaveOneFile_SinceAllAreExpired()
+    {
+        var filesystem = CreateFileSystem();
+        foreach (var i in Enumerable.Range(1, 10))
+        {
+            var day = API.Services.Tasks.Scanner.Parser.Parser.PadZeros($"{i}");
+            filesystem.AddFile($"{LogDirectory}kavita202009{day}.log", new MockFileData("")
+            {
+                CreationTime = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(31))
+            });
+        }
+
+        var ds = new DirectoryService(Substitute.For<ILogger<DirectoryService>>(), filesystem);
+        var cleanupService = new CleanupService(_logger, _unitOfWork, _messageHub,
+            ds);
+        await cleanupService.CleanupLogs();
+        Assert.Single(ds.GetFiles(LogDirectory, searchOption: SearchOption.AllDirectories));
+    }
+
+    [Fact]
+    public async Task CleanupLogs_LeaveLestExpired()
+    {
+        var filesystem = CreateFileSystem();
+        foreach (var i in Enumerable.Range(1, 9))
+        {
+            var day = API.Services.Tasks.Scanner.Parser.Parser.PadZeros($"{i}");
+            filesystem.AddFile($"{LogDirectory}kavita202009{day}.log", new MockFileData("")
+            {
+                CreationTime = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(31 - i))
+            });
+        }
+        filesystem.AddFile($"{LogDirectory}kavita20200910.log", new MockFileData("")
+        {
+            CreationTime = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(31 - 10))
+        });
+        filesystem.AddFile($"{LogDirectory}kavita20200911.log", new MockFileData("")
+        {
+            CreationTime = DateTimeOffset.Now.Subtract(TimeSpan.FromDays(31 - 11))
+        });
+
+
+        var ds = new DirectoryService(Substitute.For<ILogger<DirectoryService>>(), filesystem);
+        var cleanupService = new CleanupService(_logger, _unitOfWork, _messageHub,
+            ds);
+        await cleanupService.CleanupLogs();
+        Assert.True(filesystem.File.Exists($"{LogDirectory}kavita20200911.log"));
+    }
+
+    #endregion
+
     // #region CleanupBookmarks
     //
     // [Fact]

API.Tests/Services/ReaderServiceTests.cs

@@ -895,6 +895,60 @@ public async Task GetPrevChapterIdAsync_ShouldGetPrevVolume()
         Assert.Equal("1", actualChapter.Range);
     }
 
+    [Fact]
+    public async Task GetPrevChapterIdAsync_ShouldGetPrevVolume_2()
+    {
+        await ResetDb();
+
+        _context.Series.Add(new Series()
+        {
+            Name = "Test",
+            Library = new Library() {
+                Name = "Test LIb",
+                Type = LibraryType.Manga,
+            },
+            Volumes = new List<Volume>()
+            {
+                EntityFactory.CreateVolume("0", new List<Chapter>()
+                {
+                    EntityFactory.CreateChapter("40", false, new List<MangaFile>(), 1),
+                    EntityFactory.CreateChapter("50", false, new List<MangaFile>(), 1),
+                    EntityFactory.CreateChapter("60", false, new List<MangaFile>(), 1),
+                    EntityFactory.CreateChapter("Some Special Title", true, new List<MangaFile>(), 1),
+                }),
+                EntityFactory.CreateVolume("1997", new List<Chapter>()
+                {
+                    EntityFactory.CreateChapter("1", false, new List<MangaFile>(), 1),
+                }),
+                EntityFactory.CreateVolume("2001", new List<Chapter>()
+                {
+                    EntityFactory.CreateChapter("21", false, new List<MangaFile>(), 1),
+                }),
+                EntityFactory.CreateVolume("2005", new List<Chapter>()
+                {
+                    EntityFactory.CreateChapter("31", false, new List<MangaFile>(), 1),
+                }),
+            }
+        });
+
+
+       _context.AppUser.Add(new AppUser()
+        {
+            UserName = "majora2007"
+        });
+
+        await _context.SaveChangesAsync();
+
+        var readerService = new ReaderService(_unitOfWork, Substitute.For<ILogger<ReaderService>>(), Substitute.For<IEventHub>());
+
+        // prevChapter should be id from ch.21 from volume 2001
+        var prevChapter = await readerService.GetPrevChapterIdAsync(1, 4, 7, 1);
+
+        var actualChapter = await _unitOfWork.ChapterRepository.GetChapterAsync(prevChapter);
+        Assert.NotNull(actualChapter);
+        Assert.Equal("21", actualChapter.Range);
+    }
+
     [Fact]
     public async Task GetPrevChapterIdAsync_ShouldRollIntoPrevVolume()
     {