2019-11-01 13:38:54 -04:00
#pragma warning disable CS1591
2019-01-06 15:50:43 -05:00
using System ;
2016-10-29 01:40:15 -04:00
using System.Collections.Generic ;
2020-01-13 01:25:54 -05:00
using System.Globalization ;
2016-10-29 01:40:15 -04:00
using System.IO ;
using System.Linq ;
2021-04-21 21:11:21 -04:00
using System.Runtime.InteropServices ;
2019-02-08 04:13:58 -05:00
using MediaBrowser.Common.Configuration ;
2016-10-29 01:40:15 -04:00
using MediaBrowser.Model.IO ;
2017-03-10 14:51:29 -05:00
using MediaBrowser.Model.System ;
2019-01-13 14:21:32 -05:00
using Microsoft.Extensions.Logging ;
2019-03-07 11:39:40 -05:00
using OperatingSystem = MediaBrowser . Common . System . OperatingSystem ;
2016-10-29 01:40:15 -04:00
2017-08-16 02:43:41 -04:00
namespace Emby.Server.Implementations.IO
2016-10-29 01:40:15 -04:00
{
/// <summary>
2020-01-13 01:25:54 -05:00
/// Class ManagedFileSystem.
2016-10-29 01:40:15 -04:00
/// </summary>
public class ManagedFileSystem : IFileSystem
{
2020-06-05 20:15:56 -04:00
protected ILogger < ManagedFileSystem > Logger ;
2016-10-29 01:40:15 -04:00
private readonly List < IShortcutHandler > _shortcutHandlers = new List < IShortcutHandler > ( ) ;
2019-02-08 04:13:58 -05:00
private readonly string _tempPath ;
2021-04-21 21:11:21 -04:00
private static readonly bool _isEnvironmentCaseInsensitive = RuntimeInformation . IsOSPlatform ( OSPlatform . Windows ) ;
2017-04-01 20:36:06 -04:00
2019-01-17 17:55:05 -05:00
public ManagedFileSystem (
2019-06-09 17:51:52 -04:00
ILogger < ManagedFileSystem > logger ,
2019-02-17 05:54:47 -05:00
IApplicationPaths applicationPaths )
2016-10-29 01:40:15 -04:00
{
2019-06-09 17:51:52 -04:00
Logger = logger ;
2019-02-08 04:13:58 -05:00
_tempPath = applicationPaths . TempDirectory ;
2018-09-12 13:26:21 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual void AddShortcutHandler ( IShortcutHandler handler )
2016-10-29 01:40:15 -04:00
{
_shortcutHandlers . Add ( handler ) ;
}
/// <summary>
/// Determines whether the specified filename is shortcut.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns><c>true</c> if the specified filename is shortcut; otherwise, <c>false</c>.</returns>
2019-01-13 15:37:13 -05:00
/// <exception cref="ArgumentNullException">filename</exception>
2016-10-29 01:40:15 -04:00
public virtual bool IsShortcut ( string filename )
{
if ( string . IsNullOrEmpty ( filename ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( filename ) ) ;
2016-10-29 01:40:15 -04:00
}
var extension = Path . GetExtension ( filename ) ;
2021-04-21 21:11:21 -04:00
return _shortcutHandlers . Any ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
2016-10-29 01:40:15 -04:00
}
/// <summary>
/// Resolves the shortcut.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
2019-01-13 15:37:13 -05:00
/// <exception cref="ArgumentNullException">filename</exception>
2021-05-20 15:28:18 -04:00
public virtual string? ResolveShortcut ( string filename )
2016-10-29 01:40:15 -04:00
{
if ( string . IsNullOrEmpty ( filename ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( filename ) ) ;
2016-10-29 01:40:15 -04:00
}
var extension = Path . GetExtension ( filename ) ;
2021-04-21 21:11:21 -04:00
var handler = _shortcutHandlers . Find ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
2016-10-29 01:40:15 -04:00
2019-03-28 18:19:56 -04:00
return handler ? . Resolve ( filename ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual string MakeAbsolutePath ( string folderPath , string filePath )
2018-09-12 13:26:21 -04:00
{
2020-01-13 01:25:54 -05:00
// path is actually a stream
2020-01-13 03:09:22 -05:00
if ( string . IsNullOrWhiteSpace ( filePath ) | | filePath . Contains ( "://" , StringComparison . Ordinal ) )
2019-03-28 18:19:56 -04:00
{
return filePath ;
}
if ( filePath . Length > 3 & & filePath [ 1 ] = = ':' & & filePath [ 2 ] = = '/' )
{
2020-01-13 01:25:54 -05:00
// absolute local path
return filePath ;
2019-03-28 18:19:56 -04:00
}
2018-09-12 13:26:21 -04:00
// unc path
2020-01-13 03:09:22 -05:00
if ( filePath . StartsWith ( "\\\\" , StringComparison . Ordinal ) )
2018-09-12 13:26:21 -04:00
{
return filePath ;
}
var firstChar = filePath [ 0 ] ;
if ( firstChar = = '/' )
{
2020-01-13 01:25:54 -05:00
// for this we don't really know
2018-09-12 13:26:21 -04:00
return filePath ;
}
2020-01-13 01:25:54 -05:00
// relative path
if ( firstChar = = '\\' )
2018-09-12 13:26:21 -04:00
{
filePath = filePath . Substring ( 1 ) ;
}
2020-01-13 01:25:54 -05:00
2018-09-12 13:26:21 -04:00
try
{
2020-01-08 04:05:07 -05:00
return Path . GetFullPath ( Path . Combine ( folderPath , filePath ) ) ;
2018-09-12 13:26:21 -04:00
}
2018-12-20 07:11:26 -05:00
catch ( ArgumentException )
2018-09-12 13:26:21 -04:00
{
return filePath ;
}
catch ( PathTooLongException )
{
return filePath ;
}
catch ( NotSupportedException )
{
return filePath ;
}
}
2016-10-29 01:40:15 -04:00
/// <summary>
/// Creates the shortcut.
/// </summary>
/// <param name="shortcutPath">The shortcut path.</param>
/// <param name="target">The target.</param>
2020-01-13 01:25:54 -05:00
/// <exception cref="ArgumentNullException">The shortcutPath or target is null.</exception>
2019-01-26 17:24:28 -05:00
public virtual void CreateShortcut ( string shortcutPath , string target )
2016-10-29 01:40:15 -04:00
{
if ( string . IsNullOrEmpty ( shortcutPath ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( shortcutPath ) ) ;
2016-10-29 01:40:15 -04:00
}
if ( string . IsNullOrEmpty ( target ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( target ) ) ;
2016-10-29 01:40:15 -04:00
}
var extension = Path . GetExtension ( shortcutPath ) ;
2019-03-28 18:19:56 -04:00
var handler = _shortcutHandlers . Find ( i = > string . Equals ( extension , i . Extension , StringComparison . OrdinalIgnoreCase ) ) ;
2016-10-29 01:40:15 -04:00
if ( handler ! = null )
{
handler . Create ( shortcutPath , target ) ;
}
else
{
throw new NotImplementedException ( ) ;
}
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified file or directory path.
/// </summary>
/// <param name="path">A path to a file or directory.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and all other properties will reflect the properties of the directory.</remarks>
2019-01-26 17:24:28 -05:00
public virtual FileSystemMetadata GetFileSystemInfo ( string path )
2016-10-29 01:40:15 -04:00
{
// Take a guess to try and avoid two file system hits, but we'll double-check by calling Exists
if ( Path . HasExtension ( path ) )
{
var fileInfo = new FileInfo ( path ) ;
if ( fileInfo . Exists )
{
return GetFileSystemMetadata ( fileInfo ) ;
}
return GetFileSystemMetadata ( new DirectoryInfo ( path ) ) ;
}
else
{
var fileInfo = new DirectoryInfo ( path ) ;
if ( fileInfo . Exists )
{
return GetFileSystemMetadata ( fileInfo ) ;
}
return GetFileSystemMetadata ( new FileInfo ( path ) ) ;
}
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified file path.
/// </summary>
/// <param name="path">A path to a file.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks><para>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property and the <see cref="FileSystemMetadata.Exists"/> property will both be set to false.</para>
/// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
2019-01-26 17:24:28 -05:00
public virtual FileSystemMetadata GetFileInfo ( string path )
2016-10-29 01:40:15 -04:00
{
var fileInfo = new FileInfo ( path ) ;
return GetFileSystemMetadata ( fileInfo ) ;
}
/// <summary>
/// Returns a <see cref="FileSystemMetadata"/> object for the specified directory path.
/// </summary>
/// <param name="path">A path to a directory.</param>
/// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
/// <remarks><para>If the specified path points to a file, the returned <see cref="FileSystemMetadata"/> object's
/// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and the <see cref="FileSystemMetadata.Exists"/> property will be set to false.</para>
/// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
2019-01-26 17:24:28 -05:00
public virtual FileSystemMetadata GetDirectoryInfo ( string path )
2016-10-29 01:40:15 -04:00
{
var fileInfo = new DirectoryInfo ( path ) ;
return GetFileSystemMetadata ( fileInfo ) ;
}
private FileSystemMetadata GetFileSystemMetadata ( FileSystemInfo info )
{
2019-03-28 18:19:56 -04:00
var result = new FileSystemMetadata
{
Exists = info . Exists ,
FullName = info . FullName ,
Extension = info . Extension ,
Name = info . Name
} ;
2016-10-29 01:40:15 -04:00
if ( result . Exists )
{
2018-09-12 13:26:21 -04:00
result . IsDirectory = info is DirectoryInfo | | ( info . Attributes & FileAttributes . Directory ) = = FileAttributes . Directory ;
2020-06-14 05:11:11 -04:00
// if (!result.IsDirectory)
2018-09-12 13:26:21 -04:00
//{
// result.IsHidden = (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
//}
2016-10-29 01:40:15 -04:00
2019-03-28 18:19:56 -04:00
if ( info is FileInfo fileInfo )
2016-10-29 01:40:15 -04:00
{
result . Length = fileInfo . Length ;
2020-05-31 18:40:02 -04:00
// Issue #2354 get the size of files behind symbolic links
2020-07-18 21:39:31 -04:00
if ( fileInfo . Attributes . HasFlag ( FileAttributes . ReparsePoint ) )
2020-05-31 18:40:02 -04:00
{
2021-04-09 17:02:36 -04:00
try
2020-05-31 18:40:02 -04:00
{
2021-04-09 17:02:36 -04:00
using ( Stream thisFileStream = File . OpenRead ( fileInfo . FullName ) )
{
result . Length = thisFileStream . Length ;
}
}
catch ( FileNotFoundException ex )
{
// Dangling symlinks cannot be detected before opening the file unfortunately...
2021-04-09 18:16:37 -04:00
Logger . LogError ( ex , "Reading the file size of the symlink at {Path} failed. Marking the file as not existing." , fileInfo . FullName ) ;
2021-04-09 17:02:36 -04:00
result . Exists = false ;
2020-05-31 18:40:02 -04:00
}
}
2016-10-29 01:40:15 -04:00
}
result . CreationTimeUtc = GetCreationTimeUtc ( info ) ;
result . LastWriteTimeUtc = GetLastWriteTimeUtc ( info ) ;
}
else
{
result . IsDirectory = info is DirectoryInfo ;
}
return result ;
}
2019-01-06 15:50:43 -05:00
private static ExtendedFileSystemInfo GetExtendedFileSystemInfo ( string path )
2018-09-12 13:26:21 -04:00
{
var result = new ExtendedFileSystemInfo ( ) ;
var info = new FileInfo ( path ) ;
if ( info . Exists )
{
result . Exists = true ;
var attributes = info . Attributes ;
result . IsHidden = ( attributes & FileAttributes . Hidden ) = = FileAttributes . Hidden ;
result . IsReadOnly = ( attributes & FileAttributes . ReadOnly ) = = FileAttributes . ReadOnly ;
}
return result ;
}
2016-10-29 01:40:15 -04:00
/// <summary>
2020-01-13 01:25:54 -05:00
/// Takes a filename and removes invalid characters.
2016-10-29 01:40:15 -04:00
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
2020-01-13 01:25:54 -05:00
/// <exception cref="ArgumentNullException">The filename is null.</exception>
2021-04-21 21:11:21 -04:00
public string GetValidFilename ( string filename )
2016-10-29 01:40:15 -04:00
{
2021-04-22 06:31:47 -04:00
var invalid = Path . GetInvalidFileNameChars ( ) ;
var first = filename . IndexOfAny ( invalid ) ;
if ( first = = - 1 )
{
// Fast path for clean strings
return filename ;
}
2021-04-21 21:11:21 -04:00
return string . Create (
filename . Length ,
2021-04-22 06:31:47 -04:00
( filename , invalid , first ) ,
2021-04-21 21:11:21 -04:00
( chars , state ) = >
{
2021-04-22 06:31:47 -04:00
state . filename . AsSpan ( ) . CopyTo ( chars ) ;
2021-04-21 21:11:21 -04:00
2021-04-22 06:31:47 -04:00
chars [ state . first + + ] = ' ' ;
2021-04-21 21:11:21 -04:00
var len = chars . Length ;
2021-04-22 06:31:47 -04:00
foreach ( var c in state . invalid )
2021-04-21 21:11:21 -04:00
{
2021-04-22 06:31:47 -04:00
for ( int i = state . first ; i < len ; i + + )
2021-04-21 21:11:21 -04:00
{
if ( chars [ i ] = = c )
{
chars [ i ] = ' ' ;
}
}
}
} ) ;
2016-10-29 01:40:15 -04:00
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>DateTime.</returns>
public DateTime GetCreationTimeUtc ( FileSystemInfo info )
{
// This could throw an error on some file systems that have dates out of range
try
{
return info . CreationTimeUtc ;
}
catch ( Exception ex )
{
2018-12-20 07:11:26 -05:00
Logger . LogError ( ex , "Error determining CreationTimeUtc for {FullName}" , info . FullName ) ;
2016-10-29 01:40:15 -04:00
return DateTime . MinValue ;
}
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
2019-01-26 17:24:28 -05:00
public virtual DateTime GetCreationTimeUtc ( string path )
2016-10-29 01:40:15 -04:00
{
return GetCreationTimeUtc ( GetFileSystemInfo ( path ) ) ;
}
2019-01-26 17:24:28 -05:00
public virtual DateTime GetCreationTimeUtc ( FileSystemMetadata info )
2016-10-29 01:40:15 -04:00
{
return info . CreationTimeUtc ;
}
2019-01-26 17:24:28 -05:00
public virtual DateTime GetLastWriteTimeUtc ( FileSystemMetadata info )
2016-10-29 01:40:15 -04:00
{
return info . LastWriteTimeUtc ;
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="info">The info.</param>
/// <returns>DateTime.</returns>
public DateTime GetLastWriteTimeUtc ( FileSystemInfo info )
{
// This could throw an error on some file systems that have dates out of range
try
{
return info . LastWriteTimeUtc ;
}
catch ( Exception ex )
{
2018-12-20 07:11:26 -05:00
Logger . LogError ( ex , "Error determining LastAccessTimeUtc for {FullName}" , info . FullName ) ;
2016-10-29 01:40:15 -04:00
return DateTime . MinValue ;
}
}
/// <summary>
/// Gets the last write time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
2019-01-26 17:24:28 -05:00
public virtual DateTime GetLastWriteTimeUtc ( string path )
2016-10-29 01:40:15 -04:00
{
return GetLastWriteTimeUtc ( GetFileSystemInfo ( path ) ) ;
}
2019-01-26 17:24:28 -05:00
public virtual void SetHidden ( string path , bool isHidden )
2016-10-29 01:40:15 -04:00
{
2020-01-13 01:34:50 -05:00
if ( OperatingSystem . Id ! = OperatingSystemId . Windows )
2017-11-25 23:48:12 -05:00
{
return ;
}
2018-09-12 13:26:21 -04:00
var info = GetExtendedFileSystemInfo ( path ) ;
2016-10-29 01:40:15 -04:00
if ( info . Exists & & info . IsHidden ! = isHidden )
{
if ( isHidden )
{
2016-10-31 00:28:23 -04:00
File . SetAttributes ( path , File . GetAttributes ( path ) | FileAttributes . Hidden ) ;
2016-10-29 01:40:15 -04:00
}
else
{
2019-01-13 15:37:13 -05:00
var attributes = File . GetAttributes ( path ) ;
2016-10-31 00:28:23 -04:00
attributes = RemoveAttribute ( attributes , FileAttributes . Hidden ) ;
File . SetAttributes ( path , attributes ) ;
2016-10-29 01:40:15 -04:00
}
}
}
2019-01-26 17:24:28 -05:00
public virtual void SetAttributes ( string path , bool isHidden , bool isReadOnly )
2017-05-12 00:54:19 -04:00
{
2020-01-13 01:25:54 -05:00
if ( OperatingSystem . Id ! = OperatingSystemId . Windows )
2017-11-25 23:48:12 -05:00
{
return ;
}
2018-09-12 13:26:21 -04:00
var info = GetExtendedFileSystemInfo ( path ) ;
2017-05-12 00:54:19 -04:00
if ( ! info . Exists )
{
return ;
}
if ( info . IsReadOnly = = isReadOnly & & info . IsHidden = = isHidden )
{
return ;
}
var attributes = File . GetAttributes ( path ) ;
if ( isReadOnly )
{
attributes = attributes | FileAttributes . ReadOnly ;
}
else
{
attributes = RemoveAttribute ( attributes , FileAttributes . ReadOnly ) ;
}
if ( isHidden )
{
attributes = attributes | FileAttributes . Hidden ;
}
else
{
attributes = RemoveAttribute ( attributes , FileAttributes . Hidden ) ;
}
File . SetAttributes ( path , attributes ) ;
}
2016-10-29 01:40:15 -04:00
private static FileAttributes RemoveAttribute ( FileAttributes attributes , FileAttributes attributesToRemove )
{
return attributes & ~ attributesToRemove ;
}
/// <summary>
/// Swaps the files.
/// </summary>
/// <param name="file1">The file1.</param>
/// <param name="file2">The file2.</param>
2019-01-26 17:24:28 -05:00
public virtual void SwapFiles ( string file1 , string file2 )
2016-10-29 01:40:15 -04:00
{
if ( string . IsNullOrEmpty ( file1 ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( file1 ) ) ;
2016-10-29 01:40:15 -04:00
}
if ( string . IsNullOrEmpty ( file2 ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( file2 ) ) ;
2016-10-29 01:40:15 -04:00
}
2019-02-28 17:22:57 -05:00
var temp1 = Path . Combine ( _tempPath , Guid . NewGuid ( ) . ToString ( "N" , CultureInfo . InvariantCulture ) ) ;
2016-10-29 01:40:15 -04:00
// Copying over will fail against hidden files
2016-12-27 02:25:51 -05:00
SetHidden ( file1 , false ) ;
SetHidden ( file2 , false ) ;
2016-10-29 01:40:15 -04:00
2017-01-23 16:51:23 -05:00
Directory . CreateDirectory ( _tempPath ) ;
2019-01-26 17:24:28 -05:00
File . Copy ( file1 , temp1 , true ) ;
2016-10-29 01:40:15 -04:00
2019-01-26 17:24:28 -05:00
File . Copy ( file2 , file1 , true ) ;
File . Copy ( temp1 , file2 , true ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual bool ContainsSubPath ( string parentPath , string path )
2016-10-29 01:40:15 -04:00
{
if ( string . IsNullOrEmpty ( parentPath ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( parentPath ) ) ;
2016-10-29 01:40:15 -04:00
}
if ( string . IsNullOrEmpty ( path ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( path ) ) ;
2016-10-29 01:40:15 -04:00
}
2021-04-01 13:39:00 -04:00
return path . Contains (
Path . TrimEndingDirectorySeparator ( parentPath ) + Path . DirectorySeparatorChar ,
_isEnvironmentCaseInsensitive ? StringComparison . OrdinalIgnoreCase : StringComparison . Ordinal ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual string NormalizePath ( string path )
2016-10-29 01:40:15 -04:00
{
if ( string . IsNullOrEmpty ( path ) )
{
2019-01-06 15:50:43 -05:00
throw new ArgumentNullException ( nameof ( path ) ) ;
2016-10-29 01:40:15 -04:00
}
if ( path . EndsWith ( ":\\" , StringComparison . OrdinalIgnoreCase ) )
{
return path ;
}
2021-04-01 13:39:00 -04:00
return Path . TrimEndingDirectorySeparator ( path ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual bool AreEqual ( string path1 , string path2 )
2017-05-04 14:14:45 -04:00
{
if ( path1 = = null & & path2 = = null )
{
return true ;
}
if ( path1 = = null | | path2 = = null )
{
return false ;
}
2021-04-01 13:39:00 -04:00
return string . Equals (
NormalizePath ( path1 ) ,
NormalizePath ( path2 ) ,
_isEnvironmentCaseInsensitive ? StringComparison . OrdinalIgnoreCase : StringComparison . Ordinal ) ;
2017-05-04 14:14:45 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual string GetFileNameWithoutExtension ( FileSystemMetadata info )
2016-10-29 01:40:15 -04:00
{
if ( info . IsDirectory )
{
return info . Name ;
}
return Path . GetFileNameWithoutExtension ( info . FullName ) ;
}
2019-01-26 17:24:28 -05:00
public virtual bool IsPathFile ( string path )
2016-10-29 01:40:15 -04:00
{
// Cannot use Path.IsPathRooted because it returns false under mono when using windows-based paths, e.g. C:\\
if ( path . IndexOf ( "://" , StringComparison . OrdinalIgnoreCase ) ! = - 1 & &
! path . StartsWith ( "file://" , StringComparison . OrdinalIgnoreCase ) )
{
return false ;
}
2017-05-04 14:14:45 -04:00
2016-10-29 01:40:15 -04:00
return true ;
}
2019-01-26 17:24:28 -05:00
public virtual void DeleteFile ( string path )
2016-10-29 01:40:15 -04:00
{
2017-05-12 00:54:19 -04:00
SetAttributes ( path , false , false ) ;
2016-10-29 01:40:15 -04:00
File . Delete ( path ) ;
}
2019-02-08 04:13:58 -05:00
2019-01-26 17:24:28 -05:00
public virtual List < FileSystemMetadata > GetDrives ( )
2016-10-31 23:07:45 -04:00
{
2019-05-16 19:45:56 -04:00
// check for ready state to avoid waiting for drives to timeout
// some drives on linux have no actual size or are used for other purposes
2019-06-03 00:49:12 -04:00
return DriveInfo . GetDrives ( ) . Where ( d = > d . IsReady & & d . TotalSize ! = 0 & & d . DriveType ! = DriveType . Ram )
. Select ( d = > new FileSystemMetadata
2020-03-24 11:12:06 -04:00
{
Name = d . Name ,
FullName = d . RootDirectory . FullName ,
IsDirectory = true
} ) . ToList ( ) ;
2016-10-31 23:07:45 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < FileSystemMetadata > GetDirectories ( string path , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
2020-12-31 21:40:24 -05:00
return ToMetadata ( new DirectoryInfo ( path ) . EnumerateDirectories ( "*" , GetEnumerationOptions ( recursive ) ) ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < FileSystemMetadata > GetFiles ( string path , bool recursive = false )
2017-03-29 02:26:48 -04:00
{
2017-03-30 13:56:32 -04:00
return GetFiles ( path , null , false , recursive ) ;
2017-03-29 02:26:48 -04:00
}
2021-05-20 15:28:18 -04:00
public virtual IEnumerable < FileSystemMetadata > GetFiles ( string path , IReadOnlyList < string > ? extensions , bool enableCaseSensitiveExtensions , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
2020-12-31 21:40:24 -05:00
var enumerationOptions = GetEnumerationOptions ( recursive ) ;
2016-10-29 01:40:15 -04:00
2017-03-29 02:26:48 -04:00
// On linux and osx the search pattern is case sensitive
// If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
2019-03-07 09:54:30 -05:00
if ( ( enableCaseSensitiveExtensions | | _isEnvironmentCaseInsensitive ) & & extensions ! = null & & extensions . Count = = 1 )
2017-03-29 02:26:48 -04:00
{
2020-12-31 21:40:24 -05:00
return ToMetadata ( new DirectoryInfo ( path ) . EnumerateFiles ( "*" + extensions [ 0 ] , enumerationOptions ) ) ;
2017-03-29 02:26:48 -04:00
}
2020-12-31 21:40:24 -05:00
var files = new DirectoryInfo ( path ) . EnumerateFiles ( "*" , enumerationOptions ) ;
2017-03-29 02:26:48 -04:00
2019-03-07 09:54:30 -05:00
if ( extensions ! = null & & extensions . Count > 0 )
2017-03-29 02:26:48 -04:00
{
files = files . Where ( i = >
{
var ext = i . Extension ;
if ( ext = = null )
{
return false ;
}
2020-06-15 17:43:52 -04:00
2017-03-29 02:26:48 -04:00
return extensions . Contains ( ext , StringComparer . OrdinalIgnoreCase ) ;
} ) ;
}
return ToMetadata ( files ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < FileSystemMetadata > GetFileSystemEntries ( string path , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
var directoryInfo = new DirectoryInfo ( path ) ;
2020-12-31 21:40:24 -05:00
var enumerationOptions = GetEnumerationOptions ( recursive ) ;
2016-10-29 01:40:15 -04:00
2020-12-31 21:40:24 -05:00
return ToMetadata ( directoryInfo . EnumerateDirectories ( "*" , enumerationOptions ) )
. Concat ( ToMetadata ( directoryInfo . EnumerateFiles ( "*" , enumerationOptions ) ) ) ;
2016-10-29 01:40:15 -04:00
}
2017-03-29 02:26:48 -04:00
private IEnumerable < FileSystemMetadata > ToMetadata ( IEnumerable < FileSystemInfo > infos )
2016-10-29 01:40:15 -04:00
{
2017-01-23 16:51:23 -05:00
return infos . Select ( GetFileSystemMetadata ) ;
2016-10-29 01:40:15 -04:00
}
2019-02-08 04:13:58 -05:00
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < string > GetDirectoryPaths ( string path , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
2020-12-31 21:40:24 -05:00
return Directory . EnumerateDirectories ( path , "*" , GetEnumerationOptions ( recursive ) ) ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < string > GetFilePaths ( string path , bool recursive = false )
2017-03-30 13:56:32 -04:00
{
return GetFilePaths ( path , null , false , recursive ) ;
}
2021-05-20 15:28:18 -04:00
public virtual IEnumerable < string > GetFilePaths ( string path , string [ ] ? extensions , bool enableCaseSensitiveExtensions , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
2020-12-31 21:40:24 -05:00
var enumerationOptions = GetEnumerationOptions ( recursive ) ;
2017-03-30 13:56:32 -04:00
// On linux and osx the search pattern is case sensitive
// If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
2018-09-12 13:26:21 -04:00
if ( ( enableCaseSensitiveExtensions | | _isEnvironmentCaseInsensitive ) & & extensions ! = null & & extensions . Length = = 1 )
2017-03-30 13:56:32 -04:00
{
2020-12-31 21:40:24 -05:00
return Directory . EnumerateFiles ( path , "*" + extensions [ 0 ] , enumerationOptions ) ;
2017-03-30 13:56:32 -04:00
}
2020-12-31 21:40:24 -05:00
var files = Directory . EnumerateFiles ( path , "*" , enumerationOptions ) ;
2017-03-30 13:56:32 -04:00
if ( extensions ! = null & & extensions . Length > 0 )
{
files = files . Where ( i = >
{
var ext = Path . GetExtension ( i ) ;
if ( ext = = null )
{
return false ;
}
2020-06-15 17:43:52 -04:00
2017-03-30 13:56:32 -04:00
return extensions . Contains ( ext , StringComparer . OrdinalIgnoreCase ) ;
} ) ;
}
return files ;
2016-10-29 01:40:15 -04:00
}
2019-01-26 17:24:28 -05:00
public virtual IEnumerable < string > GetFileSystemEntryPaths ( string path , bool recursive = false )
2016-10-29 01:40:15 -04:00
{
2020-12-31 21:40:24 -05:00
return Directory . EnumerateFileSystemEntries ( path , "*" , GetEnumerationOptions ( recursive ) ) ;
}
private EnumerationOptions GetEnumerationOptions ( bool recursive )
{
return new EnumerationOptions
{
RecurseSubdirectories = recursive ,
2021-02-02 09:14:11 -05:00
IgnoreInaccessible = true ,
// Don't skip any files.
AttributesToSkip = 0
2020-12-31 21:40:24 -05:00
} ;
2016-10-29 01:40:15 -04:00
}
}
}