mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
2447 lines
105 KiB
C#
2447 lines
105 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="FileChangesMonitor.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web {
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Web.Configuration;
|
|
using System.Web.Hosting;
|
|
using System.Web.Util;
|
|
using Microsoft.Win32;
|
|
|
|
|
|
// Type of the callback to the subscriber of a file change event in FileChangesMonitor.StartMonitoringFile
|
|
delegate void FileChangeEventHandler(Object sender, FileChangeEvent e);
|
|
|
|
// The type of file change that occurred.
|
|
enum FileAction {
|
|
Dispose = -2,
|
|
Error = -1,
|
|
Overwhelming = 0,
|
|
Added = 1,
|
|
Removed = 2,
|
|
Modified = 3,
|
|
RenamedOldName = 4,
|
|
RenamedNewName = 5
|
|
}
|
|
|
|
// Event data for a file change notification
|
|
sealed class FileChangeEvent : EventArgs {
|
|
internal FileAction Action; // the action
|
|
internal string FileName; // the file that caused the action
|
|
|
|
internal FileChangeEvent(FileAction action, string fileName) {
|
|
this.Action = action;
|
|
this.FileName = fileName;
|
|
}
|
|
}
|
|
|
|
// Contains information about the target of a file change notification
|
|
sealed class FileMonitorTarget {
|
|
internal readonly FileChangeEventHandler Callback; // the callback
|
|
internal readonly string Alias; // the filename used to name the file
|
|
internal readonly DateTime UtcStartMonitoring;// time we started monitoring
|
|
int _refs; // number of uses of callbacks
|
|
|
|
internal FileMonitorTarget(FileChangeEventHandler callback, string alias) {
|
|
Callback = callback;
|
|
Alias = alias;
|
|
UtcStartMonitoring = DateTime.UtcNow;
|
|
_refs = 1;
|
|
}
|
|
|
|
internal int AddRef() {
|
|
_refs++;
|
|
return _refs;
|
|
}
|
|
|
|
internal int Release() {
|
|
_refs--;
|
|
return _refs;
|
|
}
|
|
|
|
#if DBG
|
|
internal string DebugDescription(string indent) {
|
|
StringBuilder sb = new StringBuilder(200);
|
|
string i2 = indent + " ";
|
|
|
|
sb.Append(indent + "FileMonitorTarget\n");
|
|
sb.Append(i2 + " Callback: " + Callback.Target + "(HC=" + Callback.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")\n");
|
|
sb.Append(i2 + " Alias: " + Alias + "\n");
|
|
sb.Append(i2 + "StartMonitoring: " + Debug.FormatUtcDate(UtcStartMonitoring) + "\n");
|
|
sb.Append(i2 + " _refs: " + _refs + "\n");
|
|
|
|
return sb.ToString();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !FEATURE_PAL // FEATURE_PAL does not enable access control
|
|
sealed class FileSecurity {
|
|
const int DACL_INFORMATION =
|
|
UnsafeNativeMethods.DACL_SECURITY_INFORMATION |
|
|
UnsafeNativeMethods.GROUP_SECURITY_INFORMATION |
|
|
UnsafeNativeMethods.OWNER_SECURITY_INFORMATION;
|
|
|
|
static Hashtable s_interned;
|
|
static byte[] s_nullDacl;
|
|
|
|
class DaclComparer : IEqualityComparer {
|
|
// Compares two objects. An implementation of this method must return a
|
|
// value less than zero if x is less than y, zero if x is equal to y, or a
|
|
// value greater than zero if x is greater than y.
|
|
//
|
|
|
|
private int Compare(byte[] a, byte[] b) {
|
|
int result = a.Length - b.Length;
|
|
for (int i = 0; result == 0 && i < a.Length ; i++) {
|
|
result = a[i] - b[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool IEqualityComparer.Equals(Object x, Object y) {
|
|
if (x == null && y == null) {
|
|
return true;
|
|
}
|
|
|
|
if (x == null || y == null) {
|
|
return false;
|
|
}
|
|
|
|
byte[] a = x as byte[];
|
|
byte[] b = y as byte[];
|
|
|
|
if (a == null || b == null) {
|
|
return false;
|
|
}
|
|
|
|
return Compare(a, b) == 0;
|
|
}
|
|
|
|
int IEqualityComparer.GetHashCode(Object obj) {
|
|
byte[] a = (byte[]) obj;
|
|
|
|
HashCodeCombiner combiner = new HashCodeCombiner();
|
|
foreach (byte b in a) {
|
|
combiner.AddObject(b);
|
|
}
|
|
|
|
return combiner.CombinedHash32;
|
|
}
|
|
}
|
|
|
|
static FileSecurity() {
|
|
s_interned = new Hashtable(0, 1.0f, new DaclComparer());
|
|
s_nullDacl = new byte[0];
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Interoperability", "CA1404:CallGetLastErrorImmediatelyAfterPInvoke",
|
|
Justification="Microsoft: Call to GetLastWin32Error() does follow P/Invoke call that is outside the if/else block.")]
|
|
static internal byte[] GetDacl(string filename) {
|
|
// DevDiv #322858 - allow skipping DACL step for perf gain
|
|
if (HostingEnvironment.FcnSkipReadAndCacheDacls) {
|
|
return s_nullDacl;
|
|
}
|
|
|
|
// DevDiv #246973
|
|
// Perf: Start with initial buffer size to minimize File IO
|
|
//
|
|
int lengthNeeded = 512;
|
|
byte[] dacl = new byte[lengthNeeded];
|
|
int fOK = UnsafeNativeMethods.GetFileSecurity(filename, DACL_INFORMATION, dacl, dacl.Length, ref lengthNeeded);
|
|
|
|
if (fOK != 0) {
|
|
// If no size is needed, return a non-null marker
|
|
if (lengthNeeded == 0) {
|
|
Debug.Trace("GetDacl", "Returning null dacl");
|
|
return s_nullDacl;
|
|
}
|
|
|
|
// Shrink the buffer to fit the whole data
|
|
Array.Resize(ref dacl, lengthNeeded);
|
|
}
|
|
else {
|
|
int hr = HttpException.HResultFromLastError(Marshal.GetLastWin32Error());
|
|
|
|
// Check if need to redo the call with larger buffer
|
|
if (hr != HResults.E_INSUFFICIENT_BUFFER) {
|
|
Debug.Trace("GetDacl", "Error in first call to GetFileSecurity: 0x" + hr.ToString("x", NumberFormatInfo.InvariantInfo));
|
|
return null;
|
|
}
|
|
|
|
// The buffer wasn't large enough. Try again
|
|
dacl = new byte[lengthNeeded];
|
|
fOK = UnsafeNativeMethods.GetFileSecurity(filename, DACL_INFORMATION, dacl, dacl.Length, ref lengthNeeded);
|
|
if (fOK == 0) {
|
|
#if DBG
|
|
hr = HttpException.HResultFromLastError(Marshal.GetLastWin32Error());
|
|
Debug.Trace("GetDacl", "Error in second to GetFileSecurity: 0x" + hr.ToString("x", NumberFormatInfo.InvariantInfo));
|
|
#endif
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
byte[] interned = (byte[]) s_interned[dacl];
|
|
if (interned == null) {
|
|
lock (s_interned.SyncRoot) {
|
|
interned = (byte[]) s_interned[dacl];
|
|
if (interned == null) {
|
|
Debug.Trace("GetDacl", "Interning new dacl, length " + dacl.Length);
|
|
interned = dacl;
|
|
s_interned[interned] = interned;
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Trace("GetDacl", "Returning dacl, length " + dacl.Length);
|
|
return interned;
|
|
}
|
|
}
|
|
|
|
// holds information about a single file and the targets of change notification
|
|
sealed class FileMonitor {
|
|
internal readonly DirectoryMonitor DirectoryMonitor; // the parent
|
|
internal readonly HybridDictionary Aliases; // aliases for this file
|
|
string _fileNameLong; // long file name - if null, represents any file in this directory
|
|
string _fileNameShort; // short file name, may be null
|
|
HybridDictionary _targets; // targets of notification
|
|
bool _exists; // does the file exist?
|
|
FileAttributesData _fad; // file attributes
|
|
byte[] _dacl; // dacl
|
|
FileAction _lastAction; // last action that ocurred on this file
|
|
DateTime _utcLastCompletion; // date of the last RDCW completion
|
|
|
|
internal FileMonitor(
|
|
DirectoryMonitor dirMon, string fileNameLong, string fileNameShort,
|
|
bool exists, FileAttributesData fad, byte[] dacl) {
|
|
|
|
DirectoryMonitor = dirMon;
|
|
_fileNameLong = fileNameLong;
|
|
_fileNameShort = fileNameShort;
|
|
_exists = exists;
|
|
_fad = fad;
|
|
_dacl = dacl;
|
|
_targets = new HybridDictionary();
|
|
Aliases = new HybridDictionary(true);
|
|
}
|
|
|
|
internal string FileNameLong {get {return _fileNameLong;}}
|
|
internal string FileNameShort {get {return _fileNameShort;}}
|
|
internal bool Exists {get {return _exists;}}
|
|
internal bool IsDirectory {get {return (FileNameLong == null);}}
|
|
internal FileAction LastAction {
|
|
get {return _lastAction;}
|
|
set {_lastAction = value;}
|
|
}
|
|
|
|
internal DateTime UtcLastCompletion {
|
|
get {return _utcLastCompletion;}
|
|
set {_utcLastCompletion = value;}
|
|
}
|
|
|
|
// Returns the attributes of a file, updating them if the file has changed.
|
|
internal FileAttributesData Attributes {
|
|
get {return _fad;}
|
|
}
|
|
|
|
internal byte[] Dacl {
|
|
get {return _dacl;}
|
|
}
|
|
|
|
internal void ResetCachedAttributes() {
|
|
_fad = null;
|
|
_dacl = null;
|
|
}
|
|
|
|
internal void UpdateCachedAttributes() {
|
|
string path = Path.Combine(DirectoryMonitor.Directory, FileNameLong);
|
|
FileAttributesData.GetFileAttributes(path, out _fad);
|
|
_dacl = FileSecurity.GetDacl(path);
|
|
}
|
|
|
|
// Set new file information when a file comes into existence
|
|
internal void MakeExist(FindFileData ffd, byte[] dacl) {
|
|
_fileNameLong = ffd.FileNameLong;
|
|
_fileNameShort = ffd.FileNameShort;
|
|
_fad = ffd.FileAttributesData;
|
|
_dacl = dacl;
|
|
_exists = true;
|
|
}
|
|
|
|
// Remove a file from existence
|
|
internal void MakeExtinct() {
|
|
_fad = null;
|
|
_dacl = null;
|
|
_exists = false;
|
|
}
|
|
|
|
internal void RemoveFileNameShort() {
|
|
_fileNameShort = null;
|
|
}
|
|
|
|
internal ICollection Targets {
|
|
get {return _targets.Values;}
|
|
}
|
|
|
|
// Add delegate for this file.
|
|
internal void AddTarget(FileChangeEventHandler callback, string alias, bool newAlias) {
|
|
FileMonitorTarget target = (FileMonitorTarget)_targets[callback.Target];
|
|
if (target != null) {
|
|
target.AddRef();
|
|
}
|
|
else {
|
|
#if DBG
|
|
// Needs the lock to sync with DebugDescription
|
|
lock (_targets) {
|
|
#endif
|
|
_targets.Add(callback.Target, new FileMonitorTarget(callback, alias));
|
|
#if DBG
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (newAlias) {
|
|
Aliases[alias] = alias;
|
|
}
|
|
}
|
|
|
|
|
|
// Remove delegate for this file given the target object.
|
|
internal int RemoveTarget(object callbackTarget) {
|
|
FileMonitorTarget target = (FileMonitorTarget)_targets[callbackTarget];
|
|
#if DBG
|
|
if (FileChangesMonitor.s_enableRemoveTargetAssert) {
|
|
Debug.Assert(target != null, "removing file monitor target that was never added or already been removed");
|
|
}
|
|
#endif
|
|
if (target != null && target.Release() == 0) {
|
|
#if DBG
|
|
// Needs the lock to sync with DebugDescription
|
|
lock (_targets) {
|
|
#endif
|
|
_targets.Remove(callbackTarget);
|
|
#if DBG
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return _targets.Count;
|
|
}
|
|
|
|
#if DBG
|
|
internal string DebugDescription(string indent) {
|
|
StringBuilder sb = new StringBuilder(200);
|
|
string i2 = indent + " ";
|
|
string i3 = i2 + " ";
|
|
DictionaryEntryTypeComparer detcomparer = new DictionaryEntryTypeComparer();
|
|
|
|
sb.Append(indent + "System.Web.FileMonitor: ");
|
|
if (FileNameLong != null) {
|
|
sb.Append(FileNameLong);
|
|
if (FileNameShort != null) {
|
|
sb.Append("; ShortFileName=" + FileNameShort);
|
|
}
|
|
|
|
sb.Append("; FileExists="); sb.Append(_exists);
|
|
}
|
|
else {
|
|
sb.Append("<ANY>");
|
|
}
|
|
sb.Append("\n");
|
|
sb.Append(i2 + "LastAction="); sb.Append(_lastAction);
|
|
sb.Append("; LastCompletion="); sb.Append(Debug.FormatUtcDate(_utcLastCompletion));
|
|
sb.Append("\n");
|
|
|
|
if (_fad != null) {
|
|
sb.Append(_fad.DebugDescription(i2));
|
|
}
|
|
else {
|
|
sb.Append(i2 + "FileAttributesData = <null>\n");
|
|
}
|
|
|
|
DictionaryEntry[] delegateEntries;
|
|
|
|
lock (_targets) {
|
|
sb.Append(i2 + _targets.Count + " delegates...\n");
|
|
|
|
delegateEntries = new DictionaryEntry[_targets.Count];
|
|
_targets.CopyTo(delegateEntries, 0);
|
|
}
|
|
|
|
Array.Sort(delegateEntries, detcomparer);
|
|
|
|
foreach (DictionaryEntry d in delegateEntries) {
|
|
sb.Append(i3 + "Delegate " + d.Key.GetType() + "(HC=" + d.Key.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")\n");
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
// Change notifications delegate from native code.
|
|
delegate void NativeFileChangeNotification(FileAction action, [In, MarshalAs(UnmanagedType.LPWStr)] string fileName, long ticks);
|
|
|
|
//
|
|
// Wraps N/Direct calls to native code that does completion port
|
|
// based ReadDirectoryChangesW().
|
|
// This needs to be a separate object so that a DirectoryMonitory
|
|
// can start monitoring while the old _rootCallback has not been
|
|
// disposed.
|
|
//
|
|
sealed class DirMonCompletion : IDisposable {
|
|
static int _activeDirMonCompletions = 0; // private counter used via reflection by FCN check-in suite
|
|
|
|
DirectoryMonitor _dirMon; // directory monitor
|
|
IntPtr _ndirMonCompletionPtr; // pointer to native dir mon as int (used only to construct HandleRef)
|
|
HandleRef _ndirMonCompletionHandle; // handleref of a pointer to native dir mon as int
|
|
GCHandle _rootCallback; // roots this callback to prevent collection
|
|
int _disposed; // set to 1 when we call DirMonClose
|
|
object _ndirMonCompletionHandleLock;
|
|
|
|
internal static int ActiveDirMonCompletions { get { return _activeDirMonCompletions; } }
|
|
|
|
internal DirMonCompletion(DirectoryMonitor dirMon, string dir, bool watchSubtree, uint notifyFilter) {
|
|
Debug.Trace("FileChangesMonitor", "DirMonCompletion::ctor " + dir + " " + watchSubtree.ToString() + " " + notifyFilter.ToString(NumberFormatInfo.InvariantInfo));
|
|
|
|
int hr;
|
|
NativeFileChangeNotification myCallback;
|
|
|
|
_dirMon = dirMon;
|
|
myCallback = new NativeFileChangeNotification(this.OnFileChange);
|
|
_ndirMonCompletionHandleLock = new object();
|
|
try {
|
|
}
|
|
finally {
|
|
// protected from ThreadAbortEx
|
|
lock(_ndirMonCompletionHandleLock) {
|
|
// Dev10 927846: The managed DirMonCompletion.ctor calls DirMonOpen to create and initialize the native DirMonCompletion.
|
|
// If this succeeds, the managed DirMonCompletion.ctor creates a GCHandle to root itself so the target of the callback
|
|
// stays alive. When the native DirMonCompletion is freed it invokes the managed callback with ACTION_DISPOSE to
|
|
// release the GCHandle. In order for the native DirMonCOmpletion to be freed, either DirMonOpen must fail or
|
|
// the managed DirMonCompletion.Dispose must be called and it must invoke DirMonClose. Waiting until the native
|
|
// DirMonCompletion.dtor is called to release the GCHandle ensures that the directory handle has been closed,
|
|
// the i/o completions have finished and there are no other threads calling the managed callback. This is because
|
|
// we AddRef when we initiate i/o and we Release when the i/o completion finishes.
|
|
|
|
// If I don't do this, myCallback will be collected by GC since its only reference is
|
|
// from the native code.
|
|
_rootCallback = GCHandle.Alloc(myCallback);
|
|
|
|
hr = UnsafeNativeMethods.DirMonOpen(dir, HttpRuntime.AppDomainAppId, watchSubtree, notifyFilter, dirMon.FcnMode, myCallback, out _ndirMonCompletionPtr);
|
|
if (hr != HResults.S_OK) {
|
|
_rootCallback.Free();
|
|
throw FileChangesMonitor.CreateFileMonitoringException(hr, dir);
|
|
}
|
|
|
|
_ndirMonCompletionHandle = new HandleRef(this, _ndirMonCompletionPtr);
|
|
Interlocked.Increment(ref _activeDirMonCompletions);
|
|
}
|
|
}
|
|
}
|
|
|
|
~DirMonCompletion() {
|
|
Dispose(false);
|
|
}
|
|
|
|
void IDisposable.Dispose() {
|
|
Dispose(true);
|
|
System.GC.SuppressFinalize(this);
|
|
}
|
|
|
|
void Dispose(bool disposing) {
|
|
Debug.Trace("FileChangesMonitor", "DirMonCompletion::Dispose");
|
|
// this is here because callbacks from native code can cause
|
|
// this to be invoked from multiple threads concurrently, and
|
|
// I don't want contention on _ndirMonCompletionHandleLock,
|
|
// but also need to ensure that DirMonOpen returns and the
|
|
// _ndirMonCompletionHandle is set before DirMonClose is called.
|
|
if (Interlocked.Exchange(ref _disposed, 1) == 0) {
|
|
|
|
// Dev10 927846: There is a small window during which the .ctor has
|
|
// not returned from DirMonOpen yet but because we already started
|
|
// monitoring, we might receive a change notification which could
|
|
// potentially Dispose the instance, so we need to block until
|
|
// DirMonOpen returns and _ndirMonCompletionHandler is set
|
|
lock(_ndirMonCompletionHandleLock) {
|
|
// Dev11 - 364642: if Dispose is called while finalizing for AD unload then
|
|
// the native DirMonCompletion won't be able to call back into the appdomain.
|
|
// But it does not need to because _rootCallback is already reclaimed as part of AD unload
|
|
bool fNeedToSendFileActionDispose = !AppDomain.CurrentDomain.IsFinalizingForUnload();
|
|
HandleRef ndirMonCompletionHandle = _ndirMonCompletionHandle;
|
|
if (ndirMonCompletionHandle.Handle != IntPtr.Zero) {
|
|
_ndirMonCompletionHandle = new HandleRef(this, IntPtr.Zero);
|
|
UnsafeNativeMethods.DirMonClose(ndirMonCompletionHandle, fNeedToSendFileActionDispose);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnFileChange(FileAction action, string fileName, long ticks) {
|
|
DateTime utcCompletion;
|
|
if (ticks == 0) {
|
|
utcCompletion = DateTime.MinValue;
|
|
}
|
|
else {
|
|
utcCompletion = DateTimeUtil.FromFileTimeToUtc(ticks);
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorOnFileChange", "Action=" + action + "; Dir=" + _dirMon.Directory + "; fileName=" + Debug.ToStringMaybeNull(fileName) + "; completion=" + Debug.FormatUtcDate(utcCompletion) + ";_ndirMonCompletionPtr=0x" + _ndirMonCompletionPtr.ToString("x"));
|
|
#endif
|
|
|
|
//
|
|
// The native DirMonCompletion sends FileAction.Dispose
|
|
// when there are no more outstanding calls on the
|
|
// delegate. Only then can _rootCallback be freed.
|
|
//
|
|
if (action == FileAction.Dispose) {
|
|
if (_rootCallback.IsAllocated) {
|
|
_rootCallback.Free();
|
|
}
|
|
Interlocked.Decrement(ref _activeDirMonCompletions);
|
|
}
|
|
else {
|
|
using (new ApplicationImpersonationContext()) {
|
|
_dirMon.OnFileChange(action, fileName, utcCompletion);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
internal string DebugDescription(string indent) {
|
|
int hc = ((Delegate)_rootCallback.Target).Target.GetHashCode();
|
|
string description = indent + "_ndirMonCompletionPtr=0x" + _ndirMonCompletionPtr.ToString("x") + "; callback=0x" + hc.ToString("x", NumberFormatInfo.InvariantInfo) + "\n";
|
|
return description;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
sealed class NotificationQueueItem {
|
|
internal readonly FileChangeEventHandler Callback;
|
|
internal readonly string Filename;
|
|
internal readonly FileAction Action;
|
|
|
|
internal NotificationQueueItem(FileChangeEventHandler callback, FileAction action, string filename) {
|
|
Callback = callback;
|
|
Action = action;
|
|
Filename = filename;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Monitor changes in a single directory.
|
|
//
|
|
sealed class DirectoryMonitor : IDisposable {
|
|
|
|
static Queue s_notificationQueue = new Queue();
|
|
static WorkItemCallback s_notificationCallback = new WorkItemCallback(FireNotifications);
|
|
static int s_inNotificationThread;
|
|
static int s_notificationBufferSizeIncreased = 0;
|
|
|
|
internal readonly string Directory; // directory being monitored
|
|
Hashtable _fileMons; // fileName -> FileMonitor
|
|
int _cShortNames; // number of file monitors that are added with their short name
|
|
FileMonitor _anyFileMon; // special file monitor to watch for any changes in directory
|
|
bool _watchSubtree; // watch subtree?
|
|
uint _notifyFilter; // the notify filter for the call to ReadDirectoryChangesW
|
|
bool _ignoreSubdirChange; // when a subdirectory is deleted or renamed, ignore the notification if we're not monitoring it
|
|
DirMonCompletion _dirMonCompletion; // dirmon completion
|
|
bool _isDirMonAppPathInternal; // special dirmon that monitors all files and subdirectories beneath the vroot (enabled via FCNMode registry key)
|
|
|
|
// FcnMode to pass to native code
|
|
internal int FcnMode {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
// constructor for special dirmon that monitors all files and subdirectories beneath the vroot (enabled via FCNMode registry key)
|
|
internal DirectoryMonitor(string appPathInternal, int fcnMode): this(appPathInternal, true, UnsafeNativeMethods.RDCW_FILTER_FILE_AND_DIR_CHANGES, fcnMode) {
|
|
_isDirMonAppPathInternal = true;
|
|
}
|
|
|
|
internal DirectoryMonitor(string dir, bool watchSubtree, uint notifyFilter, int fcnMode): this(dir, watchSubtree, notifyFilter, false, fcnMode) {
|
|
}
|
|
|
|
internal DirectoryMonitor(string dir, bool watchSubtree, uint notifyFilter, bool ignoreSubdirChange, int fcnMode) {
|
|
Directory = dir;
|
|
_fileMons = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
_watchSubtree = watchSubtree;
|
|
_notifyFilter = notifyFilter;
|
|
_ignoreSubdirChange = ignoreSubdirChange;
|
|
FcnMode = fcnMode;
|
|
}
|
|
|
|
void IDisposable.Dispose() {
|
|
if (_dirMonCompletion != null) {
|
|
((IDisposable)_dirMonCompletion).Dispose();
|
|
_dirMonCompletion = null;
|
|
}
|
|
|
|
//
|
|
// Remove aliases to this object in FileChangesMonitor so that
|
|
// it is not rooted.
|
|
//
|
|
if (_anyFileMon != null) {
|
|
HttpRuntime.FileChangesMonitor.RemoveAliases(_anyFileMon);
|
|
_anyFileMon = null;
|
|
}
|
|
|
|
foreach (DictionaryEntry e in _fileMons) {
|
|
string key = (string) e.Key;
|
|
FileMonitor fileMon = (FileMonitor) e.Value;
|
|
if (fileMon.FileNameLong == key) {
|
|
HttpRuntime.FileChangesMonitor.RemoveAliases(fileMon);
|
|
}
|
|
}
|
|
|
|
_fileMons.Clear();
|
|
_cShortNames = 0;
|
|
}
|
|
|
|
internal bool IsMonitoring() {
|
|
return GetFileMonitorsCount() > 0;
|
|
}
|
|
|
|
void StartMonitoring() {
|
|
if (_dirMonCompletion == null) {
|
|
_dirMonCompletion = new DirMonCompletion(this, Directory, _watchSubtree, _notifyFilter);
|
|
}
|
|
}
|
|
|
|
internal void StopMonitoring() {
|
|
lock (this) {
|
|
((IDisposable)this).Dispose();
|
|
}
|
|
}
|
|
|
|
FileMonitor FindFileMonitor(string file) {
|
|
FileMonitor fileMon;
|
|
|
|
if (file == null) {
|
|
fileMon = _anyFileMon;
|
|
}
|
|
else {
|
|
fileMon = (FileMonitor)_fileMons[file];
|
|
}
|
|
|
|
return fileMon;
|
|
}
|
|
|
|
FileMonitor AddFileMonitor(string file) {
|
|
string path;
|
|
FileMonitor fileMon;
|
|
FindFileData ffd = null;
|
|
int hr;
|
|
|
|
if (String.IsNullOrEmpty(file)) {
|
|
// add as the <ANY> file monitor
|
|
fileMon = new FileMonitor(this, null, null, true, null, null);
|
|
_anyFileMon = fileMon;
|
|
}
|
|
else {
|
|
// Get the long and short name of the file
|
|
path = Path.Combine(Directory, file);
|
|
if (_isDirMonAppPathInternal) {
|
|
hr = FindFileData.FindFile(path, Directory, out ffd);
|
|
}
|
|
else {
|
|
hr = FindFileData.FindFile(path, out ffd);
|
|
}
|
|
if (hr == HResults.S_OK) {
|
|
// Unless this is FileChangesMonitor._dirMonAppPathInternal,
|
|
// don't monitor changes to a directory - this will not pickup changes to files in the directory.
|
|
if (!_isDirMonAppPathInternal
|
|
&& (ffd.FileAttributesData.FileAttributes & FileAttributes.Directory) != 0) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(HResults.E_INVALIDARG, path);
|
|
}
|
|
|
|
byte[] dacl = FileSecurity.GetDacl(path);
|
|
fileMon = new FileMonitor(this, ffd.FileNameLong, ffd.FileNameShort, true, ffd.FileAttributesData, dacl);
|
|
_fileMons.Add(ffd.FileNameLong, fileMon);
|
|
|
|
// Update short name aliases to this file
|
|
UpdateFileNameShort(fileMon, null, ffd.FileNameShort);
|
|
}
|
|
else if (hr == HResults.E_PATHNOTFOUND || hr == HResults.E_FILENOTFOUND) {
|
|
// Don't allow possible short file names to be added as non-existant,
|
|
// because it is impossible to track them if they are indeed a short name since
|
|
// short file names may change.
|
|
|
|
// FEATURE_PAL
|
|
|
|
|
|
|
|
if (file.IndexOf('~') != -1) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(HResults.E_INVALIDARG, path);
|
|
}
|
|
|
|
// Add as non-existent file
|
|
fileMon = new FileMonitor(this, file, null, false, null, null);
|
|
_fileMons.Add(file, fileMon);
|
|
}
|
|
else {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(hr, path);
|
|
}
|
|
}
|
|
|
|
return fileMon;
|
|
}
|
|
|
|
//
|
|
// Update short names of a file
|
|
//
|
|
void UpdateFileNameShort(FileMonitor fileMon, string oldFileNameShort, string newFileNameShort) {
|
|
if (oldFileNameShort != null) {
|
|
FileMonitor oldFileMonShort = (FileMonitor)_fileMons[oldFileNameShort];
|
|
if (oldFileMonShort != null) {
|
|
// The old filemonitor no longer has this short file name.
|
|
// Update the monitor and _fileMons
|
|
if (oldFileMonShort != fileMon) {
|
|
oldFileMonShort.RemoveFileNameShort();
|
|
}
|
|
|
|
|
|
_fileMons.Remove(oldFileNameShort);
|
|
_cShortNames--;
|
|
}
|
|
}
|
|
|
|
if (newFileNameShort != null) {
|
|
// Add the new short file name.
|
|
_fileMons.Add(newFileNameShort, fileMon);
|
|
_cShortNames++;
|
|
}
|
|
}
|
|
|
|
void RemoveFileMonitor(FileMonitor fileMon) {
|
|
if (fileMon == _anyFileMon) {
|
|
_anyFileMon = null;
|
|
}
|
|
else {
|
|
_fileMons.Remove(fileMon.FileNameLong);
|
|
if (fileMon.FileNameShort != null) {
|
|
_fileMons.Remove(fileMon.FileNameShort);
|
|
_cShortNames--;
|
|
}
|
|
}
|
|
|
|
HttpRuntime.FileChangesMonitor.RemoveAliases(fileMon);
|
|
}
|
|
|
|
int GetFileMonitorsCount() {
|
|
int c = _fileMons.Count - _cShortNames;
|
|
if (_anyFileMon != null) {
|
|
c++;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
// The 4.0 CAS changes made the AppDomain homogenous, so we need to assert
|
|
// FileIOPermission. Currently this is only exposed publicly via CacheDependency, which
|
|
// already does a PathDiscover check for public callers.
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
internal FileMonitor StartMonitoringFileWithAssert(string file, FileChangeEventHandler callback, string alias) {
|
|
FileMonitor fileMon = null;
|
|
bool firstFileMonAdded = false;
|
|
|
|
lock (this) {
|
|
// Find existing file monitor
|
|
fileMon = FindFileMonitor(file);
|
|
if (fileMon == null) {
|
|
// Add a new monitor
|
|
fileMon = AddFileMonitor(file);
|
|
if (GetFileMonitorsCount() == 1) {
|
|
firstFileMonAdded = true;
|
|
}
|
|
}
|
|
|
|
// Add callback to the file monitor
|
|
fileMon.AddTarget(callback, alias, true);
|
|
|
|
// Start directory monitoring when the first file gets added
|
|
if (firstFileMonAdded) {
|
|
StartMonitoring();
|
|
}
|
|
}
|
|
|
|
return fileMon;
|
|
}
|
|
|
|
//
|
|
// Request to stop monitoring a file.
|
|
//
|
|
internal void StopMonitoringFile(string file, object target) {
|
|
FileMonitor fileMon;
|
|
int numTargets;
|
|
|
|
lock (this) {
|
|
// Find existing file monitor
|
|
fileMon = FindFileMonitor(file);
|
|
if (fileMon != null) {
|
|
numTargets = fileMon.RemoveTarget(target);
|
|
if (numTargets == 0) {
|
|
RemoveFileMonitor(fileMon);
|
|
|
|
// last target for the file monitor gone
|
|
// -- remove the file monitor
|
|
if (GetFileMonitorsCount() == 0) {
|
|
((IDisposable)this).Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
if (fileMon != null) {
|
|
Debug.Dump("FileChangesMonitor", HttpRuntime.FileChangesMonitor);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
internal bool GetFileAttributes(string file, out FileAttributesData fad) {
|
|
FileMonitor fileMon = null;
|
|
fad = null;
|
|
|
|
lock (this) {
|
|
// Find existing file monitor
|
|
fileMon = FindFileMonitor(file);
|
|
if (fileMon != null) {
|
|
// Get the attributes
|
|
fad = fileMon.Attributes;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Notes about file attributes:
|
|
//
|
|
// CreationTime is the time a file entry is added to a directory.
|
|
// If file q1 is copied to q2, q2's creation time is updated if it is new to the directory,
|
|
// else q2's old time is used.
|
|
//
|
|
// If a file is deleted, then added, its creation time is preserved from before the delete.
|
|
//
|
|
// LastWriteTime is the time a file was last written.
|
|
// If file q1 is copied to q2, q2's lastWrite time is the same as q1.
|
|
// Note that this implies that the LastWriteTime can be older than the LastCreationTime,
|
|
// and that a copy of a file can result in the LastWriteTime being earlier than
|
|
// its previous value.
|
|
//
|
|
// LastAccessTime is the time a file was last accessed, such as opened or written to.
|
|
// Note that if the attributes of a file are changed, its LastAccessTime is not necessarily updated.
|
|
//
|
|
// If the FileSize, CreationTime, or LastWriteTime have changed, then we know that the
|
|
// file has changed in a significant way, and that the LastAccessTime will be greater than
|
|
// or equal to that time.
|
|
//
|
|
// If the FileSize, CreationTime, or LastWriteTime have not changed, then the file's
|
|
// attributes may have changed without changing the LastAccessTime.
|
|
//
|
|
|
|
// Confirm that the changes occurred after we started monitoring,
|
|
// to handle the case where:
|
|
//
|
|
// 1. User creates a file.
|
|
// 2. User starts to monitor the file.
|
|
// 3. Change notification is made of the original creation of the file.
|
|
//
|
|
// Note that we can only approximate when the last change occurred by
|
|
// examining the LastAccessTime. The LastAccessTime will change if the
|
|
// contents of a file (but not necessarily its attributes) change.
|
|
// The drawback to using the LastAccessTime is that it will also be
|
|
// updated when a file is read.
|
|
//
|
|
// Note that we cannot make this confirmation when only the file's attributes
|
|
// or ACLs change, because changes to attributes and ACLs won't change the LastAccessTime.
|
|
//
|
|
bool IsChangeAfterStartMonitoring(FileAttributesData fad, FileMonitorTarget target, DateTime utcCompletion) {
|
|
// If the LastAccessTime is more than 60 seconds before we
|
|
// started monitoring, then the change likely did not update
|
|
// the LastAccessTime correctly.
|
|
if (fad.UtcLastAccessTime.AddSeconds(60) < target.UtcStartMonitoring) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "LastAccessTime is more than 60 seconds before monitoring started.");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// Check if the notification of the change came after
|
|
// we started monitoring.
|
|
if (utcCompletion > target.UtcStartMonitoring) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "Notification came after we started monitoring.");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// Make sure that the LastAccessTime is valid.
|
|
// It must be more recent than the LastWriteTime.
|
|
if (fad.UtcLastAccessTime < fad.UtcLastWriteTime) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "UtcLastWriteTime is greater then UtcLastAccessTime.");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// If the LastAccessTime occurs exactly at midnight,
|
|
// then the system is FAT32 and LastAccessTime is unusable.
|
|
if (fad.UtcLastAccessTime.TimeOfDay == TimeSpan.Zero) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "UtcLastAccessTime is midnight -- FAT32 likely.");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// Finally, compare LastAccessTime to the time we started monitoring.
|
|
// If the time of the last access was before we started monitoring, then
|
|
// we know a change did not occur to the file contents.
|
|
if (fad.UtcLastAccessTime >= target.UtcStartMonitoring) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "UtcLastAccessTime is greater than UtcStartMonitoring.");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIsChangeAfterStart", "Change is before start of monitoring. Data:\n FileAttributesData: \nUtcCreationTime: "
|
|
+ fad.UtcCreationTime + " UtcLastAccessTime: " + fad.UtcLastAccessTime + " UtcLastWriteTime: " + fad.UtcLastWriteTime + "\n FileMonitorTarget:\n UtcStartMonitoring: "
|
|
+ target.UtcStartMonitoring + "\nUtcCompletion: " + utcCompletion);
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
// If this is a special dirmon that monitors all files and subdirectories
|
|
// beneath the vroot (enabled via FCNMode registry key), then
|
|
// we need to special case how we lookup the FileMonitor. For example, nobody has called
|
|
// StartMonitorFile for specific files in the App_LocalResources directory,
|
|
// so we need to see if fileName is in App_LocalResources and then get the FileMonitor for
|
|
// the directory.
|
|
private bool GetFileMonitorForSpecialDirectory(string fileName, ref FileMonitor fileMon) {
|
|
|
|
// fileName should not be in short form (8.3 format)...it was converted to long form in
|
|
// DirMonCompletion::ProcessOneFileNotification
|
|
|
|
// first search for match within s_dirsToMonitor
|
|
for (int i = 0; i < FileChangesMonitor.s_dirsToMonitor.Length; i++) {
|
|
if (StringUtil.StringStartsWithIgnoreCase(fileName, FileChangesMonitor.s_dirsToMonitor[i])) {
|
|
fileMon = (FileMonitor)_fileMons[FileChangesMonitor.s_dirsToMonitor[i]];
|
|
return fileMon != null;
|
|
}
|
|
}
|
|
|
|
// if we did not find a match in s_dirsToMonitor, look for LocalResourcesDirectoryName anywhere within fileName
|
|
int indexStart = fileName.IndexOf(HttpRuntime.LocalResourcesDirectoryName, StringComparison.OrdinalIgnoreCase);
|
|
if (indexStart > -1) {
|
|
int dirNameLength = indexStart + HttpRuntime.LocalResourcesDirectoryName.Length;
|
|
|
|
// fileName should either end with LocalResourcesDirectoryName or include a trailing slash and more characters
|
|
if (fileName.Length == dirNameLength || fileName[dirNameLength] == Path.DirectorySeparatorChar) {
|
|
string dirName = fileName.Substring(0, dirNameLength);
|
|
fileMon = (FileMonitor)_fileMons[dirName];
|
|
return fileMon != null;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//
|
|
// Delegate callback from native code.
|
|
//
|
|
internal void OnFileChange(FileAction action, string fileName, DateTime utcCompletion) {
|
|
//
|
|
// Use try/catch to prevent runtime exceptions from propagating
|
|
// into native code.
|
|
//
|
|
try {
|
|
FileMonitor fileMon = null;
|
|
ArrayList targets = null;
|
|
int i, n;
|
|
FileMonitorTarget target;
|
|
ICollection col;
|
|
string key;
|
|
FileAttributesData fadOld = null;
|
|
FileAttributesData fadNew = null;
|
|
byte[] daclOld = null;
|
|
byte[] daclNew = null;
|
|
FileAction lastAction = FileAction.Error;
|
|
DateTime utcLastCompletion = DateTime.MinValue;
|
|
bool isSpecialDirectoryChange = false;
|
|
|
|
#if DBG
|
|
string reasonIgnore = string.Empty;
|
|
string reasonFire = string.Empty;
|
|
#endif
|
|
|
|
// We've already stopped monitoring, but a change completion was
|
|
// posted afterwards. Ignore it.
|
|
if (_dirMonCompletion == null) {
|
|
return;
|
|
}
|
|
|
|
lock (this) {
|
|
if (_fileMons.Count > 0) {
|
|
if (action == FileAction.Error || action == FileAction.Overwhelming) {
|
|
// Overwhelming change -- notify all file monitors
|
|
Debug.Assert(fileName == null, "fileName == null");
|
|
Debug.Assert(action != FileAction.Overwhelming, "action != FileAction.Overwhelming");
|
|
|
|
if (action == FileAction.Overwhelming) {
|
|
//increase file notification buffer size, but only once per app instance
|
|
if (Interlocked.Increment(ref s_notificationBufferSizeIncreased) == 1) {
|
|
UnsafeNativeMethods.GrowFileNotificationBuffer( HttpRuntime.AppDomainAppId, _watchSubtree );
|
|
}
|
|
}
|
|
|
|
// Get targets for all files
|
|
targets = new ArrayList();
|
|
foreach (DictionaryEntry d in _fileMons) {
|
|
key = (string) d.Key;
|
|
fileMon = (FileMonitor) d.Value;
|
|
if (fileMon.FileNameLong == key) {
|
|
fileMon.ResetCachedAttributes();
|
|
fileMon.LastAction = action;
|
|
fileMon.UtcLastCompletion = utcCompletion;
|
|
col = fileMon.Targets;
|
|
targets.AddRange(col);
|
|
}
|
|
}
|
|
|
|
fileMon = null;
|
|
}
|
|
else {
|
|
Debug.Assert((int) action >= 1 && fileName != null && fileName.Length > 0,
|
|
"(int) action >= 1 && fileName != null && fileName.Length > 0");
|
|
|
|
// Find the file monitor
|
|
fileMon = (FileMonitor)_fileMons[fileName];
|
|
|
|
if (_isDirMonAppPathInternal && fileMon == null) {
|
|
isSpecialDirectoryChange = GetFileMonitorForSpecialDirectory(fileName, ref fileMon);
|
|
}
|
|
|
|
if (fileMon != null) {
|
|
// Get the targets
|
|
col = fileMon.Targets;
|
|
targets = new ArrayList(col);
|
|
|
|
fadOld = fileMon.Attributes;
|
|
daclOld = fileMon.Dacl;
|
|
lastAction = fileMon.LastAction;
|
|
utcLastCompletion = fileMon.UtcLastCompletion;
|
|
fileMon.LastAction = action;
|
|
fileMon.UtcLastCompletion = utcCompletion;
|
|
|
|
if (action == FileAction.Removed || action == FileAction.RenamedOldName) {
|
|
// File not longer exists.
|
|
fileMon.MakeExtinct();
|
|
}
|
|
else if (fileMon.Exists) {
|
|
// We only need to update the attributes if this is
|
|
// a different completion, as we retreive the attributes
|
|
// after the completion is received.
|
|
if (utcLastCompletion != utcCompletion) {
|
|
fileMon.UpdateCachedAttributes();
|
|
}
|
|
}
|
|
else {
|
|
// File now exists - update short name and attributes.
|
|
FindFileData ffd = null;
|
|
string path = Path.Combine(Directory, fileMon.FileNameLong);
|
|
int hr;
|
|
if (_isDirMonAppPathInternal) {
|
|
hr = FindFileData.FindFile(path, Directory, out ffd);
|
|
}
|
|
else {
|
|
hr = FindFileData.FindFile(path, out ffd);
|
|
}
|
|
if (hr == HResults.S_OK) {
|
|
Debug.Assert(StringUtil.EqualsIgnoreCase(fileMon.FileNameLong, ffd.FileNameLong),
|
|
"StringUtil.EqualsIgnoreCase(fileMon.FileNameLong, ffd.FileNameLong)");
|
|
|
|
string oldFileNameShort = fileMon.FileNameShort;
|
|
byte[] dacl = FileSecurity.GetDacl(path);
|
|
fileMon.MakeExist(ffd, dacl);
|
|
UpdateFileNameShort(fileMon, oldFileNameShort, ffd.FileNameShort);
|
|
}
|
|
}
|
|
|
|
fadNew = fileMon.Attributes;
|
|
daclNew = fileMon.Dacl;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Notify the delegate waiting for any changes
|
|
if (_anyFileMon != null) {
|
|
col = _anyFileMon.Targets;
|
|
if (targets != null) {
|
|
targets.AddRange(col);
|
|
}
|
|
else {
|
|
targets = new ArrayList(col);
|
|
}
|
|
}
|
|
|
|
if (action == FileAction.Error) {
|
|
// Stop monitoring.
|
|
((IDisposable)this).Dispose();
|
|
}
|
|
}
|
|
|
|
// Ignore Modified action for directories (VSWhidbey 295597)
|
|
bool ignoreThisChangeNotification = false;
|
|
|
|
if (!isSpecialDirectoryChange && fileName != null && action == FileAction.Modified) {
|
|
// check if the file is a directory (reuse attributes if already obtained)
|
|
FileAttributesData fad = fadNew;
|
|
|
|
if (fad == null) {
|
|
string path = Path.Combine(Directory, fileName);
|
|
FileAttributesData.GetFileAttributes(path, out fad);
|
|
}
|
|
|
|
if (fad != null && ((fad.FileAttributes & FileAttributes.Directory) != 0)) {
|
|
// ignore if directory
|
|
ignoreThisChangeNotification = true;
|
|
}
|
|
}
|
|
|
|
// Dev10 440497: Don't unload AppDomain when a folder is deleted or renamed, unless we're monitoring files in it
|
|
if (_ignoreSubdirChange && (action == FileAction.Removed || action == FileAction.RenamedOldName) && fileName != null) {
|
|
string fullPath = Path.Combine(Directory, fileName);
|
|
if (!HttpRuntime.FileChangesMonitor.IsDirNameMonitored(fullPath, fileName)) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorIgnoreSubdirChange",
|
|
"*** Ignoring SubDirChange " + DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture)
|
|
+ ": fullPath=" + fullPath + ", action=" + action.ToString());
|
|
#endif
|
|
ignoreThisChangeNotification = true;
|
|
}
|
|
#if DBG
|
|
else {
|
|
Debug.Trace("FileChangesMonitorIgnoreSubdirChange",
|
|
"*** SubDirChange " + DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture)
|
|
+ ": fullPath=" + fullPath + ", action=" + action.ToString());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Fire the event
|
|
if (targets != null && !ignoreThisChangeNotification) {
|
|
Debug.Dump("FileChangesMonitor", HttpRuntime.FileChangesMonitor);
|
|
|
|
lock (s_notificationQueue.SyncRoot) {
|
|
for (i = 0, n = targets.Count; i < n; i++) {
|
|
//
|
|
// Determine whether the change is significant, and if so, add it
|
|
// to the notification queue.
|
|
//
|
|
// - A change is significant if action is other than Added or Modified
|
|
// - A change is significant if the action is Added and it occurred after
|
|
// the target started monitoring.
|
|
// - If the action is Modified:
|
|
// -- A change is significant if the file contents were modified
|
|
// and it occurred after the target started monitoring.
|
|
// -- A change is significant if the DACL changed. We cannot check if
|
|
// the change was made after the target started monitoring in this case,
|
|
// as the LastAccess time may not be updated.
|
|
//
|
|
target = (FileMonitorTarget)targets[i];
|
|
bool isSignificantChange;
|
|
if ((action != FileAction.Added && action != FileAction.Modified) || fadNew == null) {
|
|
|
|
// Any change other than Added or Modified is significant.
|
|
// If we have no attributes to examine, the change is significant.
|
|
isSignificantChange = true;
|
|
|
|
#if DBG
|
|
reasonFire = "(action != FileAction.Added && action != FileAction.Modified) || fadNew == null";
|
|
#endif
|
|
}
|
|
else if (action == FileAction.Added) {
|
|
// Added actions are significant if they occur after we started monitoring.
|
|
isSignificantChange = IsChangeAfterStartMonitoring(fadNew, target, utcCompletion);
|
|
|
|
#if DBG
|
|
reasonIgnore = "change occurred before started monitoring";
|
|
reasonFire = "file added after start of monitoring";
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
Debug.Assert(action == FileAction.Modified, "action == FileAction.Modified");
|
|
if (utcCompletion == utcLastCompletion) {
|
|
// File attributes and ACLs will not have changed if the completion is the same
|
|
// as the last, since we get the attributes after all changes in the completion
|
|
// have occurred. Therefore if the previous change was Modified, there
|
|
// is no change that we can detect.
|
|
//
|
|
// Notepad fires such spurious notifications when a file is saved.
|
|
//
|
|
isSignificantChange = (lastAction != FileAction.Modified);
|
|
|
|
#if DBG
|
|
reasonIgnore = "spurious FileAction.Modified";
|
|
reasonFire = "spurious completion where action != modified";
|
|
#endif
|
|
|
|
}
|
|
else if (fadOld == null) {
|
|
// There were no attributes before this notification,
|
|
// so assume the change is significant. We cannot check for
|
|
// whether the change was after the start of monitoring,
|
|
// because we don't know if the content changed, or just
|
|
// DACL, in which case the LastAccessTime will not be updated.
|
|
isSignificantChange = true;
|
|
|
|
#if DBG
|
|
reasonFire = "no attributes before this notification";
|
|
#endif
|
|
}
|
|
else if (daclOld == null || daclOld != daclNew) {
|
|
// The change is significant if the DACL changed.
|
|
// We cannot check if the change is after the start of monitoring,
|
|
// as a change in the DACL does not necessarily update the
|
|
// LastAccessTime of a file.
|
|
// If we cannot access the DACL, then we must assume
|
|
// that it is what has changed.
|
|
isSignificantChange = true;
|
|
|
|
#if DBG
|
|
if (daclOld == null) {
|
|
reasonFire = "unable to access ACL";
|
|
}
|
|
else {
|
|
reasonFire = "ACL changed";
|
|
}
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
// The file content was modified. We cannot guarantee that the
|
|
// LastWriteTime or FileSize changed when the file changed, as
|
|
// copying a file preserves the LastWriteTime, and the "touch"
|
|
// command can reset the LastWriteTime of many files to the same
|
|
// time.
|
|
//
|
|
// If the file content is modified, we can determine if the file
|
|
// was not changed after the start of monitoring by looking at
|
|
// the LastAccess time.
|
|
isSignificantChange = IsChangeAfterStartMonitoring(fadNew, target, utcCompletion);
|
|
|
|
#if DBG
|
|
reasonIgnore = "change occurred before started monitoring";
|
|
reasonFire = "file content modified after start of monitoring";
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
if (isSignificantChange) {
|
|
#if DBG
|
|
Debug.Trace("FileChangesMonitorCallback", "Firing change event, reason=" + reasonFire +
|
|
"\n\tArgs: Action=" + action + "; Completion=" + Debug.FormatUtcDate(utcCompletion) + "; fileName=" + fileName +
|
|
"\n\t LastAction=" + lastAction + "; LastCompletion=" + Debug.FormatUtcDate(utcLastCompletion) +
|
|
"\nfadOld=" + ((fadOld != null) ? fadOld.DebugDescription("\t") : "<null>") +
|
|
"\nfileMon=" + ((fileMon != null) ? fileMon.DebugDescription("\t") : "<null>") +
|
|
"\n" + target.DebugDescription("\t"));
|
|
#endif
|
|
|
|
s_notificationQueue.Enqueue(new NotificationQueueItem(target.Callback, action, target.Alias));
|
|
}
|
|
#if DBG
|
|
else {
|
|
Debug.Trace("FileChangesMonitorCallback", "Ignoring change event, reason=" + reasonIgnore +
|
|
"\n\tArgs: Action=" + action + "; Completion=" + Debug.FormatUtcDate(utcCompletion) + "; fileName=" + fileName +
|
|
"\n\t LastAction=" + lastAction + "; LastCompletion=" + Debug.FormatUtcDate(utcLastCompletion) +
|
|
"\nfadOld=" + ((fadOld != null) ? fadOld.DebugDescription("\t") : "<null>") +
|
|
"\nfileMon=" + ((fileMon != null) ? fileMon.DebugDescription("\t") : "<null>") +
|
|
"\n" + target.DebugDescription("\t"));
|
|
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (s_notificationQueue.Count > 0 && s_inNotificationThread == 0 && Interlocked.Exchange(ref s_inNotificationThread, 1) == 0) {
|
|
WorkItem.PostInternal(s_notificationCallback);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex) {
|
|
Debug.Trace(Debug.TAG_INTERNAL,
|
|
"Exception thrown processing file change notification" +
|
|
" action=" + action.ToString() +
|
|
" fileName" + fileName);
|
|
|
|
Debug.TraceException(Debug.TAG_INTERNAL, ex);
|
|
}
|
|
}
|
|
|
|
// Fire notifications on a separate thread from that which received the notifications,
|
|
// so that we don't block notification collection.
|
|
static void FireNotifications() {
|
|
try {
|
|
// Outer loop: test whether we need to fire notifications and grab the lock
|
|
for (;;) {
|
|
// Inner loop: fire notifications until the queue is emptied
|
|
for (;;) {
|
|
// Remove an item from the queue.
|
|
NotificationQueueItem nqi = null;
|
|
lock (s_notificationQueue.SyncRoot) {
|
|
if (s_notificationQueue.Count > 0) {
|
|
nqi = (NotificationQueueItem) s_notificationQueue.Dequeue();
|
|
}
|
|
}
|
|
|
|
if (nqi == null)
|
|
break;
|
|
|
|
try {
|
|
Debug.Trace("FileChangesMonitorFireNotification", "Firing change event" +
|
|
"\n\tArgs: Action=" + nqi.Action + "; fileName=" + nqi.Filename + "; Target=" + nqi.Callback.Target + "(HC=" + nqi.Callback.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")");
|
|
|
|
// Call the callback
|
|
nqi.Callback(null, new FileChangeEvent(nqi.Action, nqi.Filename));
|
|
}
|
|
catch (Exception ex) {
|
|
Debug.Trace(Debug.TAG_INTERNAL,
|
|
"Exception thrown in file change callback" +
|
|
" action=" + nqi.Action.ToString() +
|
|
" fileName" + nqi.Filename);
|
|
|
|
Debug.TraceException(Debug.TAG_INTERNAL, ex);
|
|
}
|
|
}
|
|
|
|
// Release the lock
|
|
Interlocked.Exchange(ref s_inNotificationThread, 0);
|
|
|
|
// We need to test again to avoid ---- where a thread that receives notifications adds to the
|
|
// queue, but does not spawn a thread because s_inNotificationThread = 1
|
|
if (s_notificationQueue.Count == 0 || Interlocked.Exchange(ref s_inNotificationThread, 1) != 0)
|
|
break;
|
|
}
|
|
}
|
|
catch {
|
|
Interlocked.Exchange(ref s_inNotificationThread, 0);
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
internal string DebugDescription(string indent) {
|
|
StringBuilder sb = new StringBuilder(200);
|
|
string i2 = indent + " ";
|
|
DictionaryEntryCaseInsensitiveComparer decomparer = new DictionaryEntryCaseInsensitiveComparer();
|
|
|
|
lock (this) {
|
|
DictionaryEntry[] fileEntries = new DictionaryEntry[_fileMons.Count];
|
|
_fileMons.CopyTo(fileEntries, 0);
|
|
Array.Sort(fileEntries, decomparer);
|
|
|
|
sb.Append(indent + "System.Web.DirectoryMonitor: " + Directory + "\n");
|
|
if (_dirMonCompletion != null) {
|
|
sb.Append(i2 + "_dirMonCompletion " + _dirMonCompletion.DebugDescription(String.Empty));
|
|
}
|
|
else {
|
|
sb.Append(i2 + "_dirMonCompletion = <null>\n");
|
|
}
|
|
|
|
sb.Append(i2 + GetFileMonitorsCount() + " file monitors...\n");
|
|
if (_anyFileMon != null) {
|
|
sb.Append(_anyFileMon.DebugDescription(i2));
|
|
}
|
|
|
|
foreach (DictionaryEntry d in fileEntries) {
|
|
FileMonitor fileMon = (FileMonitor)d.Value;
|
|
if (fileMon.FileNameShort == (string)d.Key)
|
|
continue;
|
|
|
|
sb.Append(fileMon.DebugDescription(i2));
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
#endif
|
|
}
|
|
#endif // !FEATURE_PAL
|
|
|
|
//
|
|
// Manager for directory monitors.
|
|
// Provides file change notification services in ASP.NET
|
|
//
|
|
sealed class FileChangesMonitor {
|
|
#if !FEATURE_PAL // FEATURE_PAL does not enable file change notification
|
|
internal static string[] s_dirsToMonitor = new string[] {
|
|
HttpRuntime.BinDirectoryName,
|
|
HttpRuntime.ResourcesDirectoryName,
|
|
HttpRuntime.CodeDirectoryName,
|
|
HttpRuntime.WebRefDirectoryName,
|
|
HttpRuntime.BrowsersDirectoryName
|
|
};
|
|
|
|
internal const int MAX_PATH = 260;
|
|
|
|
#pragma warning disable 0649
|
|
ReadWriteSpinLock _lockDispose; // spinlock for coordinating dispose
|
|
#pragma warning restore 0649
|
|
|
|
bool _disposed; // have we disposed?
|
|
Hashtable _aliases; // alias -> FileMonitor
|
|
Hashtable _dirs; // dir -> DirectoryMonitor
|
|
DirectoryMonitor _dirMonSubdirs; // subdirs monitor for renames
|
|
Hashtable _subDirDirMons; // Hashtable of DirectoryMonitor used in ListenToSubdirectoryChanges
|
|
ArrayList _dirMonSpecialDirs; // top level dirs we monitor
|
|
FileChangeEventHandler _callbackRenameOrCriticaldirChange; // event handler for renames and bindir
|
|
int _activeCallbackCount; // number of callbacks currently executing
|
|
DirectoryMonitor _dirMonAppPathInternal; // watches all files and subdirectories (at any level) beneath HttpRuntime.AppDomainAppPathInternal
|
|
String _appPathInternal; // HttpRuntime.AppDomainAppPathInternal
|
|
int _FCNMode; // from registry, controls how we monitor directories
|
|
|
|
#if DBG
|
|
internal static bool s_enableRemoveTargetAssert;
|
|
#endif
|
|
|
|
// Dev10 927283: We were appending to HttpRuntime._shutdownMessage in DirectoryMonitor.OnFileChange when
|
|
// we received overwhelming changes and errors, but not all overwhelming file change notifications result
|
|
// in a shutdown. The fix is to only append to _shutdownMessage when the domain is being shutdown.
|
|
internal static string GenerateErrorMessage(FileAction action, String fileName = null) {
|
|
string message = null;
|
|
if (action == FileAction.Overwhelming) {
|
|
message = "Overwhelming Change Notification in ";
|
|
}
|
|
else if (action == FileAction.Error) {
|
|
message = "File Change Notification Error in ";
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
return (fileName != null) ? message + Path.GetDirectoryName(fileName) : message;
|
|
}
|
|
|
|
internal static HttpException CreateFileMonitoringException(int hr, string path) {
|
|
string message;
|
|
bool logEvent = false;
|
|
|
|
switch (hr) {
|
|
case HResults.E_FILENOTFOUND:
|
|
case HResults.E_PATHNOTFOUND:
|
|
message = SR.Directory_does_not_exist_for_monitoring;
|
|
break;
|
|
|
|
case HResults.E_ACCESSDENIED:
|
|
message = SR.Access_denied_for_monitoring;
|
|
logEvent = true;
|
|
break;
|
|
|
|
case HResults.E_INVALIDARG:
|
|
message = SR.Invalid_file_name_for_monitoring;
|
|
break;
|
|
|
|
case HResults.ERROR_TOO_MANY_CMDS:
|
|
message = SR.NetBios_command_limit_reached;
|
|
logEvent = true;
|
|
break;
|
|
|
|
default:
|
|
message = SR.Failed_to_start_monitoring;
|
|
break;
|
|
}
|
|
|
|
|
|
if (logEvent) {
|
|
// Need to raise an eventlog too.
|
|
UnsafeNativeMethods.RaiseFileMonitoringEventlogEvent(
|
|
SR.GetString(message, HttpRuntime.GetSafePath(path)) +
|
|
"\n\r" +
|
|
SR.GetString(SR.App_Virtual_Path, HttpRuntime.AppDomainAppVirtualPath),
|
|
path, HttpRuntime.AppDomainAppVirtualPath, hr);
|
|
}
|
|
|
|
return new HttpException(SR.GetString(message, HttpRuntime.GetSafePath(path)), hr);
|
|
}
|
|
|
|
internal static string GetFullPath(string alias) {
|
|
// Assert PathDiscovery before call to Path.GetFullPath
|
|
try {
|
|
new FileIOPermission(FileIOPermissionAccess.PathDiscovery, alias).Assert();
|
|
}
|
|
catch {
|
|
throw CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
string path = Path.GetFullPath(alias);
|
|
path = FileUtil.RemoveTrailingDirectoryBackSlash(path);
|
|
|
|
return path;
|
|
}
|
|
|
|
private bool IsBeneathAppPathInternal(string fullPathName) {
|
|
if (_appPathInternal != null
|
|
&& fullPathName.Length > _appPathInternal.Length+1
|
|
&& fullPathName.IndexOf(_appPathInternal, StringComparison.OrdinalIgnoreCase) > -1
|
|
&& fullPathName[_appPathInternal.Length] == Path.DirectorySeparatorChar) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool IsFCNDisabled { get { return _FCNMode == 1; } }
|
|
|
|
internal FileChangesMonitor(FcnMode mode) {
|
|
// Possible values for DWORD FCNMode:
|
|
// does not exist == default behavior (create DirectoryMonitor for each subdir)
|
|
// 0 or >2 == default behavior (create DirectoryMonitor for each subdir)
|
|
// 1 == disable File Change Notifications (FCN)
|
|
// 2 == create 1 DirectoryMonitor for AppPathInternal and watch subtrees
|
|
switch (mode) {
|
|
case FcnMode.NotSet:
|
|
// If the mode is not set, we use the registry key's value
|
|
UnsafeNativeMethods.GetDirMonConfiguration(out _FCNMode);
|
|
break;
|
|
case FcnMode.Disabled:
|
|
_FCNMode = 1;
|
|
break;
|
|
case FcnMode.Single:
|
|
_FCNMode = 2;
|
|
break;
|
|
case FcnMode.Default:
|
|
default:
|
|
_FCNMode = 0;
|
|
break;
|
|
}
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
_aliases = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));
|
|
_dirs = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
_subDirDirMons = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
|
|
if (_FCNMode == 2 && HttpRuntime.AppDomainAppPathInternal != null) {
|
|
_appPathInternal = GetFullPath(HttpRuntime.AppDomainAppPathInternal);
|
|
_dirMonAppPathInternal = new DirectoryMonitor(_appPathInternal, _FCNMode);
|
|
}
|
|
|
|
#if DBG
|
|
if ((int)Misc.GetAspNetRegValue(null /*subKey*/, "FCMRemoveTargetAssert", 0) > 0) {
|
|
s_enableRemoveTargetAssert = true;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
internal bool IsDirNameMonitored(string fullPath, string dirName) {
|
|
// is it one of the not-so-special directories we're monitoring?
|
|
if (_dirs.ContainsKey(fullPath)) {
|
|
return true;
|
|
}
|
|
// is it one of the special directories (bin, App_Code, etc) or a subfolder?
|
|
foreach (string specialDirName in s_dirsToMonitor) {
|
|
if (StringUtil.StringStartsWithIgnoreCase(dirName, specialDirName)) {
|
|
// a special directory?
|
|
if (dirName.Length == specialDirName.Length) {
|
|
return true;
|
|
}
|
|
// a subfolder?
|
|
else if (dirName.Length > specialDirName.Length && dirName[specialDirName.Length] == Path.DirectorySeparatorChar) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
// Dev10 Bug 663511: Deletes, moves, and renames of the App_LocalResources folder may be ignored
|
|
if (dirName.IndexOf(HttpRuntime.LocalResourcesDirectoryName, StringComparison.OrdinalIgnoreCase) > -1) {
|
|
return true;
|
|
}
|
|
// we're not monitoring it
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Find the directory monitor. If not found, maybe add it.
|
|
// If the directory is not actively monitoring, ensure that
|
|
// it still represents an accessible directory.
|
|
//
|
|
DirectoryMonitor FindDirectoryMonitor(string dir, bool addIfNotFound, bool throwOnError) {
|
|
DirectoryMonitor dirMon;
|
|
FileAttributesData fad = null;
|
|
int hr;
|
|
|
|
dirMon = (DirectoryMonitor)_dirs[dir];
|
|
if (dirMon != null) {
|
|
if (!dirMon.IsMonitoring()) {
|
|
hr = FileAttributesData.GetFileAttributes(dir, out fad);
|
|
if (hr != HResults.S_OK || (fad.FileAttributes & FileAttributes.Directory) == 0) {
|
|
dirMon = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dirMon != null || !addIfNotFound) {
|
|
return dirMon;
|
|
}
|
|
|
|
lock (_dirs.SyncRoot) {
|
|
// Check again, this time under synchronization.
|
|
dirMon = (DirectoryMonitor)_dirs[dir];
|
|
if (dirMon != null) {
|
|
if (!dirMon.IsMonitoring()) {
|
|
// Fail if it's not a directory or inaccessible.
|
|
hr = FileAttributesData.GetFileAttributes(dir, out fad);
|
|
if (hr == HResults.S_OK && (fad.FileAttributes & FileAttributes.Directory) == 0) {
|
|
// Fail if it's not a directory.
|
|
hr = HResults.E_INVALIDARG;
|
|
}
|
|
|
|
if (hr != HResults.S_OK) {
|
|
// Not accessible or a dir, so stop monitoring and remove.
|
|
_dirs.Remove(dir);
|
|
dirMon.StopMonitoring();
|
|
if (addIfNotFound && throwOnError) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(hr, dir);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
else if (addIfNotFound) {
|
|
// Fail if it's not a directory or inaccessible.
|
|
hr = FileAttributesData.GetFileAttributes(dir, out fad);
|
|
if (hr == HResults.S_OK && (fad.FileAttributes & FileAttributes.Directory) == 0) {
|
|
hr = HResults.E_INVALIDARG;
|
|
}
|
|
|
|
if (hr == HResults.S_OK) {
|
|
// Add a new directory monitor.
|
|
dirMon = new DirectoryMonitor(dir, false, UnsafeNativeMethods.RDCW_FILTER_FILE_AND_DIR_CHANGES, _FCNMode);
|
|
_dirs.Add(dir, dirMon);
|
|
}
|
|
else if (throwOnError) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(hr, dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
return dirMon;
|
|
}
|
|
|
|
// Remove the aliases of a file monitor.
|
|
internal void RemoveAliases(FileMonitor fileMon) {
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
foreach (DictionaryEntry entry in fileMon.Aliases) {
|
|
if (_aliases[entry.Key] == fileMon) {
|
|
_aliases.Remove(entry.Key);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to monitor a file, which may or may not exist.
|
|
//
|
|
internal DateTime StartMonitoringFile(string alias, FileChangeEventHandler callback) {
|
|
Debug.Trace("FileChangesMonitor", "StartMonitoringFile\n" + "\tArgs: File=" + alias + "; Callback=" + callback.Target + "(HC=" + callback.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")");
|
|
|
|
FileMonitor fileMon;
|
|
DirectoryMonitor dirMon;
|
|
string fullPathName, dir, file;
|
|
bool addAlias = false;
|
|
|
|
if (alias == null) {
|
|
throw CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
if (IsFCNDisabled) {
|
|
fullPathName = GetFullPath(alias);
|
|
FindFileData ffd = null;
|
|
int hr = FindFileData.FindFile(fullPathName, out ffd);
|
|
if (hr == HResults.S_OK) {
|
|
return ffd.FileAttributesData.UtcLastWriteTime;
|
|
}
|
|
else {
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try{
|
|
// Don't start monitoring if disposed.
|
|
if (_disposed) {
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
fileMon = (FileMonitor)_aliases[alias];
|
|
if (fileMon != null) {
|
|
// Used the cached directory monitor and file name.
|
|
dirMon = fileMon.DirectoryMonitor;
|
|
file = fileMon.FileNameLong;
|
|
}
|
|
else {
|
|
addAlias = true;
|
|
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
//
|
|
// Get the directory and file name, and lookup
|
|
// the directory monitor.
|
|
//
|
|
fullPathName = GetFullPath(alias);
|
|
|
|
if (IsBeneathAppPathInternal(fullPathName)) {
|
|
dirMon = _dirMonAppPathInternal;
|
|
file = fullPathName.Substring(_appPathInternal.Length+1);
|
|
}
|
|
else {
|
|
dir = UrlPath.GetDirectoryOrRootName(fullPathName);
|
|
file = Path.GetFileName(fullPathName);
|
|
if (String.IsNullOrEmpty(file)) {
|
|
// not a file
|
|
throw CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
dirMon = FindDirectoryMonitor(dir, true /*addIfNotFound*/, true /*throwOnError*/);
|
|
}
|
|
}
|
|
|
|
fileMon = dirMon.StartMonitoringFileWithAssert(file, callback, alias);
|
|
if (addAlias) {
|
|
_aliases[alias] = fileMon;
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
|
|
FileAttributesData fad;
|
|
fileMon.DirectoryMonitor.GetFileAttributes(file, out fad);
|
|
|
|
Debug.Dump("FileChangesMonitor", this);
|
|
|
|
if (fad != null) {
|
|
return fad.UtcLastWriteTime;
|
|
}
|
|
else {
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to monitor a path, which may be file, directory, or non-existent
|
|
// file.
|
|
//
|
|
internal DateTime StartMonitoringPath(string alias, FileChangeEventHandler callback, out FileAttributesData fad) {
|
|
Debug.Trace("FileChangesMonitor", "StartMonitoringPath\n" + "\tArgs: File=" + alias + "; Callback=" + callback.Target + "(HC=" + callback.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")");
|
|
|
|
FileMonitor fileMon = null;
|
|
DirectoryMonitor dirMon = null;
|
|
string fullPathName, dir, file = null;
|
|
bool addAlias = false;
|
|
|
|
fad = null;
|
|
|
|
if (alias == null) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, String.Empty));
|
|
}
|
|
|
|
if (IsFCNDisabled) {
|
|
fullPathName = GetFullPath(alias);
|
|
FindFileData ffd = null;
|
|
int hr = FindFileData.FindFile(fullPathName, out ffd);
|
|
if (hr == HResults.S_OK) {
|
|
fad = ffd.FileAttributesData;
|
|
return ffd.FileAttributesData.UtcLastWriteTime;
|
|
}
|
|
else {
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try{
|
|
if (_disposed) {
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
// do/while loop once to make breaking out easy
|
|
do {
|
|
fileMon = (FileMonitor)_aliases[alias];
|
|
if (fileMon != null) {
|
|
// Used the cached directory monitor and file name.
|
|
file = fileMon.FileNameLong;
|
|
fileMon = fileMon.DirectoryMonitor.StartMonitoringFileWithAssert(file, callback, alias);
|
|
continue;
|
|
}
|
|
|
|
addAlias = true;
|
|
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, HttpRuntime.GetSafePath(alias)));
|
|
}
|
|
|
|
fullPathName = GetFullPath(alias);
|
|
|
|
// see if the path is beneath HttpRuntime.AppDomainAppPathInternal
|
|
if (IsBeneathAppPathInternal(fullPathName)) {
|
|
dirMon = _dirMonAppPathInternal;
|
|
file = fullPathName.Substring(_appPathInternal.Length+1);
|
|
fileMon = dirMon.StartMonitoringFileWithAssert(file, callback, alias);
|
|
continue;
|
|
}
|
|
|
|
// try treating the path as a directory
|
|
dirMon = FindDirectoryMonitor(fullPathName, false, false);
|
|
if (dirMon != null) {
|
|
fileMon = dirMon.StartMonitoringFileWithAssert(null, callback, alias);
|
|
continue;
|
|
}
|
|
|
|
// try treaing the path as a file
|
|
dir = UrlPath.GetDirectoryOrRootName(fullPathName);
|
|
file = Path.GetFileName(fullPathName);
|
|
if (!String.IsNullOrEmpty(file)) {
|
|
dirMon = FindDirectoryMonitor(dir, false, false);
|
|
if (dirMon != null) {
|
|
// try to add it - a file is the common case,
|
|
// and we avoid hitting the disk twice
|
|
try {
|
|
fileMon = dirMon.StartMonitoringFileWithAssert(file, callback, alias);
|
|
}
|
|
catch {
|
|
}
|
|
|
|
if (fileMon != null) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We aren't monitoring this path or its parent directory yet.
|
|
// Hit the disk to determine if it's a directory or file.
|
|
dirMon = FindDirectoryMonitor(fullPathName, true, false);
|
|
if (dirMon != null) {
|
|
// It's a directory, so monitor all changes in it
|
|
file = null;
|
|
}
|
|
else {
|
|
// It's not a directory, so treat as file
|
|
if (String.IsNullOrEmpty(file)) {
|
|
throw CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
dirMon = FindDirectoryMonitor(dir, true, true);
|
|
}
|
|
|
|
fileMon = dirMon.StartMonitoringFileWithAssert(file, callback, alias);
|
|
} while (false);
|
|
|
|
if (!fileMon.IsDirectory) {
|
|
fileMon.DirectoryMonitor.GetFileAttributes(file, out fad);
|
|
}
|
|
|
|
if (addAlias) {
|
|
_aliases[alias] = fileMon;
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
|
|
Debug.Dump("FileChangesMonitor", this);
|
|
|
|
if (fad != null) {
|
|
return fad.UtcLastWriteTime;
|
|
}
|
|
else {
|
|
return DateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to monitor the bin directory and directory renames anywhere under app
|
|
//
|
|
|
|
internal void StartMonitoringDirectoryRenamesAndBinDirectory(string dir, FileChangeEventHandler callback) {
|
|
Debug.Trace("FileChangesMonitor", "StartMonitoringDirectoryRenamesAndBinDirectory\n" + "\tArgs: File=" + dir + "; Callback=" + callback.Target + "(HC=" + callback.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")");
|
|
|
|
if (String.IsNullOrEmpty(dir)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, String.Empty));
|
|
}
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Assert(_dirs.Count == 0, "This function must be called before monitoring other directories, otherwise monitoring of UNC directories will be unreliable on Windows2000 Server.");
|
|
#endif
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try {
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
_callbackRenameOrCriticaldirChange = callback;
|
|
|
|
string dirRoot = GetFullPath(dir);
|
|
|
|
// Monitor bin directory and app directory (for renames only) separately
|
|
// to avoid overwhelming changes when the user writes to a subdirectory
|
|
// of the app directory.
|
|
|
|
_dirMonSubdirs = new DirectoryMonitor(dirRoot, true, UnsafeNativeMethods.RDCW_FILTER_DIR_RENAMES, true, _FCNMode);
|
|
try {
|
|
_dirMonSubdirs.StartMonitoringFileWithAssert(null, new FileChangeEventHandler(this.OnSubdirChange), dirRoot);
|
|
}
|
|
catch {
|
|
((IDisposable)_dirMonSubdirs).Dispose();
|
|
_dirMonSubdirs = null;
|
|
throw;
|
|
}
|
|
|
|
_dirMonSpecialDirs = new ArrayList();
|
|
for (int i=0; i<s_dirsToMonitor.Length; i++) {
|
|
_dirMonSpecialDirs.Add(ListenToSubdirectoryChanges(dirRoot, s_dirsToMonitor[i]));
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Monitor a directory that causes an appdomain shutdown when it changes
|
|
//
|
|
internal void StartListeningToLocalResourcesDirectory(VirtualPath virtualDir) {
|
|
Debug.Trace("FileChangesMonitor", "StartListeningToVirtualSubdirectory\n" + "\tArgs: virtualDir=" + virtualDir);
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
// In some situation (not well understood yet), we get here with either
|
|
// _callbackRenameOrCriticaldirChange or _dirMonSpecialDirs being null (VSWhidbey #215040).
|
|
// When that happens, just return.
|
|
//Debug.Assert(_callbackRenameOrCriticaldirChange != null);
|
|
//Debug.Assert(_dirMonSpecialDirs != null);
|
|
if (_callbackRenameOrCriticaldirChange == null || _dirMonSpecialDirs == null)
|
|
return;
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try {
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
// Get the physical path, and split it into the parent dir and the dir name
|
|
string dir = virtualDir.MapPath();
|
|
dir = FileUtil.RemoveTrailingDirectoryBackSlash(dir);
|
|
string name = Path.GetFileName(dir);
|
|
dir = Path.GetDirectoryName(dir);
|
|
|
|
// If the physical parent directory doesn't exist, don't do anything.
|
|
// This could happen when using a non-file system based VirtualPathProvider
|
|
if (!Directory.Exists(dir))
|
|
return;
|
|
|
|
_dirMonSpecialDirs.Add(ListenToSubdirectoryChanges(dir, name));
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
DirectoryMonitor ListenToSubdirectoryChanges(string dirRoot, string dirToListenTo) {
|
|
|
|
string dirRootSubDir;
|
|
DirectoryMonitor dirMonSubDir;
|
|
|
|
if (StringUtil.StringEndsWith(dirRoot, '\\')) {
|
|
dirRootSubDir = dirRoot + dirToListenTo;
|
|
}
|
|
else {
|
|
dirRootSubDir = dirRoot + "\\" + dirToListenTo;
|
|
}
|
|
|
|
if (IsBeneathAppPathInternal(dirRootSubDir)) {
|
|
dirMonSubDir = _dirMonAppPathInternal;
|
|
|
|
dirToListenTo = dirRootSubDir.Substring(_appPathInternal.Length+1);
|
|
Debug.Trace("ListenToSubDir", dirRoot + " " + dirToListenTo);
|
|
dirMonSubDir.StartMonitoringFileWithAssert(dirToListenTo, new FileChangeEventHandler(this.OnCriticaldirChange), dirRootSubDir);
|
|
}
|
|
else if (Directory.Exists(dirRootSubDir)) {
|
|
dirMonSubDir = new DirectoryMonitor(dirRootSubDir, true, UnsafeNativeMethods.RDCW_FILTER_FILE_CHANGES, _FCNMode);
|
|
try {
|
|
dirMonSubDir.StartMonitoringFileWithAssert(null, new FileChangeEventHandler(this.OnCriticaldirChange), dirRootSubDir);
|
|
}
|
|
catch {
|
|
((IDisposable)dirMonSubDir).Dispose();
|
|
dirMonSubDir = null;
|
|
throw;
|
|
}
|
|
}
|
|
else {
|
|
dirMonSubDir = (DirectoryMonitor)_subDirDirMons[dirRoot];
|
|
if (dirMonSubDir == null) {
|
|
dirMonSubDir = new DirectoryMonitor(dirRoot, false, UnsafeNativeMethods.RDCW_FILTER_FILE_AND_DIR_CHANGES, _FCNMode);
|
|
_subDirDirMons[dirRoot] = dirMonSubDir;
|
|
}
|
|
|
|
try {
|
|
dirMonSubDir.StartMonitoringFileWithAssert(dirToListenTo, new FileChangeEventHandler(this.OnCriticaldirChange), dirRootSubDir);
|
|
}
|
|
catch {
|
|
((IDisposable)dirMonSubDir).Dispose();
|
|
dirMonSubDir = null;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
return dirMonSubDir;
|
|
}
|
|
|
|
void OnSubdirChange(Object sender, FileChangeEvent e) {
|
|
try {
|
|
Interlocked.Increment(ref _activeCallbackCount);
|
|
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
Debug.Trace("FileChangesMonitor", "OnSubdirChange\n" + "\tArgs: Action=" + e.Action + "; fileName=" + e.FileName);
|
|
FileChangeEventHandler handler = _callbackRenameOrCriticaldirChange;
|
|
if ( handler != null &&
|
|
(e.Action == FileAction.Error || e.Action == FileAction.Overwhelming || e.Action == FileAction.RenamedOldName || e.Action == FileAction.Removed)) {
|
|
Debug.Trace("FileChangesMonitor", "Firing subdir change event\n" + "\tArgs: Action=" + e.Action + "; fileName=" + e.FileName + "; Target=" + handler.Target + "(HC=" + handler.Target.GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo) + ")");
|
|
|
|
HttpRuntime.SetShutdownMessage(
|
|
SR.GetString(SR.Directory_rename_notification, e.FileName));
|
|
|
|
handler(this, e);
|
|
}
|
|
}
|
|
finally {
|
|
Interlocked.Decrement(ref _activeCallbackCount);
|
|
}
|
|
}
|
|
|
|
void OnCriticaldirChange(Object sender, FileChangeEvent e) {
|
|
try {
|
|
Interlocked.Increment(ref _activeCallbackCount);
|
|
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
Debug.Trace("FileChangesMonitor", "OnCriticaldirChange\n" + "\tArgs: Action=" + e.Action + "; fileName=" + e.FileName);
|
|
HttpRuntime.SetShutdownMessage(SR.GetString(SR.Change_notification_critical_dir));
|
|
FileChangeEventHandler handler = _callbackRenameOrCriticaldirChange;
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
finally {
|
|
Interlocked.Decrement(ref _activeCallbackCount);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to stop monitoring a file.
|
|
//
|
|
internal void StopMonitoringFile(string alias, object target) {
|
|
Debug.Trace("FileChangesMonitor", "StopMonitoringFile\n" + "File=" + alias + "; Callback=" + target);
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
FileMonitor fileMon;
|
|
DirectoryMonitor dirMon = null;
|
|
string fullPathName, file = null, dir;
|
|
|
|
if (alias == null) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, String.Empty));
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try {
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
fileMon = (FileMonitor)_aliases[alias];
|
|
if (fileMon != null && !fileMon.IsDirectory) {
|
|
// Used the cached directory monitor and file name
|
|
dirMon = fileMon.DirectoryMonitor;
|
|
file = fileMon.FileNameLong;
|
|
}
|
|
else {
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, HttpRuntime.GetSafePath(alias)));
|
|
}
|
|
|
|
// Lookup the directory monitor
|
|
fullPathName = GetFullPath(alias);
|
|
dir = UrlPath.GetDirectoryOrRootName(fullPathName);
|
|
file = Path.GetFileName(fullPathName);
|
|
if (String.IsNullOrEmpty(file)) {
|
|
// not a file
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, HttpRuntime.GetSafePath(alias)));
|
|
}
|
|
|
|
dirMon = FindDirectoryMonitor(dir, false, false);
|
|
}
|
|
|
|
if (dirMon != null) {
|
|
dirMon.StopMonitoringFile(file, target);
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to stop monitoring a file.
|
|
//
|
|
internal void StopMonitoringPath(String alias, object target) {
|
|
Debug.Trace("FileChangesMonitor", "StopMonitoringFile\n" + "File=" + alias + "; Callback=" + target);
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
FileMonitor fileMon;
|
|
DirectoryMonitor dirMon = null;
|
|
string fullPathName, file = null, dir;
|
|
|
|
if (alias == null) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, String.Empty));
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try {
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
fileMon = (FileMonitor)_aliases[alias];
|
|
if (fileMon != null) {
|
|
// Used the cached directory monitor and file name.
|
|
dirMon = fileMon.DirectoryMonitor;
|
|
file = fileMon.FileNameLong;
|
|
}
|
|
else {
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_file_name_for_monitoring, HttpRuntime.GetSafePath(alias)));
|
|
}
|
|
|
|
// try treating the path as a directory
|
|
fullPathName = GetFullPath(alias);
|
|
dirMon = FindDirectoryMonitor(fullPathName, false, false);
|
|
if (dirMon == null) {
|
|
// try treaing the path as a file
|
|
dir = UrlPath.GetDirectoryOrRootName(fullPathName);
|
|
file = Path.GetFileName(fullPathName);
|
|
if (!String.IsNullOrEmpty(file)) {
|
|
dirMon = FindDirectoryMonitor(dir, false, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dirMon != null) {
|
|
dirMon.StopMonitoringFile(file, target);
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Returns the last modified time of the file. If the
|
|
// file does not exist, returns DateTime.MinValue.
|
|
//
|
|
internal FileAttributesData GetFileAttributes(string alias) {
|
|
FileMonitor fileMon;
|
|
DirectoryMonitor dirMon = null;
|
|
string fullPathName, file = null, dir;
|
|
FileAttributesData fad = null;
|
|
|
|
if (alias == null) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
if (IsFCNDisabled) {
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
fullPathName = GetFullPath(alias);
|
|
FindFileData ffd = null;
|
|
int hr = FindFileData.FindFile(fullPathName, out ffd);
|
|
if (hr == HResults.S_OK) {
|
|
return ffd.FileAttributesData;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireReaderLock();
|
|
try {
|
|
if (!_disposed) {
|
|
fileMon = (FileMonitor)_aliases[alias];
|
|
if (fileMon != null && !fileMon.IsDirectory) {
|
|
// Used the cached directory monitor and file name.
|
|
dirMon = fileMon.DirectoryMonitor;
|
|
file = fileMon.FileNameLong;
|
|
}
|
|
else {
|
|
if (alias.Length == 0 || !UrlPath.IsAbsolutePhysicalPath(alias)) {
|
|
throw FileChangesMonitor.CreateFileMonitoringException(HResults.E_INVALIDARG, alias);
|
|
}
|
|
|
|
// Lookup the directory monitor
|
|
fullPathName = GetFullPath(alias);
|
|
dir = UrlPath.GetDirectoryOrRootName(fullPathName);
|
|
file = Path.GetFileName(fullPathName);
|
|
if (!String.IsNullOrEmpty(file)) {
|
|
dirMon = FindDirectoryMonitor(dir, false, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseReaderLock();
|
|
}
|
|
|
|
// If we're not monitoring the file, get the attributes.
|
|
if (dirMon == null || !dirMon.GetFileAttributes(file, out fad)) {
|
|
FileAttributesData.GetFileAttributes(alias, out fad);
|
|
}
|
|
|
|
return fad;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Request to stop monitoring everything -- release all native resources
|
|
//
|
|
internal void Stop() {
|
|
Debug.Trace("FileChangesMonitor", "Stop!");
|
|
|
|
if (IsFCNDisabled) {
|
|
return;
|
|
}
|
|
|
|
using (new ApplicationImpersonationContext()) {
|
|
_lockDispose.AcquireWriterLock();
|
|
try {
|
|
_disposed = true;
|
|
}
|
|
finally {
|
|
_lockDispose.ReleaseWriterLock();
|
|
}
|
|
|
|
// wait for executing callbacks to complete
|
|
while(_activeCallbackCount != 0) {
|
|
Thread.Sleep(250);
|
|
}
|
|
|
|
if (_dirMonSubdirs != null) {
|
|
_dirMonSubdirs.StopMonitoring();
|
|
_dirMonSubdirs = null;
|
|
}
|
|
|
|
if (_dirMonSpecialDirs != null) {
|
|
foreach (DirectoryMonitor dirMon in _dirMonSpecialDirs) {
|
|
if (dirMon != null) {
|
|
dirMon.StopMonitoring();
|
|
}
|
|
}
|
|
|
|
_dirMonSpecialDirs = null;
|
|
}
|
|
|
|
_callbackRenameOrCriticaldirChange = null;
|
|
|
|
if (_dirs != null) {
|
|
IDictionaryEnumerator e = _dirs.GetEnumerator();
|
|
while (e.MoveNext()) {
|
|
DirectoryMonitor dirMon = (DirectoryMonitor)e.Value;
|
|
dirMon.StopMonitoring();
|
|
}
|
|
}
|
|
|
|
_dirs.Clear();
|
|
_aliases.Clear();
|
|
|
|
// Don't allow the AppDomain to unload while we have
|
|
// active DirMonCompletions
|
|
while (DirMonCompletion.ActiveDirMonCompletions != 0) {
|
|
Thread.Sleep(10);
|
|
}
|
|
}
|
|
|
|
Debug.Dump("FileChangesMonitor", this);
|
|
}
|
|
|
|
#if DBG
|
|
internal string DebugDescription(string indent) {
|
|
StringBuilder sb = new StringBuilder(200);
|
|
string i2 = indent + " ";
|
|
DictionaryEntryCaseInsensitiveComparer decomparer = new DictionaryEntryCaseInsensitiveComparer();
|
|
|
|
sb.Append(indent + "System.Web.FileChangesMonitor\n");
|
|
if (_dirMonSubdirs != null) {
|
|
sb.Append(indent + "_dirMonSubdirs\n");
|
|
sb.Append(_dirMonSubdirs.DebugDescription(i2));
|
|
}
|
|
|
|
if (_dirMonSpecialDirs != null) {
|
|
for (int i=0; i<s_dirsToMonitor.Length; i++) {
|
|
if (_dirMonSpecialDirs[i] != null) {
|
|
sb.Append(indent + "_dirMon" + s_dirsToMonitor[i] + "\n");
|
|
sb.Append(((DirectoryMonitor)_dirMonSpecialDirs[i]).DebugDescription(i2));
|
|
}
|
|
}
|
|
}
|
|
|
|
sb.Append(indent + "_dirs " + _dirs.Count + " directory monitors...\n");
|
|
|
|
DictionaryEntry[] dirEntries = new DictionaryEntry[_dirs.Count];
|
|
_dirs.CopyTo(dirEntries, 0);
|
|
Array.Sort(dirEntries, decomparer);
|
|
|
|
foreach (DictionaryEntry d in dirEntries) {
|
|
DirectoryMonitor dirMon = (DirectoryMonitor)d.Value;
|
|
sb.Append(dirMon.DebugDescription(i2));
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
#endif
|
|
|
|
#else // !FEATURE_PAL stubbing
|
|
|
|
internal static string[] s_dirsToMonitor = new string[] {
|
|
};
|
|
|
|
internal DateTime StartMonitoringFile(string alias, FileChangeEventHandler callback)
|
|
{
|
|
return DateTime.Now;
|
|
}
|
|
|
|
internal DateTime StartMonitoringPath(string alias, FileChangeEventHandler callback)
|
|
{
|
|
return DateTime.Now;
|
|
}
|
|
|
|
internal void StopMonitoringPath(String alias, object target)
|
|
{
|
|
}
|
|
|
|
internal void StartMonitoringDirectoryRenamesAndBinDirectory(string dir, FileChangeEventHandler callback)
|
|
{
|
|
}
|
|
|
|
internal void Stop()
|
|
{
|
|
}
|
|
|
|
#endif // !FEATURE_PAL
|
|
}
|
|
|
|
#if DBG
|
|
internal sealed class DictionaryEntryCaseInsensitiveComparer : IComparer {
|
|
IComparer _cicomparer = StringComparer.OrdinalIgnoreCase;
|
|
|
|
internal DictionaryEntryCaseInsensitiveComparer() {}
|
|
|
|
int IComparer.Compare(object x, object y) {
|
|
string a = (string) ((DictionaryEntry) x).Key;
|
|
string b = (string) ((DictionaryEntry) y).Key;
|
|
|
|
if (a != null && b != null) {
|
|
return _cicomparer.Compare(a, b);
|
|
}
|
|
else {
|
|
return InvariantComparer.Default.Compare(a, b);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if DBG
|
|
internal sealed class DictionaryEntryTypeComparer : IComparer {
|
|
IComparer _cicomparer = StringComparer.OrdinalIgnoreCase;
|
|
|
|
internal DictionaryEntryTypeComparer() {}
|
|
|
|
int IComparer.Compare(object x, object y) {
|
|
object a = ((DictionaryEntry) x).Key;
|
|
object b = ((DictionaryEntry) y).Key;
|
|
|
|
string i = null, j = null;
|
|
if (a != null) {
|
|
i = a.GetType().ToString();
|
|
}
|
|
|
|
if (b != null) {
|
|
j = b.GetType().ToString();
|
|
}
|
|
|
|
if (i != null && j != null) {
|
|
return _cicomparer.Compare(i, j);
|
|
}
|
|
else {
|
|
return InvariantComparer.Default.Compare(i, j);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|