jellyfin-server/Emby.Server.Implementations/IO/ManagedFileSystem.cs

723 lines
25 KiB
C#
Raw Normal View History

2019-11-01 17:38:54 +00:00
#pragma warning disable CS1591
2019-12-10 23:13:57 +00:00
#pragma warning disable SA1600
2019-11-01 17:38:54 +00:00
using System;
2016-10-29 05:40:15 +00:00
using System.Collections.Generic;
2017-10-04 18:51:26 +00:00
using System.Diagnostics;
2020-01-13 06:25:54 +00:00
using System.Globalization;
2016-10-29 05:40:15 +00:00
using System.IO;
using System.Linq;
using System.Text;
using MediaBrowser.Common.Configuration;
2016-10-29 05:40:15 +00:00
using MediaBrowser.Model.IO;
2017-03-10 19:51:29 +00:00
using MediaBrowser.Model.System;
using Microsoft.Extensions.Logging;
using OperatingSystem = MediaBrowser.Common.System.OperatingSystem;
2016-10-29 05:40:15 +00:00
namespace Emby.Server.Implementations.IO
2016-10-29 05:40:15 +00:00
{
/// <summary>
2020-01-13 06:25:54 +00:00
/// Class ManagedFileSystem.
2016-10-29 05:40:15 +00:00
/// </summary>
public class ManagedFileSystem : IFileSystem
{
protected ILogger Logger;
private readonly List<IShortcutHandler> _shortcutHandlers = new List<IShortcutHandler>();
private readonly string _tempPath;
private readonly bool _isEnvironmentCaseInsensitive;
2017-04-02 00:36:06 +00:00
public ManagedFileSystem(
ILogger<ManagedFileSystem> logger,
IApplicationPaths applicationPaths)
2016-10-29 05:40:15 +00:00
{
Logger = logger;
_tempPath = applicationPaths.TempDirectory;
2017-03-18 23:37:29 +00:00
_isEnvironmentCaseInsensitive = OperatingSystem.Id == OperatingSystemId.Windows;
2018-09-12 17:26:21 +00:00
}
public virtual void AddShortcutHandler(IShortcutHandler handler)
2016-10-29 05:40:15 +00: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 20:37:13 +00:00
/// <exception cref="ArgumentNullException">filename</exception>
2016-10-29 05:40:15 +00:00
public virtual bool IsShortcut(string filename)
{
if (string.IsNullOrEmpty(filename))
{
throw new ArgumentNullException(nameof(filename));
2016-10-29 05:40:15 +00:00
}
var extension = Path.GetExtension(filename);
return _shortcutHandlers.Any(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Resolves the shortcut.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
2019-01-13 20:37:13 +00:00
/// <exception cref="ArgumentNullException">filename</exception>
2016-10-29 05:40:15 +00:00
public virtual string ResolveShortcut(string filename)
{
if (string.IsNullOrEmpty(filename))
{
throw new ArgumentNullException(nameof(filename));
2016-10-29 05:40:15 +00:00
}
var extension = Path.GetExtension(filename);
var handler = _shortcutHandlers.FirstOrDefault(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
return handler?.Resolve(filename);
2016-10-29 05:40:15 +00:00
}
public virtual string MakeAbsolutePath(string folderPath, string filePath)
2018-09-12 17:26:21 +00:00
{
2020-01-13 06:25:54 +00:00
// path is actually a stream
2020-01-13 08:09:22 +00:00
if (string.IsNullOrWhiteSpace(filePath) || filePath.Contains("://", StringComparison.Ordinal))
{
return filePath;
}
if (filePath.Length > 3 && filePath[1] == ':' && filePath[2] == '/')
{
2020-01-13 06:25:54 +00:00
// absolute local path
return filePath;
}
2018-09-12 17:26:21 +00:00
// unc path
2020-01-13 08:09:22 +00:00
if (filePath.StartsWith("\\\\", StringComparison.Ordinal))
2018-09-12 17:26:21 +00:00
{
return filePath;
}
var firstChar = filePath[0];
if (firstChar == '/')
{
2020-01-13 06:25:54 +00:00
// for this we don't really know
2018-09-12 17:26:21 +00:00
return filePath;
}
2020-01-13 06:25:54 +00:00
// relative path
if (firstChar == '\\')
2018-09-12 17:26:21 +00:00
{
filePath = filePath.Substring(1);
}
2020-01-13 06:25:54 +00:00
2018-09-12 17:26:21 +00:00
try
{
return Path.GetFullPath(Path.Combine(folderPath, filePath));
2018-09-12 17:26:21 +00:00
}
2018-12-20 12:11:26 +00:00
catch (ArgumentException)
2018-09-12 17:26:21 +00:00
{
return filePath;
}
catch (PathTooLongException)
{
return filePath;
}
catch (NotSupportedException)
{
return filePath;
}
}
2016-10-29 05:40:15 +00:00
/// <summary>
/// Creates the shortcut.
/// </summary>
/// <param name="shortcutPath">The shortcut path.</param>
/// <param name="target">The target.</param>
2020-01-13 06:25:54 +00:00
/// <exception cref="ArgumentNullException">The shortcutPath or target is null.</exception>
public virtual void CreateShortcut(string shortcutPath, string target)
2016-10-29 05:40:15 +00:00
{
if (string.IsNullOrEmpty(shortcutPath))
{
throw new ArgumentNullException(nameof(shortcutPath));
2016-10-29 05:40:15 +00:00
}
if (string.IsNullOrEmpty(target))
{
throw new ArgumentNullException(nameof(target));
2016-10-29 05:40:15 +00:00
}
var extension = Path.GetExtension(shortcutPath);
var handler = _shortcutHandlers.Find(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
2016-10-29 05:40:15 +00: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>
public virtual FileSystemMetadata GetFileSystemInfo(string path)
2016-10-29 05:40:15 +00: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>
public virtual FileSystemMetadata GetFileInfo(string path)
2016-10-29 05:40:15 +00: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>
public virtual FileSystemMetadata GetDirectoryInfo(string path)
2016-10-29 05:40:15 +00:00
{
var fileInfo = new DirectoryInfo(path);
return GetFileSystemMetadata(fileInfo);
}
private FileSystemMetadata GetFileSystemMetadata(FileSystemInfo info)
{
var result = new FileSystemMetadata
{
Exists = info.Exists,
FullName = info.FullName,
Extension = info.Extension,
Name = info.Name
};
2016-10-29 05:40:15 +00:00
if (result.Exists)
{
2018-09-12 17:26:21 +00:00
result.IsDirectory = info is DirectoryInfo || (info.Attributes & FileAttributes.Directory) == FileAttributes.Directory;
//if (!result.IsDirectory)
//{
// result.IsHidden = (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
//}
2016-10-29 05:40:15 +00:00
if (info is FileInfo fileInfo)
2016-10-29 05:40:15 +00:00
{
result.Length = fileInfo.Length;
result.DirectoryName = fileInfo.DirectoryName;
}
result.CreationTimeUtc = GetCreationTimeUtc(info);
result.LastWriteTimeUtc = GetLastWriteTimeUtc(info);
}
else
{
result.IsDirectory = info is DirectoryInfo;
}
return result;
}
private static ExtendedFileSystemInfo GetExtendedFileSystemInfo(string path)
2018-09-12 17:26:21 +00: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 05:40:15 +00:00
/// <summary>
2020-01-13 06:25:54 +00:00
/// Takes a filename and removes invalid characters.
2016-10-29 05:40:15 +00:00
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.String.</returns>
2020-01-13 06:25:54 +00:00
/// <exception cref="ArgumentNullException">The filename is null.</exception>
public virtual string GetValidFilename(string filename)
2016-10-29 05:40:15 +00:00
{
var builder = new StringBuilder(filename);
foreach (var c in Path.GetInvalidFileNameChars())
2016-10-29 05:40:15 +00:00
{
builder = builder.Replace(c, ' ');
2016-10-29 05:40:15 +00:00
}
return builder.ToString();
}
/// <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 12:11:26 +00:00
Logger.LogError(ex, "Error determining CreationTimeUtc for {FullName}", info.FullName);
2016-10-29 05:40:15 +00:00
return DateTime.MinValue;
}
}
/// <summary>
/// Gets the creation time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
public virtual DateTime GetCreationTimeUtc(string path)
2016-10-29 05:40:15 +00:00
{
return GetCreationTimeUtc(GetFileSystemInfo(path));
}
public virtual DateTime GetCreationTimeUtc(FileSystemMetadata info)
2016-10-29 05:40:15 +00:00
{
return info.CreationTimeUtc;
}
public virtual DateTime GetLastWriteTimeUtc(FileSystemMetadata info)
2016-10-29 05:40:15 +00: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 12:11:26 +00:00
Logger.LogError(ex, "Error determining LastAccessTimeUtc for {FullName}", info.FullName);
2016-10-29 05:40:15 +00:00
return DateTime.MinValue;
}
}
/// <summary>
/// Gets the last write time UTC.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>DateTime.</returns>
public virtual DateTime GetLastWriteTimeUtc(string path)
2016-10-29 05:40:15 +00:00
{
return GetLastWriteTimeUtc(GetFileSystemInfo(path));
}
public virtual void SetHidden(string path, bool isHidden)
2016-10-29 05:40:15 +00:00
{
if (OperatingSystem.Id != OperatingSystemId.Windows)
2017-11-26 04:48:12 +00:00
{
return;
}
2018-09-12 17:26:21 +00:00
var info = GetExtendedFileSystemInfo(path);
2016-10-29 05:40:15 +00:00
if (info.Exists && info.IsHidden != isHidden)
{
if (isHidden)
{
2016-10-31 04:28:23 +00:00
File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.Hidden);
2016-10-29 05:40:15 +00:00
}
else
{
2019-01-13 20:37:13 +00:00
var attributes = File.GetAttributes(path);
2016-10-31 04:28:23 +00:00
attributes = RemoveAttribute(attributes, FileAttributes.Hidden);
File.SetAttributes(path, attributes);
2016-10-29 05:40:15 +00:00
}
}
}
public virtual void SetReadOnly(string path, bool isReadOnly)
2016-11-09 17:24:57 +00:00
{
2020-01-13 06:25:54 +00:00
if (OperatingSystem.Id != OperatingSystemId.Windows)
2017-11-26 04:48:12 +00:00
{
return;
}
2018-09-12 17:26:21 +00:00
var info = GetExtendedFileSystemInfo(path);
2016-11-09 17:24:57 +00:00
if (info.Exists && info.IsReadOnly != isReadOnly)
{
if (isReadOnly)
{
File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.ReadOnly);
}
else
{
2019-01-13 20:37:13 +00:00
var attributes = File.GetAttributes(path);
2016-11-09 17:24:57 +00:00
attributes = RemoveAttribute(attributes, FileAttributes.ReadOnly);
File.SetAttributes(path, attributes);
}
}
}
public virtual void SetAttributes(string path, bool isHidden, bool isReadOnly)
2017-05-12 04:54:19 +00:00
{
2020-01-13 06:25:54 +00:00
if (OperatingSystem.Id != OperatingSystemId.Windows)
2017-11-26 04:48:12 +00:00
{
return;
}
2018-09-12 17:26:21 +00:00
var info = GetExtendedFileSystemInfo(path);
2017-05-12 04:54:19 +00: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 05:40:15 +00: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>
public virtual void SwapFiles(string file1, string file2)
2016-10-29 05:40:15 +00:00
{
if (string.IsNullOrEmpty(file1))
{
throw new ArgumentNullException(nameof(file1));
2016-10-29 05:40:15 +00:00
}
if (string.IsNullOrEmpty(file2))
{
throw new ArgumentNullException(nameof(file2));
2016-10-29 05:40:15 +00:00
}
var temp1 = Path.Combine(_tempPath, Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture));
2016-10-29 05:40:15 +00:00
// Copying over will fail against hidden files
2016-12-27 07:25:51 +00:00
SetHidden(file1, false);
SetHidden(file2, false);
2016-10-29 05:40:15 +00:00
2017-01-23 21:51:23 +00:00
Directory.CreateDirectory(_tempPath);
File.Copy(file1, temp1, true);
2016-10-29 05:40:15 +00:00
File.Copy(file2, file1, true);
File.Copy(temp1, file2, true);
2016-10-29 05:40:15 +00:00
}
public virtual bool ContainsSubPath(string parentPath, string path)
2016-10-29 05:40:15 +00:00
{
if (string.IsNullOrEmpty(parentPath))
{
throw new ArgumentNullException(nameof(parentPath));
2016-10-29 05:40:15 +00:00
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
2016-10-29 05:40:15 +00:00
}
var separatorChar = Path.DirectorySeparatorChar;
2017-04-02 04:08:07 +00:00
return path.IndexOf(parentPath.TrimEnd(separatorChar) + separatorChar, StringComparison.OrdinalIgnoreCase) != -1;
2016-10-29 05:40:15 +00:00
}
public virtual bool IsRootPath(string path)
2016-10-29 05:40:15 +00:00
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
2016-10-29 05:40:15 +00:00
}
var parent = Path.GetDirectoryName(path);
2016-10-29 05:40:15 +00:00
if (!string.IsNullOrEmpty(parent))
{
return false;
}
return true;
}
public virtual string NormalizePath(string path)
2016-10-29 05:40:15 +00:00
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
2016-10-29 05:40:15 +00:00
}
if (path.EndsWith(":\\", StringComparison.OrdinalIgnoreCase))
{
return path;
}
return path.TrimEnd(Path.DirectorySeparatorChar);
2016-10-29 05:40:15 +00:00
}
public virtual bool AreEqual(string path1, string path2)
2017-05-04 18:14:45 +00:00
{
if (path1 == null && path2 == null)
{
return true;
}
if (path1 == null || path2 == null)
{
return false;
}
return string.Equals(NormalizePath(path1), NormalizePath(path2), StringComparison.OrdinalIgnoreCase);
}
public virtual string GetFileNameWithoutExtension(FileSystemMetadata info)
2016-10-29 05:40:15 +00:00
{
if (info.IsDirectory)
{
return info.Name;
}
return Path.GetFileNameWithoutExtension(info.FullName);
}
public virtual bool IsPathFile(string path)
2016-10-29 05:40:15 +00: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 18:14:45 +00:00
2016-10-29 05:40:15 +00:00
return true;
}
public virtual void DeleteFile(string path)
2016-10-29 05:40:15 +00:00
{
2017-05-12 04:54:19 +00:00
SetAttributes(path, false, false);
2016-10-29 05:40:15 +00:00
File.Delete(path);
}
public virtual List<FileSystemMetadata> GetDrives()
2016-11-01 03:07:45 +00:00
{
2019-05-16 23:45:56 +00: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
return DriveInfo.GetDrives().Where(d => d.IsReady && d.TotalSize != 0 && d.DriveType != DriveType.Ram)
.Select(d => new FileSystemMetadata
2016-11-01 03:07:45 +00:00
{
Name = d.Name,
2016-11-01 03:07:45 +00:00
FullName = d.RootDirectory.FullName,
IsDirectory = true
}).ToList();
}
public virtual IEnumerable<FileSystemMetadata> GetDirectories(string path, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
2017-03-29 06:26:48 +00:00
return ToMetadata(new DirectoryInfo(path).EnumerateDirectories("*", searchOption));
2016-10-29 05:40:15 +00:00
}
public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, bool recursive = false)
2017-03-29 06:26:48 +00:00
{
2017-03-30 17:56:32 +00:00
return GetFiles(path, null, false, recursive);
2017-03-29 06:26:48 +00:00
}
public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, IReadOnlyList<string> extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
2017-03-29 06:26:48 +00: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
if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions != null && extensions.Count == 1)
2017-03-29 06:26:48 +00:00
{
return ToMetadata(new DirectoryInfo(path).EnumerateFiles("*" + extensions[0], searchOption));
}
var files = new DirectoryInfo(path).EnumerateFiles("*", searchOption);
if (extensions != null && extensions.Count > 0)
2017-03-29 06:26:48 +00:00
{
files = files.Where(i =>
{
var ext = i.Extension;
if (ext == null)
{
return false;
}
return extensions.Contains(ext, StringComparer.OrdinalIgnoreCase);
});
}
return ToMetadata(files);
2016-10-29 05:40:15 +00:00
}
public virtual IEnumerable<FileSystemMetadata> GetFileSystemEntries(string path, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var directoryInfo = new DirectoryInfo(path);
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
return ToMetadata(directoryInfo.EnumerateDirectories("*", searchOption))
.Concat(ToMetadata(directoryInfo.EnumerateFiles("*", searchOption)));
2016-10-29 05:40:15 +00:00
}
2017-03-29 06:26:48 +00:00
private IEnumerable<FileSystemMetadata> ToMetadata(IEnumerable<FileSystemInfo> infos)
2016-10-29 05:40:15 +00:00
{
2017-01-23 21:51:23 +00:00
return infos.Select(GetFileSystemMetadata);
2016-10-29 05:40:15 +00:00
}
public virtual IEnumerable<string> GetDirectoryPaths(string path, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
return Directory.EnumerateDirectories(path, "*", searchOption);
}
public virtual IEnumerable<string> GetFilePaths(string path, bool recursive = false)
2017-03-30 17:56:32 +00:00
{
return GetFilePaths(path, null, false, recursive);
}
public virtual IEnumerable<string> GetFilePaths(string path, string[] extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
2017-03-30 17:56:32 +00: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 17:26:21 +00:00
if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions != null && extensions.Length == 1)
2017-03-30 17:56:32 +00:00
{
return Directory.EnumerateFiles(path, "*" + extensions[0], searchOption);
}
var files = Directory.EnumerateFiles(path, "*", searchOption);
if (extensions != null && extensions.Length > 0)
{
files = files.Where(i =>
{
var ext = Path.GetExtension(i);
if (ext == null)
{
return false;
}
return extensions.Contains(ext, StringComparer.OrdinalIgnoreCase);
});
}
return files;
2016-10-29 05:40:15 +00:00
}
public virtual IEnumerable<string> GetFileSystemEntryPaths(string path, bool recursive = false)
2016-10-29 05:40:15 +00:00
{
var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
return Directory.EnumerateFileSystemEntries(path, "*", searchOption);
}
2016-11-11 07:24:36 +00:00
public virtual void SetExecutable(string path)
{
if (OperatingSystem.Id == OperatingSystemId.Darwin)
2017-10-04 18:51:26 +00:00
{
RunProcess("chmod", "+x \"" + path + "\"", Path.GetDirectoryName(path));
2017-10-04 18:51:26 +00:00
}
}
2017-03-29 06:26:48 +00:00
private static void RunProcess(string path, string args, string workingDirectory)
2017-10-04 18:51:26 +00:00
{
using (var process = Process.Start(new ProcessStartInfo
{
Arguments = args,
FileName = path,
CreateNoWindow = true,
WorkingDirectory = workingDirectory,
WindowStyle = ProcessWindowStyle.Normal
}))
{
process.WaitForExit();
}
2016-11-11 07:24:36 +00:00
}
2016-10-29 05:40:15 +00:00
}
}