Fix FolderStorageInfo to show parent filesystem

A direct implementation using DriveInfo directly on a path does not work
as expected. The method will return a DriveInfo object with the given
path as both the Name and the RootDirectory, which is not helpful.

Instead, add parsing logic to find the best possible match out of all
filesystems on the system for the path, including handling edge cases
involving symlinked paths in the chain.

This ensures that the resulting DeviceId is a valid filesystem, allowing
it to be used in the UI to show a better description. It also includes
the new ResolvedPath which will show, if required, what the Path
resolved to after all symlinks are interpolated.

One possible issue here is that walking all drives as-is might become
slow(er) on a system with many partitions, but even on my
partition-heavy system with over a dozen ZVOLs and remote mounts, this
takes under 0.4 seconds including runup time for `dotnet run`, so I
imagine this should be fine.

1 files changed, 46 insertions, 7 deletions

diff --git a/Jellyfin.Server.Implementations/StorageHelpers/StorageHelper.cs b/Jellyfin.Server.Implementations/StorageHelpers/StorageHelper.cs
index ce628a04d0..0b8e2830d2 100644
--- a/Jellyfin.Server.Implementations/StorageHelpers/StorageHelper.cs
+++ b/Jellyfin.Server.Implementations/StorageHelpers/StorageHelper.cs
@@ -28,22 +28,41 @@ public static class StorageHelper
     }
 
     /// <summary>
-    /// Gets the free space of a specific directory.
+    /// Gets the free space of the parent filesystem of a specific directory.
     /// </summary>
     /// <param name="path">Path to a folder.</param>
-    /// <returns>The number of bytes available space.</returns>
+    /// <returns>Various details about the parent filesystem containing the directory.</returns>
     public static FolderStorageInfo GetFreeSpaceOf(string path)
     {
         try
         {
-            var driveInfo = new DriveInfo(path);
+            // Fully resolve the given path to an actual filesystem target, in case it's a symlink or similar.
+            resolvedPath = ResolvePath(path);
+            // We iterate all filesystems reported by GetDrives() here, and attempt to find the best
+            // match that contains, as deep as possible, the given path.
+            // This is required because simply calling `DriveInfo` on a path returns that path as
+            // the Name and RootDevice, which is not at all how this should work.
+            DriveInfo[] allDrives = DriveInfo.GetDrives();
+            DriveInfo bestMatch = null;  
+            foreach (DriveInfo d in allDrives)
+            {
+                if (resolvedPath.StartsWith(d.RootDirectory.FullName) &&
+                    (bestMatch == null || d.RootDirectory.FullName.Length > bestMatch.RootDirectory.FullName.Length))
+                {
+                    bestMatch = d;
+                }
+            }
+            if (bestMatch is null) {
+                throw new InvalidOperationException($"The path `{path}` has no matching parent device. Space check invalid.");
+            }
             return new FolderStorageInfo()
             {
                 Path = path,
-                FreeSpace = driveInfo.AvailableFreeSpace,
-                UsedSpace = driveInfo.TotalSize - driveInfo.AvailableFreeSpace,
-                StorageType = driveInfo.DriveType.ToString(),
-                DeviceId = driveInfo.Name,
+                ResolvedPath = resolvedPath,
+                FreeSpace = bestMatch.AvailableFreeSpace,
+                UsedSpace = bestMatch.TotalSize - bestMatch.AvailableFreeSpace,
+                StorageType = bestMatch.DriveType.ToString(),
+                DeviceId = bestMatch.Name,
             };
         }
         catch
@@ -60,6 +79,26 @@ public static class StorageHelper
     }
 
     /// <summary>
+    /// Walk a path and fully resolve any symlinks within it.
+    /// </summary>
+    private static string ResolvePath(string path)
+    {
+        var parts = path.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries);
+        var current = Path.DirectorySeparatorChar.ToString();
+        foreach (var part in parts)
+        {
+            current = Path.Combine(current, part);
+            var resolved = new DirectoryInfo(current).ResolveLinkTarget(returnFinalTarget: true);
+            if (resolved is not null)
+            {
+                current = resolved.FullName;
+            }
+        }
+
+        return current;
+    }
+
+    /// <summary>
     /// Gets the underlying drive data from a given path and checks if the available storage capacity matches the threshold.
     /// </summary>
     /// <param name="path">The path to a folder to evaluate.</param>