bug fixes (#757)

* fix docker blur hash generation

* scanner async cleanup

* catch and log some unauthorized exception errors

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Cleanly stop Plex library scan when service termination is requested
 - Fix bug introduced with 0.5.2-beta that prevented some Plex content from being played
 - Fix spammy subtitle error message
+- Fix generating blur hashes for song backgrounds in Docker
 
 ### Changed
 - No longer remove Plex movies and episodes from ErsatzTV when they do not exist on disk

ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs

@@ -70,8 +70,15 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
             apiKey,
             library.ItemId);
 
-        await maybeShows.Match(
+        foreach (BaseError error in maybeShows.LeftToSeq())
-            async shows =>
+        {
+            _logger.LogWarning(
+                "Error synchronizing emby library {Path}: {Error}",
+                library.Name,
+                error.Value);
+        }
+
+        foreach (List<EmbyShow> shows in maybeShows.RightToSeq())
         {
             await ProcessShows(
                 address,
@@ -97,16 +104,7 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
 
             await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
             _searchIndex.Commit();
-            },
+        }
-            error =>
-            {
-                _logger.LogWarning(
-                    "Error synchronizing emby library {Path}: {Error}",
-                    library.Name,
-                    error.Value);
-
-                return Task.CompletedTask;
-            });
 
         return Unit.Default;
     }
@@ -128,39 +126,35 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
             await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
             Option<EmbyItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
-            await maybeExisting.Match(
+            if (maybeExisting.IsNone)
-                async existing =>
+            {
+                incoming.LibraryPathId = library.Paths.Head().Id;
+
+                // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
+
+                if (await _televisionRepository.AddShow(incoming))
+                {
+                    await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                }
+            }
+
+            foreach (EmbyItemEtag existing in maybeExisting)
             {
                 if (existing.Etag == incoming.Etag)
                 {
                     return;
                 }
 
-                    _logger.LogDebug(
+                _logger.LogDebug("UPDATE: Etag has changed for show {Show}", incoming.ShowMetadata.Head().Title);
-                        "UPDATE: Etag has changed for show {Show}",
-                        incoming.ShowMetadata.Head().Title);
 
                 incoming.LibraryPathId = library.Paths.Head().Id;
 
                 Option<EmbyShow> updated = await _televisionRepository.Update(incoming);
                 if (updated.IsSome)
                 {
-                        await _searchIndex.UpdateItems(
+                    await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { updated.ValueUnsafe() });
-                            _searchRepository,
-                            new List<MediaItem> { updated.ValueUnsafe() });
                 }
-                },
-                async () =>
-                {
-                    incoming.LibraryPathId = library.Paths.Head().Id;
-
-                    // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
-
-                    if (await _televisionRepository.AddShow(incoming))
-                    {
-                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
             }
-                });
 
             List<EmbyItemEtag> existingSeasons =
                 await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
@@ -168,8 +162,15 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
             Either<BaseError, List<EmbySeason>> maybeSeasons =
                 await _embyApiClient.GetSeasonLibraryItems(address, apiKey, incoming.ItemId);
 
-            await maybeSeasons.Match(
+            foreach (BaseError error in maybeSeasons.LeftToSeq())
-                async seasons =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing emby library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+            }
+
+            foreach (List<EmbySeason> seasons in maybeSeasons.RightToSeq())
             {
                 await ProcessSeasons(
                     address,
@@ -188,16 +189,7 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
                     .Map(m => m.ItemId)
                     .ToList();
                 await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
-                },
+            }
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error synchronizing emby library {Path}: {Error}",
-                        library.Name,
-                        error.Value);
-
-                    return Task.CompletedTask;
-                });
         }
     }
 
@@ -237,9 +229,7 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
 
                         foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
                         {
-                            await _searchIndex.UpdateItems(
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { toIndex });
-                                _searchRepository,
-                                new List<MediaItem> { toIndex });
                         }
                     }
                 },
@@ -361,9 +351,7 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
                         Option<EmbyEpisode> maybeUpdated = await _televisionRepository.Update(incoming);
                         foreach (EmbyEpisode updated in maybeUpdated)
                         {
-                            await _searchIndex.UpdateItems(
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { updated });
-                                _searchRepository,
-                                new List<MediaItem> { updated });
 
                             incomingEpisode = updated;
                         }
@@ -425,13 +413,14 @@ public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
                     refreshResult = await UpdateSubtitles(incomingEpisode, localPath);
                 }
 
-                refreshResult.Match(
+                foreach (BaseError error in refreshResult.LeftToSeq())
-                    _ => { },
+                {
-                    error => _logger.LogWarning(
+                    _logger.LogWarning(
                         "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
                         "Statistics",
                         localPath,
-                        error.Value));
+                        error.Value);
+                }
             }
         }
     }

ErsatzTV.Core/Metadata/LocalFileSystem.cs

@@ -47,6 +47,10 @@ public class LocalFileSystem : ILocalFileSystem
             {
                 return Directory.EnumerateDirectories(folder);
             }
+            catch (UnauthorizedAccessException)
+            {
+                _logger.LogWarning("Unauthorized access exception listing subdirectories of folder {Folder}", folder);
+            }
             catch (Exception ex)
             {
                 // do nothing
@@ -65,6 +69,10 @@ public class LocalFileSystem : ILocalFileSystem
             {
                 return Directory.EnumerateFiles(folder, "*", SearchOption.TopDirectoryOnly);
             }
+            catch (UnauthorizedAccessException)
+            {
+                _logger.LogWarning("Unauthorized access exception listing files in folder {Folder}", folder);
+            }
             catch (Exception ex)
             {
                 // do nothing
@@ -83,6 +91,10 @@ public class LocalFileSystem : ILocalFileSystem
             {
                 return Directory.EnumerateFiles(folder, searchPattern, SearchOption.TopDirectoryOnly);
             }
+            catch (UnauthorizedAccessException)
+            {
+                _logger.LogWarning("Unauthorized access exception listing files in folder {Folder}", folder);
+            }
             catch (Exception ex)
             {
                 // do nothing

ErsatzTV.Core/Metadata/MovieFolderScanner.cs

@@ -88,7 +88,8 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
         {
             decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
             await _mediator.Publish(
-                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread),
+                cancellationToken);
 
             string movieFolder = folderQueue.Dequeue();
             foldersCompleted++;
@@ -142,8 +143,12 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
                     .BindT(UpdateSubtitles)
                     .BindT(FlagNormal);
 
-                await maybeMovie.Match(
+                foreach (BaseError error in maybeMovie.LeftToSeq())
-                    async result =>
+                {
+                    _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value);
+                }
+
+                foreach (MediaItemScanResult<Movie> result in maybeMovie.RightToSeq())
                 {
                     if (result.IsAdded)
                     {
@@ -155,12 +160,7 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
                     }
 
                     await _libraryRepository.SetEtag(libraryPath, knownFolder, movieFolder, etag);
-                    },
+                }
-                    error =>
-                    {
-                        _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value);
-                        return Task.CompletedTask;
-                    });
             }
         }
 
@@ -192,8 +192,22 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
         try
         {
             Movie movie = result.Item;
-            await LocateNfoFile(movie).Match(
+            
-                async nfoFile =>
+            Option<string> maybeNfoFile = LocateNfoFile(movie);
+            if (maybeNfoFile.IsNone)
+            {
+                if (!Optional(movie.MovieMetadata).Flatten().Any())
+                {
+                    string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
+                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                    if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+            }
+
+            foreach (string nfoFile in maybeNfoFile)
             {
                 bool shouldUpdate = Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
                     m => m.MetadataKind == MetadataKind.Fallback ||
@@ -208,19 +222,7 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
                         result.IsUpdated = true;
                     }
                 }
-                },
-                async () =>
-                {
-                    if (!Optional(movie.MovieMetadata).Flatten().Any())
-                    {
-                        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
-                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                        if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
-                        {
-                            result.IsUpdated = true;
-                        }
             }
-                });
 
             return result;
         }
@@ -239,12 +241,12 @@ public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
         try
         {
             Movie movie = result.Item;
-            await LocateArtwork(movie, artworkKind).IfSomeAsync(
+            Option<string> maybeArtwork = LocateArtwork(movie, artworkKind);
-                async posterFile =>
+            foreach (string posterFile in maybeArtwork)
             {
                 MovieMetadata metadata = movie.MovieMetadata.Head();
                 await RefreshArtwork(posterFile, metadata, artworkKind, None, None, cancellationToken);
-                });
+            }
 
             return result;
         }

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -83,7 +83,8 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
         {
             decimal percentCompletion = (decimal)allShowFolders.IndexOf(showFolder) / allShowFolders.Count;
             await _mediator.Publish(
-                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread),
+                cancellationToken);
 
             Either<BaseError, MediaItemScanResult<Show>> maybeShow =
                 await FindOrCreateShow(libraryPath.Id, showFolder)
@@ -92,16 +93,17 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
                     .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.FanArt, cancellationToken))
                     .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Thumbnail, cancellationToken));
 
-            await maybeShow.Match(
+            foreach (BaseError error in maybeShow.LeftToSeq())
-                async result =>
             {
-                    await ScanSeasons(
+                _logger.LogWarning(
-                        libraryPath,
+                    "Error processing show in folder {Folder}: {Error}",
-                        ffmpegPath,
-                        ffprobePath,
-                        result.Item,
                     showFolder,
-                        cancellationToken);
+                    error.Value);
+            }
+
+            foreach (MediaItemScanResult<Show> result in maybeShow.RightToSeq())
+            {
+                await ScanSeasons(libraryPath, ffmpegPath, ffprobePath, result.Item, showFolder, cancellationToken);
 
                 if (result.IsAdded)
                 {
@@ -111,15 +113,7 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
                 {
                     await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
                 }
-                },
+            }
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error processing show in folder {Folder}: {Error}",
-                        showFolder,
-                        error.Value);
-                    return Task.FromResult(Unit.Default);
-                });
         }
 
         foreach (string path in await _televisionRepository.FindEpisodePaths(libraryPath))
@@ -249,16 +243,15 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
                 .BindT(e => FlagNormal(new MediaItemScanResult<Episode>(e)))
                 .MapT(r => r.Item);
 
-            await maybeEpisode.Match(
+            foreach (BaseError error in maybeEpisode.LeftToSeq())
-                async episode =>
-                {
-                    await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
-                },
-                error =>
             {
                 _logger.LogWarning("Error processing episode at {Path}: {Error}", file, error.Value);
-                    return Task.CompletedTask;
+            }
-                });
+
+            foreach (Episode episode in maybeEpisode.RightToSeq())
+            {
+                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
+            }
         }
 
         // TODO: remove missing episodes?
@@ -273,8 +266,21 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
         try
         {
             Show show = result.Item;
-            await LocateNfoFileForShow(showFolder).Match(
+            
-                async nfoFile =>
+            Option<string> maybeNfo = LocateNfoFileForShow(showFolder);
+            if (maybeNfo.IsNone)
+            {
+                if (!Optional(show.ShowMetadata).Flatten().Any())
+                {
+                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
+                    if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
+                    {
+                        result.IsUpdated = true;
+                    }
+                }
+            }
+
+            foreach (string nfoFile in maybeNfo)
             {
                 bool shouldUpdate = Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
                     m => m.MetadataKind == MetadataKind.Fallback ||
@@ -289,18 +295,7 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
                         result.IsUpdated = true;
                     }
                 }
-                },
-                async () =>
-                {
-                    if (!Optional(show.ShowMetadata).Flatten().Any())
-                    {
-                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
-                        if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
-                        {
-                            result.IsUpdated = true;
-                        }
             }
-                });
 
             return result;
         }
@@ -337,33 +332,34 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
     {
         try
         {
-            await LocateNfoFile(episode).Match(
+            Option<string> maybeNfo = LocateNfoFile(episode);
-                async nfoFile =>
+            if (maybeNfo.IsNone)
             {
                 bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
-                        m => m.MetadataKind == MetadataKind.Fallback ||
+                    m => m.DateUpdated == SystemTime.MinValueUtc,
-                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
                     true);
 
                 if (shouldUpdate)
                 {
-                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                    string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-                        await _localMetadataProvider.RefreshSidecarMetadata(episode, nfoFile);
+                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                    await _localMetadataProvider.RefreshFallbackMetadata(episode);
                 }
-                },
+            }
-                async () =>
+
+            foreach (string nfoFile in maybeNfo)
             {
                 bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
-                        m => m.DateUpdated == SystemTime.MinValueUtc,
+                    m => m.MetadataKind == MetadataKind.Fallback ||
+                         m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
                     true);
 
                 if (shouldUpdate)
                 {
-                        string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+                    _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                    await _localMetadataProvider.RefreshSidecarMetadata(episode, nfoFile);
-                        await _localMetadataProvider.RefreshFallbackMetadata(episode);
+                }
             }
-                });
 
             return episode;
         }
@@ -383,12 +379,12 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
         try
         {
             Show show = result.Item;
-            await LocateArtworkForShow(showFolder, artworkKind).IfSomeAsync(
+            Option<string> maybeArtwork = LocateArtworkForShow(showFolder, artworkKind);
-                async artworkFile =>
+            foreach (string artworkFile in maybeArtwork)
             {
                 ShowMetadata metadata = show.ShowMetadata.Head();
                 await RefreshArtwork(artworkFile, metadata, artworkKind, None, None, cancellationToken);
-                });
+            }
 
             return result;
         }
@@ -406,12 +402,12 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
     {
         try
         {
-            await LocatePoster(season, seasonFolder).IfSomeAsync(
+            Option<string> maybePoster = LocatePoster(season, seasonFolder);
-                async posterFile =>
+            foreach (string posterFile in maybePoster)
             {
                 SeasonMetadata metadata = season.SeasonMetadata.Head();
                 await RefreshArtwork(posterFile, metadata, ArtworkKind.Poster, None, None, cancellationToken);
-                });
+            }
 
             return season;
         }
@@ -426,20 +422,20 @@ public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScan
     {
         try
         {
-            await LocateThumbnail(episode).IfSomeAsync(
+            Option<string> maybeThumbnail = LocateThumbnail(episode);
-                async posterFile =>
+            foreach (string thumbnailFile in maybeThumbnail)
             {
                 foreach (EpisodeMetadata metadata in episode.EpisodeMetadata)
                 {
                     await RefreshArtwork(
-                            posterFile,
+                        thumbnailFile,
                         metadata,
                         ArtworkKind.Thumbnail,
                         None,
                         None,
                         cancellationToken);
                 }
-                });
+            }
 
             return episode;
         }

ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs

@@ -290,8 +290,16 @@ public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScan
                 Either<BaseError, bool> refreshResult =
                     await _localStatisticsProvider.RefreshStatistics(ffmpegPath, ffprobePath, existing, localPath);
 
-                await refreshResult.Match(
+                foreach (BaseError error in refreshResult.LeftToSeq())
-                    async _ =>
+                {
+                    _logger.LogWarning(
+                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                        "Statistics",
+                        localPath,
+                        error.Value);
+                }
+
+                foreach (bool _ in refreshResult.RightToSeq())
                 {
                     foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
                     {
@@ -301,17 +309,7 @@ public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScan
                     }
 
                     await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, incomingVersion);
-                    },
+                }
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                            "Statistics",
-                            localPath,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
             }
         }
 
@@ -340,8 +338,7 @@ public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScan
                 connection,
                 token);
 
-        await maybeMetadata.Match(
+        foreach (MovieMetadata fullMetadata in maybeMetadata.RightToSeq())
-            async fullMetadata =>
         {
             if (existingMetadata.MetadataKind != MetadataKind.External)
             {
@@ -525,8 +522,7 @@ public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScan
             {
                 await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
             }
-            },
+        }
-            _ => Task.CompletedTask);
 
         // TODO: update other metadata?
 

ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs

@@ -747,8 +747,16 @@ public class PlexTelevisionLibraryScanner : PlexLibraryScanner, IPlexTelevisionL
                     localPath);
             }
 
-            await refreshResult.Match(
+            foreach (BaseError error in refreshResult.LeftToSeq())
-                async _ =>
+            {
+                _logger.LogWarning(
+                    "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                    "Statistics",
+                    localPath,
+                    error.Value);
+            }
+
+            foreach (var _ in refreshResult.RightToSeq())
             {
                 foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
                 {
@@ -764,8 +772,7 @@ public class PlexTelevisionLibraryScanner : PlexLibraryScanner, IPlexTelevisionL
                         connection,
                         token);
 
-                    await maybeStatistics.Match(
+                foreach (Tuple<EpisodeMetadata, MediaVersion> tuple in maybeStatistics.RightToSeq())
-                        async tuple =>
                 {
                     (EpisodeMetadata incomingMetadata, MediaVersion mediaVersion) = tuple;
 
@@ -811,19 +818,8 @@ public class PlexTelevisionLibraryScanner : PlexLibraryScanner, IPlexTelevisionL
                     existingVersion.DateUpdated = mediaVersion.DateUpdated;
 
                     await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, mediaVersion);
-                        },
+                }
-                        _ => Task.CompletedTask);
+            }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                        "Statistics",
-                        localPath,
-                        error.Value);
-
-                    return Task.CompletedTask;
-                });
         }
 
         return result;

docker/Dockerfile

@@ -2,7 +2,7 @@
 
 FROM jasongdove/ffmpeg:5.0-ubuntu2004 AS runtime-base
 COPY --from=dotnet-runtime /usr/share/dotnet /usr/share/dotnet
-RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu-dev tzdata  fontconfig fonts-dejavu
+RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu-dev tzdata  fontconfig fonts-dejavu libgdiplus
 
 # https://hub.docker.com/_/microsoft-dotnet
 FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build

docker/nvidia/ffmpeg.Dockerfile

@@ -3,5 +3,5 @@
 FROM jasongdove/ffmpeg-base:5.0-nvidia2004 AS runtime-base
 COPY --from=dotnet-runtime /usr/share/dotnet /usr/share/dotnet
 RUN apt-get update \
-    && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu-dev tzdata fontconfig fonts-dejavu \
+    && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu-dev tzdata fontconfig fonts-dejavu libgdiplus \
     && rm -rf /var/lib/apt/lists/*

docker/vaapi/ffmpeg.Dockerfile

@@ -6,6 +6,7 @@ RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu
     tzdata \
     fontconfig \
     fonts-dejavu \
+    libgdiplus \
     autoconf \
     libtool \
     libdrm-dev \