/// <summary>
/// Initializes a new instance of a LocalFileSystem with the given physical root path.
/// </summary>
public LocalFileSystem(string root)
{
Guard.NotEmpty(root, nameof(root));
_filters = ExclusionFilters.Sensitive;
_provider = new PhysicalFileProvider(root, _filters);
}
/// <summary>
/// Add a filter
/// </summary>
/// <param name="processAssemblyClassFilter">Filter is of the format (+ or -)<processFilter>[assemblyFilter]classFilter, wildcards are allowed. <br/>
/// i.e. -[mscorlib], -[System.*]*, +[App.*]*, +[*]*
/// </param>
public void AddFilter(string processAssemblyClassFilter)
{
string assemblyFilter;
string classFilter;
string processFilter;
FilterType filterType;
GetAssemblyClassName(processAssemblyClassFilter, RegExFilters, out filterType, out assemblyFilter, out classFilter, out processFilter);
try
{
if (!RegExFilters)
{
processFilter = ValidateAndEscape((string.IsNullOrEmpty(processFilter) ? "*" : processFilter), "<>|\"", "process"); // Path.GetInvalidPathChars except *?
assemblyFilter = ValidateAndEscape(assemblyFilter, @"\[]", "assembly");
classFilter = ValidateAndEscape(classFilter, @"\[]", "class/type");
}
var filter = new AssemblyAndClassFilter(processFilter, assemblyFilter, classFilter);
if (filterType == FilterType.Inclusion)
{
InclusionFilters.Add(filter);
}
if (filterType == FilterType.Exclusion)
{
ExclusionFilters.Add(filter);
}
}
catch (Exception)
{
HandleInvalidFilterFormat(processAssemblyClassFilter);
}
}
/// <summary>
/// Initializes a new instance of a PhysicalFileProvider at the given root directory.
/// </summary>
/// <param name="root">The root directory. This should be an absolute path.</param>
/// <param name="filters">Specifies which files or directories are excluded.</param>
public TemplateFileProvider(string root, ExclusionFilters filters)
{
if (!Path.IsPathRooted(root))
{
throw new ArgumentException("The path must be absolute.", nameof(root));
}
var fullRoot = Path.GetFullPath(root);
// When we do matches in GetFullPath, we want to only match full directory names.
if (fullRoot.EndsWith("/"))
{
Root = fullRoot;
}
else
{
Root = fullRoot + "/";
}
if (!Directory.Exists(Root))
{
throw new DirectoryNotFoundException(Root);
}
_filters = filters;
}
/// <summary>
/// Initializes an instance of <see cref="PhysicalDirectoryContents"/>
/// </summary>
/// <param name="directory">The directory</param>
/// <param name="filters">Specifies which files or directories are excluded from enumeration.</param>
public PhysicalDirectoryContents(string directory, ExclusionFilters filters)
{
ThrowHelper.ThrowIfNull(directory);
_directory = directory;
_filters = filters;
}
/// <summary>
/// Initializes an instance of <see cref="PhysicalFilesWatcher" /> that watches files in <paramref name="root" />.
/// Wraps an instance of <see cref="System.IO.FileSystemWatcher" />
/// </summary>
/// <param name="root">Root directory for the watcher</param>
/// <param name="fileSystemWatcher">The wrapped watcher that is watching <paramref name="root" /></param>
/// <param name="pollForChanges">
/// True when the watcher should use polling to trigger instances of
/// <see cref="IChangeToken" /> created by <see cref="CreateFileChangeToken(string)" />
/// </param>
/// <param name="filters">Specifies which files or directories are excluded. Notifications of changes to are not raised to these.</param>
public PhysicalFilesWatcher(
string root,
FileSystemWatcher fileSystemWatcher,
bool pollForChanges,
ExclusionFilters filters)
{
if (fileSystemWatcher == null && !pollForChanges)
{
throw new ArgumentNullException(nameof(fileSystemWatcher), SR.Error_FileSystemWatcherRequiredWithoutPolling);
}
_root = root;
if (fileSystemWatcher != null)
{
_fileWatcher = fileSystemWatcher;
_fileWatcher.IncludeSubdirectories = true;
_fileWatcher.Created += OnChanged;
_fileWatcher.Changed += OnChanged;
_fileWatcher.Renamed += OnRenamed;
_fileWatcher.Deleted += OnChanged;
_fileWatcher.Error += OnError;
}
PollForChanges = pollForChanges;
_filters = filters;
PollingChangeTokens = new ConcurrentDictionary <IPollingChangeToken, IPollingChangeToken>();
_timerFactory = () => NonCapturingTimer.Create(RaiseChangeEvents, state: PollingChangeTokens, dueTime: TimeSpan.Zero, period: DefaultPollingInterval);
}
/// <summary>
/// Should we instrument this asssembly
/// </summary>
/// <param name="processName"></param>
/// <returns></returns>
public bool InstrumentProcess(string processName)
{
if (string.IsNullOrEmpty(processName))
{
return(false);
}
if (!ExclusionFilters.Any() && !InclusionFilters.Any())
{
return(true);
}
if (IsProcessExcluded(processName))
{
return(false);
}
if (InclusionFilters.Any())
{
var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForProcessName(processName);
return(matchingInclusionFilters.Any());
}
return(true); // not excluded and no inclusion filters
}
/// <summary>
/// Add a filter
/// </summary>
/// <param name="assemblyClassName">A filter is of the format (+ or -)[assemblyName]className, wildcards are allowed. <br/>
/// i.e. -[mscorlib], -[System.*]*, +[App.*]*, +[*]*
/// </param>
public void AddFilter(string assemblyClassName)
{
string assemblyName;
string className;
string processName;
FilterType filterType;
GetAssemblyClassName(assemblyClassName, RegExFilters, out filterType, out assemblyName, out className, out processName);
if (!RegExFilters)
{
processName = (string.IsNullOrEmpty(processName) ? "*" : processName).ValidateAndEscape("/?\"<>|}{");
assemblyName = assemblyName.ValidateAndEscape();
className = className.ValidateAndEscape();
}
var filter = new AssemblyAndClassFilter(processName, assemblyName, className);
if (filterType == FilterType.Inclusion)
{
InclusionFilters.Add(filter);
}
if (filterType == FilterType.Exclusion)
{
ExclusionFilters.Add(filter);
}
}
public void AddFilter(string assemblyClassName)
{
string assemblyName;
string className;
FilterType filterType;
GetAssemblyClassName(assemblyClassName, RegExFilters, out filterType, out assemblyName, out className);
if (!RegExFilters)
{
assemblyName = assemblyName.ValidateAndEscape();
className = className.ValidateAndEscape();
}
var filter = new AssemblyAndClassFilter(assemblyName, className);
if (filterType == FilterType.Inclusion)
{
InclusionFilters.Add(filter);
}
if (filterType == FilterType.Exclusion)
{
ExclusionFilters.Add(filter);
}
}
/// <summary>
/// æž„é€ ä¸€ä¸ª <see cref="PhysicalStorageDirectoryContents"/>。
/// </summary>
/// <param name="directory">给定的目录。</param>
/// <param name="filters">指定排除哪些文件或目录。</param>
public PhysicalStorageDirectoryContents(string directory, ExclusionFilters filters)
{
_directory = directory.NotEmpty(nameof(directory));
_filters = filters;
Exists = Directory.Exists(_directory);
}
public bool InstrumentClass(string assemblyName, string className)
{
if (string.IsNullOrEmpty(assemblyName) || string.IsNullOrEmpty(className))
{
return(false);
}
var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
{
return(false);
}
if (matchingExclusionFilters
.Where(exclusionFilter => exclusionFilter.ClassName != ".*")
.Any(exclusionFilter => exclusionFilter.IsMatchingClassName(className)))
{
return(false);
}
var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingInclusionFilters.Any(inclusionFilter => inclusionFilter.IsMatchingClassName(className)))
{
return(true);
}
return(false);
}
private bool ExcludeProcessOrAssembly(string processName, string assemblyName, out IList <AssemblyAndClassFilter> matchingExclusionFilters)
{
matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
return(matchingExclusionFilters.Any(
exclusionFilter =>
exclusionFilter.ClassName == ".*" &&
(exclusionFilter.IsMatchingProcessName(processName))));
}
private static PhysicalFilesWatcher CreateFileWatcher(string root, ExclusionFilters filters)
{
string environmentVariable = Environment.GetEnvironmentVariable("DOTNET_USE_POLLING_FILE_WATCHER");
bool pollForChanges = string.Equals(environmentVariable, "1", StringComparison.Ordinal) || string.Equals(environmentVariable, "true", StringComparison.OrdinalIgnoreCase);
root = PathUtils.EnsureTrailingSlash(Path.GetFullPath(root));
return(new PhysicalFilesWatcher(root, new FileSystemWatcher(root), pollForChanges, filters));
}
public static PhysicalFileProvider Create(string root, ExclusionFilters filters)
{
if (!Directory.Exists(root))
{
_ = Directory.CreateDirectory(root);
}
return(new PhysicalFileProvider(root, filters));
}
public void FiltersExcludedFiles(string filename, FileAttributes attributes, ExclusionFilters filters, bool excluded)
{
var fileInfo = new FileInfo(Path.Combine(_fileSystem.RootPath, filename));
_fileSystem.CreateFile(fileInfo);
fileInfo.Attributes = attributes;
Assert.Equal(excluded, FileSystemInfoHelper.IsExcluded(_fileSystem.GetFile(filename), filters));
}
/// <summary>Creates file watcher.</summary>
/// <param name="root"> The root directory. This should be an absolute path. </param>
/// <param name="filters"> Specifies which files or directories are excluded. </param>
/// <returns>The new file watcher.</returns>
private static PhysicalFilesWatcher CreateFileWatcher(string root, ExclusionFilters filters)
{
var environmentValue = Environment.GetEnvironmentVariable(PollingEnvironmentKey);
var pollForChanges = string.Equals(environmentValue, "1", StringComparison.Ordinal) ||
string.Equals(environmentValue, "true", StringComparison.OrdinalIgnoreCase);
root = PathUtils.EnsureTrailingSlash(Path.GetFullPath(root));
return(new PhysicalFilesWatcher(root, new FileSystemWatcher(root), pollForChanges, filters));
}
private bool IsProcessExcluded(string processName)
{
if (!ExclusionFilters.Any())
{
return(false);
}
var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForProcessName(processName);
// Excluded by all filters
return(matchingExclusionFilters.Any(exclusionFilter => (exclusionFilter.AssemblyName == ".*" && exclusionFilter.ClassName == ".*")));
}
public static void AddPhysical(
[NotNull] this VirtualFileSetList list,
[NotNull] string root,
ExclusionFilters exclusionFilters = ExclusionFilters.Sensitive)
{
Check.NotNull(list, nameof(list));
Check.NotNullOrWhiteSpace(root, nameof(root));
var fileProvider = new PhysicalFileProvider(root, exclusionFilters);
list.Add(new PhysicalVirtualFileSetInfo(fileProvider, root));
}
public void FiltersExcludedFiles(string filename, FileAttributes attributes, ExclusionFilters filters, bool excluded)
{
using var fileSystem = new TempDirectory(GetTestFilePath());
var fileInfo = new FileInfo(Path.Combine(fileSystem.Path, filename));
using (var stream = fileInfo.Create())
using (var writer = new StreamWriter(stream))
{
writer.Write("temp");
}
fileInfo.Attributes = attributes;
Assert.Equal(excluded, FileSystemInfoHelper.IsExcluded(fileInfo, filters));
}
private PhysicalFileProvider(string root, PhysicalFilesWatcher physicalFilesWatcher, ExclusionFilters filters)
{
if (!Path.IsPathRooted(root))
{
throw new ArgumentException("The path must be absolute.", nameof(root));
}
Root = PathUtils.EnsureTrailingSlash(Path.GetFullPath(root));
if (!Directory.Exists(Root))
{
throw new DirectoryNotFoundException(Root);
}
_filesWatcher = physicalFilesWatcher;
_filters = filters;
}
/// <summary>
/// Should we instrument this asssembly
/// </summary>
/// <param name="processPath"></param>
/// <returns></returns>
public bool InstrumentProcess(string processPath)
{
if (string.IsNullOrEmpty(processPath))
{
return(false);
}
if (!ExclusionFilters.Any() && !InclusionFilters.Any())
{
return(true);
}
var processName = Path.GetFileNameWithoutExtension(processPath); // can return null!
if (ExclusionFilters.Any())
{
var matchingExclusionFilters = new List <AssemblyAndClassFilter>(ExclusionFilters.GetMatchingFiltersForProcessName(processPath));
if (!string.IsNullOrWhiteSpace(processName) && processName != processPath)
{
matchingExclusionFilters.AddRange(ExclusionFilters.GetMatchingFiltersForProcessName(processName));
}
if (matchingExclusionFilters.Any
(exclusionFilter =>
// class-filter is .* and assembly-filter is matching processName
// this does not match default exclude filters like {.*}[mscorlib].* or {.*}[system].*
// but does match {.*}[.*].* or {.*}[processNa*].* or {.*}[processName].* where assemblyName == processName
exclusionFilter.ClassName == ".*" && exclusionFilter.IsMatchingAssemblyName(processName)
)
)
{
return(false);
}
}
if (InclusionFilters.Any())
{
var matchingInclusionFilters = new List <AssemblyAndClassFilter>(InclusionFilters.GetMatchingFiltersForProcessName(processPath));
if (!string.IsNullOrWhiteSpace(processName) && processName != processPath)
{
matchingInclusionFilters.AddRange(InclusionFilters.GetMatchingFiltersForProcessName(processName));
}
return(matchingInclusionFilters.Any());
}
return(true); // not excluded and no inclusion filters
}
/// <summary>Constructor.</summary>
/// <exception cref="ArgumentException"> Thrown when one or more arguments have
/// unsupported or illegal values. </exception>
/// <exception cref="DirectoryNotFoundException"> Thrown when the requested directory is not
/// present. </exception>
/// <param name="root"> The root directory. This should be an absolute path. </param>
/// <param name="physicalFilesWatcher"> The physical files watcher. </param>
/// <param name="filters"> Specifies which files or directories are excluded. </param>
private LanguageAwarePhysicalFileProvider(string root, PhysicalFilesWatcher physicalFilesWatcher, ExclusionFilters filters)
{
if (!Path.IsPathRooted(root))
{
throw new ArgumentException("The path must be absolute.", nameof(root));
}
var fullRoot = Path.GetFullPath(root);
// When we do matches in GetFullPath, we want to only match full directory names.
Root = PathUtils.EnsureTrailingSlash(fullRoot);
if (!Directory.Exists(Root))
{
throw new DirectoryNotFoundException(Root);
}
_filesWatcher = physicalFilesWatcher;
_filters = filters;
}
/// <summary>
/// Initializes an instance of <see cref="PhysicalFilesWatcher" /> that watches files in <paramref name="root" />.
/// Wraps an instance of <see cref="System.IO.FileSystemWatcher" />
/// </summary>
/// <param name="root">Root directory for the watcher</param>
/// <param name="fileSystemWatcher">The wrapped watcher that is watching <paramref name="root" /></param>
/// <param name="pollForChanges">
/// True when the watcher should use polling to trigger instances of
/// <see cref="IChangeToken" /> created by <see cref="CreateFileChangeToken(string)" />
/// </param>
/// <param name="filters">Specifies which files or directories are excluded. Notifications of changes to are not raised to these.</param>
public PhysicalFilesWatcher(
string root,
FileSystemWatcher fileSystemWatcher,
bool pollForChanges,
ExclusionFilters filters)
{
_root = root;
_fileWatcher = fileSystemWatcher;
_fileWatcher.IncludeSubdirectories = true;
_fileWatcher.Created += OnChanged;
_fileWatcher.Changed += OnChanged;
_fileWatcher.Renamed += OnRenamed;
_fileWatcher.Deleted += OnChanged;
_fileWatcher.Error += OnError;
_pollForChanges = pollForChanges;
_filters = filters;
}
public bool InstrumentProcess(string processName)
{
if (string.IsNullOrEmpty(processName))
{
return(false);
}
processName = Path.GetFileNameWithoutExtension(processName);
var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForProcessName(processName);
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.AssemblyName == ".*" && exclusionFilter.ClassName == ".*"))
{
return(false);
}
var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForProcessName(processName);
return(matchingInclusionFilters.Any(inclusionFilter => inclusionFilter.AssemblyName == ".*" || inclusionFilter.ClassName == ".*"));
}
/// <summary>
/// Initializes a new instance of a PhysicalFileProvider at the given root directory.
/// </summary>
/// <param name="root">The root directory. This should be an absolute path.</param>
/// <param name="filters">Specifies which files or directories are excluded.</param>
public PhysicalFileProvider(string root, ExclusionFilters filters)
{
if (!Path.IsPathRooted(root))
{
throw new ArgumentException("The path must be absolute.", nameof(root));
}
string fullRoot = Path.GetFullPath(root);
// When we do matches in GetFullPath, we want to only match full directory names.
Root = PathUtils.EnsureTrailingSlash(fullRoot);
if (!Directory.Exists(Root))
{
throw new DirectoryNotFoundException(Root);
}
_filters = filters;
_fileWatcherFactory = () => CreateFileWatcher();
}
public static bool IsExcluded(FileSystemInfo fileSystemInfo, ExclusionFilters filters)
{
if (filters == ExclusionFilters.None)
{
return(false);
}
else if (fileSystemInfo.Name.StartsWith(".", StringComparison.Ordinal) && (filters & ExclusionFilters.DotPrefixed) != 0)
{
return(true);
}
else if (fileSystemInfo.Exists &&
(((fileSystemInfo.Attributes & FileAttributes.Hidden) != 0 && (filters & ExclusionFilters.Hidden) != 0) ||
((fileSystemInfo.Attributes & FileAttributes.System) != 0 && (filters & ExclusionFilters.System) != 0)))
{
return(true);
}
return(false);
}
/// <summary>
/// Initializes an instance of <see cref="PhysicalFilesWatcher" /> that watches files in <paramref name="root" />.
/// Wraps an instance of <see cref="System.IO.FileSystemWatcher" />
/// </summary>
/// <param name="root">Root directory for the watcher</param>
/// <param name="fileSystemWatcher">The wrapped watcher that is watching <paramref name="root" /></param>
/// <param name="pollForChanges">
/// True when the watcher should use polling to trigger instances of
/// <see cref="IChangeToken" /> created by <see cref="CreateFileChangeToken(string)" />
/// </param>
/// <param name="filters">Specifies which files or directories are excluded. Notifications of changes to are not raised to these.</param>
public PhysicalFilesWatcher(
string root,
FileSystemWatcher fileSystemWatcher,
bool pollForChanges,
ExclusionFilters filters)
{
_root = root;
_fileWatcher = fileSystemWatcher;
_fileWatcher.IncludeSubdirectories = true;
_fileWatcher.Created += OnChanged;
_fileWatcher.Changed += OnChanged;
_fileWatcher.Renamed += OnRenamed;
_fileWatcher.Deleted += OnChanged;
_fileWatcher.Error += OnError;
PollForChanges = pollForChanges;
_filters = filters;
PollingChangeTokens = new ConcurrentDictionary <IPollingChangeToken, IPollingChangeToken>();
_timerFactory = () => NonCapturingTimer.Create(RaiseChangeEvents, state: PollingChangeTokens, dueTime: TimeSpan.Zero, period: DefaultPollingInterval);
}
public bool UseAssembly(string assemblyName)
{
var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
{
return(false);
}
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName != ".*"))
{
return(true);
}
var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingInclusionFilters.Any())
{
return(true);
}
return(false);
}
/// <summary>
/// Initializes an instance of <see cref="PhysicalFilesWatcher" /> that watches files in <paramref name="root" />.
/// Wraps an instance of <see cref="System.IO.FileSystemWatcher" />
/// </summary>
/// <param name="root">Root directory for the watcher</param>
/// <param name="fileSystemWatcher">The wrapped watcher that is watching <paramref name="root" /></param>
/// <param name="pollForChanges">
/// True when the watcher should use polling to trigger instances of
/// <see cref="IChangeToken" /> created by <see cref="CreateFileChangeToken(string)" />
/// </param>
/// <param name="filters">Specifies which files or directories are excluded. Notifications of changes to are not raised to these.</param>
public PhysicalFilesWatcher(
string root,
FileSystemWatcher fileSystemWatcher,
bool pollForChanges,
ExclusionFilters filters)
{
if (fileSystemWatcher == null && !pollForChanges)
{
throw new ArgumentNullException(nameof(fileSystemWatcher), SR.Error_FileSystemWatcherRequiredWithoutPolling);
}
_root = root;
if (fileSystemWatcher != null)
{
#if NETCOREAPP
if (OperatingSystem.IsBrowser() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS())
{
throw new PlatformNotSupportedException(SR.Format(SR.FileSystemWatcher_PlatformNotSupported, typeof(FileSystemWatcher)));
}
#endif
_fileWatcher = fileSystemWatcher;
_fileWatcher.IncludeSubdirectories = true;
_fileWatcher.Created += OnChanged;
_fileWatcher.Changed += OnChanged;
_fileWatcher.Renamed += OnRenamed;
_fileWatcher.Deleted += OnChanged;
_fileWatcher.Error += OnError;
}
PollForChanges = pollForChanges;
_filters = filters;
PollingChangeTokens = new ConcurrentDictionary <IPollingChangeToken, IPollingChangeToken>();
_timerFactory = () => NonCapturingTimer.Create(RaiseChangeEvents, state: PollingChangeTokens, dueTime: TimeSpan.Zero, period: DefaultPollingInterval);
}
/// <summary>
/// Decides whether an assembly should be included in the instrumentation
/// </summary>
/// <param name="processName">The name of the process being profiled</param>
/// <param name="assemblyName">the name of the assembly under profile</param>
/// <remarks>All assemblies matching either the inclusion or exclusion filter should be included
/// as it is the class that is being filtered within these unless the class filter is *</remarks>
public bool UseAssembly(string processName, string assemblyName)
{
processName = Path.GetFileNameWithoutExtension(processName);
var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*" && exclusionFilter.IsMatchingProcessName(processName)))
{
return(false);
}
if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName != ".*"))
{
return(true);
}
var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
if (matchingInclusionFilters.Any())
{
return(true);
}
return(false);
}
public DefaultMediaFileStoreCacheFileProvider(ILogger <DefaultMediaFileStoreCacheFileProvider> logger, PathString virtualPathBase, string root, ExclusionFilters filters) : base(root, filters)
{
_logger = logger;
VirtualPathBase = virtualPathBase;
}
