< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.IO.ManagedFileSystem
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/IO/ManagedFileSystem.cs
Line coverage
50%
Covered lines: 131
Uncovered lines: 127
Coverable lines: 258
Total lines: 708
Line coverage: 50.7%
Branch coverage
50%
Covered branches: 45
Total branches: 90
Branch coverage: 50%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
IsShortcut(...)100%11100%
ResolveShortcut(...)0%620%
MakeAbsolutePath(...)66.66%301250%
CreateShortcut(...)0%620%
MoveDirectory(...)0%620%
GetFileSystemInfo(...)33.33%12644.44%
GetFileInfo(...)100%11100%
GetDirectoryInfo(...)100%11100%
GetFileSystemMetadata(...)75%11864.51%
GetValidFilename(...)100%22100%
GetCreationTimeUtc(...)100%1140%
GetCreationTimeUtc(...)100%210%
GetCreationTimeUtc(...)100%210%
GetLastWriteTimeUtc(...)100%210%
GetLastWriteTimeUtc(...)100%1140%
GetLastWriteTimeUtc(...)100%210%
SetHidden(...)0%7280%
SetAttributes(...)0%156120%
SwapFiles(...)100%210%
ContainsSubPath(...)50%22100%
AreEqual(...)50%22100%
GetFileNameWithoutExtension(...)0%620%
IsPathFile(...)75%4475%
DeleteFile(...)100%210%
GetDrives()100%210%
GetDirectories(...)100%210%
GetFiles(...)100%11100%
GetFiles(...)100%11100%
GetFiles(...)100%11100%
GetFiles(...)78.57%141488.23%
GetFileSystemEntries(...)100%11100%
ToMetadata(...)100%11100%
GetDirectoryPaths(...)100%11100%
GetFilePaths(...)100%11100%
GetFilePaths(...)83.33%471237.5%
GetFileSystemEntryPaths(...)100%1140%
DirectoryExists(...)100%210%
FileExists(...)100%210%
GetEnumerationOptions(...)100%11100%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/IO/ManagedFileSystem.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.IO;
 5using System.Linq;
 6using System.Security;
 7using Jellyfin.Extensions;
 8using MediaBrowser.Common.Configuration;
 9using MediaBrowser.Model.IO;
 10using Microsoft.Extensions.Logging;
 11
 12namespace Emby.Server.Implementations.IO
 13{
 14    /// <summary>
 15    /// Class ManagedFileSystem.
 16    /// </summary>
 17    public class ManagedFileSystem : IFileSystem
 18    {
 219        private static readonly bool _isEnvironmentCaseInsensitive = OperatingSystem.IsWindows();
 220        private static readonly char[] _invalidPathCharacters =
 221        {
 222            '\"', '<', '>', '|', '\0',
 223            (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10,
 224            (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20,
 225            (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30,
 226            (char)31, ':', '*', '?', '\\', '/'
 227        };
 28
 29        private readonly ILogger<ManagedFileSystem> _logger;
 30        private readonly List<IShortcutHandler> _shortcutHandlers;
 31        private readonly string _tempPath;
 32
 33        /// <summary>
 34        /// Initializes a new instance of the <see cref="ManagedFileSystem"/> class.
 35        /// </summary>
 36        /// <param name="logger">The <see cref="ILogger"/> instance to use.</param>
 37        /// <param name="applicationPaths">The <see cref="IApplicationPaths"/> instance to use.</param>
 38        /// <param name="shortcutHandlers">the <see cref="IShortcutHandler"/>'s to use.</param>
 39        public ManagedFileSystem(
 40            ILogger<ManagedFileSystem> logger,
 41            IApplicationPaths applicationPaths,
 42            IEnumerable<IShortcutHandler> shortcutHandlers)
 43        {
 4044            _logger = logger;
 4045            _tempPath = applicationPaths.TempDirectory;
 4046            _shortcutHandlers = shortcutHandlers.ToList();
 4047        }
 48
 49        /// <summary>
 50        /// Determines whether the specified filename is shortcut.
 51        /// </summary>
 52        /// <param name="filename">The filename.</param>
 53        /// <returns><c>true</c> if the specified filename is shortcut; otherwise, <c>false</c>.</returns>
 54        /// <exception cref="ArgumentNullException"><paramref name="filename"/> is <c>null</c>.</exception>
 55        public virtual bool IsShortcut(string filename)
 56        {
 14857            ArgumentException.ThrowIfNullOrEmpty(filename);
 58
 14859            var extension = Path.GetExtension(filename);
 14860            return _shortcutHandlers.Any(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase))
 61        }
 62
 63        /// <summary>
 64        /// Resolves the shortcut.
 65        /// </summary>
 66        /// <param name="filename">The filename.</param>
 67        /// <returns>System.String.</returns>
 68        /// <exception cref="ArgumentNullException"><paramref name="filename"/> is <c>null</c>.</exception>
 69        public virtual string? ResolveShortcut(string filename)
 70        {
 071            ArgumentException.ThrowIfNullOrEmpty(filename);
 72
 073            var extension = Path.GetExtension(filename);
 074            var handler = _shortcutHandlers.Find(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgno
 75
 076            return handler?.Resolve(filename);
 77        }
 78
 79        /// <inheritdoc />
 80        public virtual string MakeAbsolutePath(string folderPath, string filePath)
 81        {
 82            // path is actually a stream
 483            if (string.IsNullOrWhiteSpace(filePath))
 84            {
 085                return filePath;
 86            }
 87
 488            var isAbsolutePath = Path.IsPathRooted(filePath) && (!OperatingSystem.IsWindows() || filePath[0] != '\\');
 89
 490            if (isAbsolutePath)
 91            {
 92                // absolute local path
 193                return filePath;
 94            }
 95
 96            // unc path
 397            if (filePath.StartsWith(@"\\", StringComparison.Ordinal))
 98            {
 099                return filePath;
 100            }
 101
 3102            var filePathSpan = filePath.AsSpan();
 103
 104            // relative path on windows
 3105            if (filePath[0] == '\\')
 106            {
 0107                filePathSpan = filePathSpan.Slice(1);
 108            }
 109
 110            try
 111            {
 3112                return Path.GetFullPath(Path.Join(folderPath, filePathSpan));
 113            }
 0114            catch (ArgumentException)
 115            {
 0116                return filePath;
 117            }
 0118            catch (PathTooLongException)
 119            {
 0120                return filePath;
 121            }
 0122            catch (NotSupportedException)
 123            {
 0124                return filePath;
 125            }
 3126        }
 127
 128        /// <summary>
 129        /// Creates the shortcut.
 130        /// </summary>
 131        /// <param name="shortcutPath">The shortcut path.</param>
 132        /// <param name="target">The target.</param>
 133        /// <exception cref="ArgumentNullException">The shortcutPath or target is null.</exception>
 134        public virtual void CreateShortcut(string shortcutPath, string target)
 135        {
 0136            ArgumentException.ThrowIfNullOrEmpty(shortcutPath);
 0137            ArgumentException.ThrowIfNullOrEmpty(target);
 138
 0139            var extension = Path.GetExtension(shortcutPath);
 0140            var handler = _shortcutHandlers.Find(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgno
 141
 0142            if (handler is not null)
 143            {
 0144                handler.Create(shortcutPath, target);
 145            }
 146            else
 147            {
 0148                throw new NotImplementedException();
 149            }
 150        }
 151
 152        /// <inheritdoc />
 153        public void MoveDirectory(string source, string destination)
 154        {
 155            try
 156            {
 0157                Directory.Move(source, destination);
 0158            }
 0159            catch (IOException)
 160            {
 161                // Cross device move requires a copy
 0162                Directory.CreateDirectory(destination);
 0163                foreach (string file in Directory.GetFiles(source))
 164                {
 0165                    File.Copy(file, Path.Combine(destination, Path.GetFileName(file)), true);
 166                }
 167
 0168                Directory.Delete(source, true);
 0169            }
 0170        }
 171
 172        /// <summary>
 173        /// Returns a <see cref="FileSystemMetadata"/> object for the specified file or directory path.
 174        /// </summary>
 175        /// <param name="path">A path to a file or directory.</param>
 176        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
 177        /// <remarks>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
 178        /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and all other properties will refl
 179        public virtual FileSystemMetadata GetFileSystemInfo(string path)
 180        {
 181            // Take a guess to try and avoid two file system hits, but we'll double-check by calling Exists
 29182            if (Path.HasExtension(path))
 183            {
 0184                var fileInfo = new FileInfo(path);
 185
 0186                if (fileInfo.Exists)
 187                {
 0188                    return GetFileSystemMetadata(fileInfo);
 189                }
 190
 0191                return GetFileSystemMetadata(new DirectoryInfo(path));
 192            }
 193            else
 194            {
 29195                var fileInfo = new DirectoryInfo(path);
 196
 29197                if (fileInfo.Exists)
 198                {
 29199                    return GetFileSystemMetadata(fileInfo);
 200                }
 201
 0202                return GetFileSystemMetadata(new FileInfo(path));
 203            }
 204        }
 205
 206        /// <summary>
 207        /// Returns a <see cref="FileSystemMetadata"/> object for the specified file path.
 208        /// </summary>
 209        /// <param name="path">A path to a file.</param>
 210        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
 211        /// <remarks><para>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> ob
 212        /// <see cref="FileSystemMetadata.IsDirectory"/> property and the <see cref="FileSystemMetadata.Exists"/> proper
 213        /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></r
 214        public virtual FileSystemMetadata GetFileInfo(string path)
 215        {
 1216            var fileInfo = new FileInfo(path);
 217
 1218            return GetFileSystemMetadata(fileInfo);
 219        }
 220
 221        /// <summary>
 222        /// Returns a <see cref="FileSystemMetadata"/> object for the specified directory path.
 223        /// </summary>
 224        /// <param name="path">A path to a directory.</param>
 225        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
 226        /// <remarks><para>If the specified path points to a file, the returned <see cref="FileSystemMetadata"/> object'
 227        /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and the <see cref="FileSystemMetad
 228        /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></r
 229        public virtual FileSystemMetadata GetDirectoryInfo(string path)
 230        {
 121231            var fileInfo = new DirectoryInfo(path);
 232
 121233            return GetFileSystemMetadata(fileInfo);
 234        }
 235
 236        private FileSystemMetadata GetFileSystemMetadata(FileSystemInfo info)
 237        {
 329238            var result = new FileSystemMetadata
 329239            {
 329240                Exists = info.Exists,
 329241                FullName = info.FullName,
 329242                Extension = info.Extension,
 329243                Name = info.Name
 329244            };
 245
 329246            if (result.Exists)
 247            {
 329248                result.IsDirectory = info is DirectoryInfo || (info.Attributes & FileAttributes.Directory) == FileAttrib
 249
 250                // if (!result.IsDirectory)
 251                // {
 252                //    result.IsHidden = (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
 253                // }
 254
 329255                if (info is FileInfo fileInfo)
 256                {
 53257                    result.Length = fileInfo.Length;
 258
 259                    // Issue #2354 get the size of files behind symbolic links. Also Enum.HasFlag is bad as it boxes!
 53260                    if ((fileInfo.Attributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint)
 261                    {
 262                        try
 263                        {
 1264                            using (var fileHandle = File.OpenHandle(fileInfo.FullName, FileMode.Open, FileAccess.Read, F
 265                            {
 0266                                result.Length = RandomAccess.GetLength(fileHandle);
 0267                            }
 0268                        }
 1269                        catch (FileNotFoundException ex)
 270                        {
 271                            // Dangling symlinks cannot be detected before opening the file unfortunately...
 1272                            _logger.LogError(ex, "Reading the file size of the symlink at {Path} failed. Marking the fil
 1273                            result.Exists = false;
 1274                        }
 0275                        catch (UnauthorizedAccessException ex)
 276                        {
 0277                            _logger.LogError(ex, "Reading the file at {Path} failed due to a permissions exception.", fi
 0278                        }
 0279                        catch (IOException ex)
 280                        {
 281                            // IOException generally means the file is not accessible due to filesystem issues
 282                            // Catch this exception and mark the file as not exist to ignore it
 0283                            _logger.LogError(ex, "Reading the file at {Path} failed due to an IO Exception. Marking the 
 0284                            result.Exists = false;
 0285                        }
 286                    }
 287                }
 288
 329289                result.CreationTimeUtc = GetCreationTimeUtc(info);
 329290                result.LastWriteTimeUtc = GetLastWriteTimeUtc(info);
 291            }
 292            else
 293            {
 0294                result.IsDirectory = info is DirectoryInfo;
 295            }
 296
 329297            return result;
 298        }
 299
 300        /// <summary>
 301        /// Takes a filename and removes invalid characters.
 302        /// </summary>
 303        /// <param name="filename">The filename.</param>
 304        /// <returns>System.String.</returns>
 305        /// <exception cref="ArgumentNullException">The filename is null.</exception>
 306        public string GetValidFilename(string filename)
 307        {
 7308            var first = filename.IndexOfAny(_invalidPathCharacters);
 7309            if (first == -1)
 310            {
 311                // Fast path for clean strings
 4312                return filename;
 313            }
 314
 3315            return string.Create(
 3316                filename.Length,
 3317                (filename, _invalidPathCharacters, first),
 3318                (chars, state) =>
 3319                {
 3320                    state.filename.AsSpan().CopyTo(chars);
 3321
 3322                    chars[state.first++] = ' ';
 3323
 3324                    var len = chars.Length;
 3325                    foreach (var c in state._invalidPathCharacters)
 3326                    {
 3327                        for (int i = state.first; i < len; i++)
 3328                        {
 3329                            if (chars[i] == c)
 3330                            {
 3331                                chars[i] = ' ';
 3332                            }
 3333                        }
 3334                    }
 3335                });
 336        }
 337
 338        /// <summary>
 339        /// Gets the creation time UTC.
 340        /// </summary>
 341        /// <param name="info">The info.</param>
 342        /// <returns>DateTime.</returns>
 343        public DateTime GetCreationTimeUtc(FileSystemInfo info)
 344        {
 345            // This could throw an error on some file systems that have dates out of range
 346            try
 347            {
 329348                return info.CreationTimeUtc;
 349            }
 0350            catch (Exception ex)
 351            {
 0352                _logger.LogError(ex, "Error determining CreationTimeUtc for {FullName}", info.FullName);
 0353                return DateTime.MinValue;
 354            }
 329355        }
 356
 357        /// <inheritdoc />
 358        public virtual DateTime GetCreationTimeUtc(string path)
 359        {
 0360            return GetCreationTimeUtc(GetFileSystemInfo(path));
 361        }
 362
 363        /// <inheritdoc />
 364        public virtual DateTime GetCreationTimeUtc(FileSystemMetadata info)
 365        {
 0366            return info.CreationTimeUtc;
 367        }
 368
 369        /// <inheritdoc />
 370        public virtual DateTime GetLastWriteTimeUtc(FileSystemMetadata info)
 371        {
 0372            return info.LastWriteTimeUtc;
 373        }
 374
 375        /// <summary>
 376        /// Gets the creation time UTC.
 377        /// </summary>
 378        /// <param name="info">The info.</param>
 379        /// <returns>DateTime.</returns>
 380        public DateTime GetLastWriteTimeUtc(FileSystemInfo info)
 381        {
 382            // This could throw an error on some file systems that have dates out of range
 383            try
 384            {
 329385                return info.LastWriteTimeUtc;
 386            }
 0387            catch (Exception ex)
 388            {
 0389                _logger.LogError(ex, "Error determining LastAccessTimeUtc for {FullName}", info.FullName);
 0390                return DateTime.MinValue;
 391            }
 329392        }
 393
 394        /// <inheritdoc />
 395        public virtual DateTime GetLastWriteTimeUtc(string path)
 396        {
 0397            return GetLastWriteTimeUtc(GetFileSystemInfo(path));
 398        }
 399
 400        /// <inheritdoc />
 401        public virtual void SetHidden(string path, bool isHidden)
 402        {
 0403            if (!OperatingSystem.IsWindows())
 404            {
 0405                return;
 406            }
 407
 0408            var info = new FileInfo(path);
 409
 0410            if (info.Exists &&
 0411                (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden != isHidden)
 412            {
 0413                if (isHidden)
 414                {
 0415                    File.SetAttributes(path, info.Attributes | FileAttributes.Hidden);
 416                }
 417                else
 418                {
 0419                    File.SetAttributes(path, info.Attributes & ~FileAttributes.Hidden);
 420                }
 421            }
 0422        }
 423
 424        /// <inheritdoc />
 425        public virtual void SetAttributes(string path, bool isHidden, bool readOnly)
 426        {
 0427            if (!OperatingSystem.IsWindows())
 428            {
 0429                return;
 430            }
 431
 0432            var info = new FileInfo(path);
 433
 0434            if (!info.Exists)
 435            {
 0436                return;
 437            }
 438
 0439            if ((info.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly == readOnly
 0440                && (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden == isHidden)
 441            {
 0442                return;
 443            }
 444
 0445            var attributes = info.Attributes;
 446
 0447            if (readOnly)
 448            {
 0449                attributes |= FileAttributes.ReadOnly;
 450            }
 451            else
 452            {
 0453                attributes &= ~FileAttributes.ReadOnly;
 454            }
 455
 0456            if (isHidden)
 457            {
 0458                attributes |= FileAttributes.Hidden;
 459            }
 460            else
 461            {
 0462                attributes &= ~FileAttributes.Hidden;
 463            }
 464
 0465            File.SetAttributes(path, attributes);
 0466        }
 467
 468        /// <inheritdoc />
 469        public virtual void SwapFiles(string file1, string file2)
 470        {
 0471            ArgumentException.ThrowIfNullOrEmpty(file1);
 0472            ArgumentException.ThrowIfNullOrEmpty(file2);
 473
 0474            var temp1 = Path.Combine(_tempPath, Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture));
 475
 476            // Copying over will fail against hidden files
 0477            SetHidden(file1, false);
 0478            SetHidden(file2, false);
 479
 0480            Directory.CreateDirectory(_tempPath);
 0481            File.Copy(file1, temp1, true);
 482
 0483            File.Copy(file2, file1, true);
 0484            File.Move(temp1, file2, true);
 0485        }
 486
 487        /// <inheritdoc />
 488        public virtual bool ContainsSubPath(string parentPath, string path)
 489        {
 1490            ArgumentException.ThrowIfNullOrEmpty(parentPath);
 1491            ArgumentException.ThrowIfNullOrEmpty(path);
 492
 1493            return path.Contains(
 1494                Path.TrimEndingDirectorySeparator(parentPath) + Path.DirectorySeparatorChar,
 1495                _isEnvironmentCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
 496        }
 497
 498        /// <inheritdoc />
 499        public virtual bool AreEqual(string path1, string path2)
 500        {
 183501            return Path.TrimEndingDirectorySeparator(path1).Equals(
 183502                Path.TrimEndingDirectorySeparator(path2),
 183503                _isEnvironmentCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
 504        }
 505
 506        /// <inheritdoc />
 507        public virtual string GetFileNameWithoutExtension(FileSystemMetadata info)
 508        {
 0509            if (info.IsDirectory)
 510            {
 0511                return info.Name;
 512            }
 513
 0514            return Path.GetFileNameWithoutExtension(info.FullName);
 515        }
 516
 517        /// <inheritdoc />
 518        public virtual bool IsPathFile(string path)
 519        {
 2055520            if (path.Contains("://", StringComparison.OrdinalIgnoreCase)
 2055521                && !path.StartsWith("file://", StringComparison.OrdinalIgnoreCase))
 522            {
 0523                return false;
 524            }
 525
 2055526            return true;
 527        }
 528
 529        /// <inheritdoc />
 530        public virtual void DeleteFile(string path)
 531        {
 0532            SetAttributes(path, false, false);
 0533            File.Delete(path);
 0534        }
 535
 536        /// <inheritdoc />
 537        public virtual IEnumerable<FileSystemMetadata> GetDrives()
 538        {
 539            // check for ready state to avoid waiting for drives to timeout
 540            // some drives on linux have no actual size or are used for other purposes
 0541            return DriveInfo.GetDrives()
 0542                .Where(
 0543                    d => (d.DriveType == DriveType.Fixed || d.DriveType == DriveType.Network || d.DriveType == DriveType
 0544                         && d.IsReady
 0545                         && d.TotalSize != 0)
 0546                .Select(d => new FileSystemMetadata
 0547                {
 0548                    Name = d.Name,
 0549                    FullName = d.RootDirectory.FullName,
 0550                    IsDirectory = true
 0551                });
 552        }
 553
 554        /// <inheritdoc />
 555        public virtual IEnumerable<FileSystemMetadata> GetDirectories(string path, bool recursive = false)
 556        {
 0557            return ToMetadata(new DirectoryInfo(path).EnumerateDirectories("*", GetEnumerationOptions(recursive)));
 558        }
 559
 560        /// <inheritdoc />
 561        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, bool recursive = false)
 562        {
 1563            return GetFiles(path, "*", recursive);
 564        }
 565
 566        /// <inheritdoc />
 567        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, bool recursive = fals
 568        {
 1569            return GetFiles(path, searchPattern, null, false, recursive);
 570        }
 571
 572        /// <inheritdoc />
 573        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, IReadOnlyList<string>? extensions, bool ena
 574        {
 16575            return GetFiles(path, "*", extensions, enableCaseSensitiveExtensions, recursive);
 576        }
 577
 578        /// <inheritdoc />
 579        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, IReadOnlyList<string>
 580        {
 17581            var enumerationOptions = GetEnumerationOptions(recursive);
 582
 583            // On linux and macOS the search pattern is case-sensitive
 584            // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
 17585            if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions is not null && extensions
 586            {
 0587                searchPattern = searchPattern.EndsWith(extensions[0], StringComparison.Ordinal) ? searchPattern : search
 588
 0589                return ToMetadata(new DirectoryInfo(path).EnumerateFiles(searchPattern, enumerationOptions));
 590            }
 591
 17592            var files = new DirectoryInfo(path).EnumerateFiles(searchPattern, enumerationOptions);
 593
 17594            if (extensions is not null && extensions.Count > 0)
 595            {
 16596                files = files.Where(i =>
 16597                {
 16598                    var ext = i.Extension.AsSpan();
 16599                    if (ext.IsEmpty)
 16600                    {
 16601                        return false;
 16602                    }
 16603
 16604                    return extensions.Contains(ext, StringComparison.OrdinalIgnoreCase);
 16605                });
 606            }
 607
 17608            return ToMetadata(files);
 609        }
 610
 611        /// <inheritdoc />
 612        public virtual IEnumerable<FileSystemMetadata> GetFileSystemEntries(string path, bool recursive = false)
 613        {
 614            // Note: any of unhandled exceptions thrown by this method may cause the caller to believe the whole path is
 615            // But what causing the exception may be a single file under that path. This could lead to unexpected behavi
 616            // For example, the scanner will remove everything in that path due to unhandled errors.
 260617            var directoryInfo = new DirectoryInfo(path);
 260618            var enumerationOptions = GetEnumerationOptions(recursive);
 619
 260620            return ToMetadata(directoryInfo.EnumerateFileSystemInfos("*", enumerationOptions));
 621        }
 622
 623        private IEnumerable<FileSystemMetadata> ToMetadata(IEnumerable<FileSystemInfo> infos)
 624        {
 277625            return infos.Select(GetFileSystemMetadata);
 626        }
 627
 628        /// <inheritdoc />
 629        public virtual IEnumerable<string> GetDirectoryPaths(string path, bool recursive = false)
 630        {
 25631            return Directory.EnumerateDirectories(path, "*", GetEnumerationOptions(recursive));
 632        }
 633
 634        /// <inheritdoc />
 635        public virtual IEnumerable<string> GetFilePaths(string path, bool recursive = false)
 636        {
 3637            return GetFilePaths(path, null, false, recursive);
 638        }
 639
 640        /// <inheritdoc />
 641        public virtual IEnumerable<string> GetFilePaths(string path, string[]? extensions, bool enableCaseSensitiveExten
 642        {
 4643            var enumerationOptions = GetEnumerationOptions(recursive);
 644
 645            // On linux and macOS the search pattern is case-sensitive
 646            // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
 4647            if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions is not null && extensions
 648            {
 1649                return Directory.EnumerateFiles(path, "*" + extensions[0], enumerationOptions);
 650            }
 651
 3652            var files = Directory.EnumerateFiles(path, "*", enumerationOptions);
 653
 3654            if (extensions is not null && extensions.Length > 0)
 655            {
 0656                files = files.Where(i =>
 0657                {
 0658                    var ext = Path.GetExtension(i.AsSpan());
 0659                    if (ext.IsEmpty)
 0660                    {
 0661                        return false;
 0662                    }
 0663
 0664                    return extensions.Contains(ext, StringComparison.OrdinalIgnoreCase);
 0665                });
 666            }
 667
 3668            return files;
 669        }
 670
 671        /// <inheritdoc />
 672        public virtual IEnumerable<string> GetFileSystemEntryPaths(string path, bool recursive = false)
 673        {
 674            try
 675            {
 25676                return Directory.EnumerateFileSystemEntries(path, "*", GetEnumerationOptions(recursive));
 677            }
 0678            catch (Exception ex) when (ex is UnauthorizedAccessException or DirectoryNotFoundException or SecurityExcept
 679            {
 0680                _logger.LogError(ex, "Failed to enumerate path {Path}", path);
 0681                return Enumerable.Empty<string>();
 682            }
 25683        }
 684
 685        /// <inheritdoc />
 686        public virtual bool DirectoryExists(string path)
 687        {
 0688            return Directory.Exists(path);
 689        }
 690
 691        /// <inheritdoc />
 692        public virtual bool FileExists(string path)
 693        {
 0694            return File.Exists(path);
 695        }
 696
 697        private EnumerationOptions GetEnumerationOptions(bool recursive)
 698        {
 331699            return new EnumerationOptions
 331700            {
 331701                RecurseSubdirectories = recursive,
 331702                IgnoreInaccessible = true,
 331703                // Don't skip any files.
 331704                AttributesToSkip = 0
 331705            };
 706        }
 707    }
 708}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:20 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(Microsoft.Extensions.Logging.ILogger`1<Emby.Server.Implementations.IO.ManagedFileSystem>,MediaBrowser.Common.Configuration.IApplicationPaths,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.IO.IShortcutHandler>)
IsShortcut(System.String)
ResolveShortcut(System.String)
MakeAbsolutePath(System.String,System.String)
CreateShortcut(System.String,System.String)
MoveDirectory(System.String,System.String)
GetFileSystemInfo(System.String)
GetFileInfo(System.String)
GetDirectoryInfo(System.String)
GetFileSystemMetadata(System.IO.FileSystemInfo)
GetValidFilename(System.String)
GetCreationTimeUtc(System.IO.FileSystemInfo)
GetCreationTimeUtc(System.String)
GetCreationTimeUtc(MediaBrowser.Model.IO.FileSystemMetadata)
GetLastWriteTimeUtc(MediaBrowser.Model.IO.FileSystemMetadata)
GetLastWriteTimeUtc(System.IO.FileSystemInfo)
GetLastWriteTimeUtc(System.String)
SetHidden(System.String,System.Boolean)
SetAttributes(System.String,System.Boolean,System.Boolean)
SwapFiles(System.String,System.String)
ContainsSubPath(System.String,System.String)
AreEqual(System.String,System.String)
GetFileNameWithoutExtension(MediaBrowser.Model.IO.FileSystemMetadata)
IsPathFile(System.String)
DeleteFile(System.String)
GetDrives()
GetDirectories(System.String,System.Boolean)
GetFiles(System.String,System.Boolean)
GetFiles(System.String,System.String,System.Boolean)
GetFiles(System.String,System.Collections.Generic.IReadOnlyList`1<System.String>,System.Boolean,System.Boolean)
GetFiles(System.String,System.String,System.Collections.Generic.IReadOnlyList`1<System.String>,System.Boolean,System.Boolean)
GetFileSystemEntries(System.String,System.Boolean)
ToMetadata(System.Collections.Generic.IEnumerable`1<System.IO.FileSystemInfo>)
GetDirectoryPaths(System.String,System.Boolean)
GetFilePaths(System.String,System.Boolean)
GetFilePaths(System.String,System.String[],System.Boolean,System.Boolean)
GetFileSystemEntryPaths(System.String,System.Boolean)
DirectoryExists(System.String)
FileExists(System.String)
GetEnumerationOptions(System.Boolean)