public static void FileSystemWatcher_MultipleDispose()
{
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose();
watcher.Dispose();
}
public override TaskStatus Run()
{
InfoFormat("Watching the folder {0} ...", FolderToWatch);
try
{
if (!Directory.Exists(FolderToWatch))
{
ErrorFormat("The folder {0} does not exist.", FolderToWatch);
return(new TaskStatus(Status.Error));
}
Info("Initializing PollingFileSystemWatcher...");
Watcher = new PollingFileSystemWatcher(FolderToWatch, Filter, new EnumerationOptions {
RecurseSubdirectories = IncludeSubFolders
});
// Add event handlers.
Watcher.ChangedDetailed += OnChanged;
// Begin watching.
Watcher.Start();
InfoFormat("PollingFileSystemWatcher.Path={0}", Watcher.Path);
InfoFormat("PollingFileSystemWatcher.Filter={0}", Watcher.Filter);
Info("PollingFileSystemWatcher Initialized.");
Info("Begin watching ...");
CurrentLogs.AddRange(Logs);
while (!IsStopped)
{
Thread.Sleep(1);
}
Watcher.Dispose();
}
catch (ThreadAbortException)
{
if (Watcher != null)
{
Watcher.Dispose();
}
throw;
}
catch (Exception e)
{
if (Watcher != null)
{
Watcher.Dispose();
}
ErrorFormat("An error occured while watching the folder {0}. Error: {1}", FolderToWatch, e.Message);
return(new TaskStatus(Status.Error, false));
}
Info("Task finished");
return(new TaskStatus(Status.Success));
}
public static void FileSystemWatcher_MultipleDisposeWithWaitHandle()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
var isSuccessful = watcher.Dispose(resetEvent);
Assert.True(isSuccessful);
resetEvent.Reset();
isSuccessful = watcher.Dispose(resetEvent);
Assert.False(isSuccessful);
}
public static void FileSystemWatcher_DisposeAfterStart()
{
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Start();
watcher.Dispose();
}
public static void FileSystemWatcher_DisposeBeforeStart()
{
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose();
Assert.Throws <ObjectDisposedException>(() => watcher.Start());
}
public static void FileSystemWatcher_Changed_File()
{
var currentDir = Directory.GetCurrentDirectory();
string fileName = Guid.NewGuid().ToString();
var watcher = new PollingFileSystemWatcher(currentDir)
{
PollingIntervalInMilliseconds = 100
};
using (var file = new TemporaryTestFile(fileName))
{
watcher.Start();
Thread.Sleep(200);
watcher.ChangedDetailed += (e, changes) =>
{
Assert.Equal(1, changes.Changes.Length);
var change = changes.Changes[0];
Assert.Equal(ChangeType.Changed, change.ChangeType);
Assert.Equal(fileName, change.Name);
Assert.Equal(currentDir, change.Directory);
};
Thread.Sleep(200);
file.WriteByte(100);
Thread.Sleep(200);
watcher.Dispose();
Thread.Sleep(200);
}
}
public static void FileSystemWatcher_DisposeBeforeStartWithWaitHandle()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose(resetEvent);
Assert.Throws <ObjectDisposedException>(() => watcher.Start());
}
public void RoundTripAfterDisposedTest()
{
PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose();
PollingFileSystemWatcher deserialized = RoundTrip(watcher);
Assert.Throws <ObjectDisposedException>(() => deserialized.Start());
}
public static void FileSystemWatcher_DisposeAfterStartWithWaitHandle()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory)
{
PollingInterval = 1
};
watcher.Start();
var isSuccessful = watcher.Dispose(resetEvent);
Assert.True(isSuccessful);
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
lock (playbackLock)
{
playbackWatcher.Dispose();
}
}
disposedValue = true;
}
}
public void RoundTripReturnSeparateObjectTest()
{
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory)
{
PollingInterval = Timeout.Infinite
};
using (PollingFileSystemWatcher deserialized = RoundTrip(watcher))
{
watcher.PollingInterval = 0;
Assert.False(ReferenceEquals(watcher, deserialized));
Assert.Equal(Timeout.Infinite, deserialized.PollingInterval);
}
watcher.Dispose();
}
public void RoundTripPropertyTest()
{
string path = Environment.CurrentDirectory;
string filter = "*.abc";
EnumerationOptions options = new EnumerationOptions {
RecurseSubdirectories = true
};
var watcher = new PollingFileSystemWatcher(path, filter, options)
{
PollingInterval = Timeout.Infinite
};
using (PollingFileSystemWatcher deserialized = RoundTrip(watcher))
{
Assert.Equal(path, deserialized.Path);
Assert.Equal(filter, deserialized.Filter);
Assert.Equal(Timeout.Infinite, deserialized.PollingInterval);
Assert.Equal(options.RecurseSubdirectories, deserialized.EnumerationOptions.RecurseSubdirectories);
}
watcher.Dispose();
}
public void RoundTripAfterStartedTest()
{
string currentDir = Utility.GetRandomDirectory();
string fileName = Path.GetRandomFileName();
string fullName = Path.Combine(currentDir, fileName);
bool eventRaised = false;
AutoResetEvent signal = new AutoResetEvent(false);
PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(currentDir)
{
PollingInterval = 0
};
watcher.Start();
using (PollingFileSystemWatcher deserialized = RoundTrip(watcher))
{
watcher.Dispose();
deserialized.Changed += (e, args) =>
{
eventRaised = true;
watcher.PollingInterval = Timeout.Infinite;
signal.Set();
};
using (var file = File.Create(fullName)) { }
signal.WaitOne(1000);
}
try
{
Assert.True(eventRaised);
}
finally
{
Directory.Delete(currentDir, true);
}
}
public override TaskStatus Run()
{
InfoFormat("Watching the folder {0} ...", FolderToWatch);
try
{
if (!Directory.Exists(FolderToWatch))
{
ErrorFormat("The folder {0} does not exist.", FolderToWatch);
return(new TaskStatus(Status.Error));
}
Info("Checking existing files...");
var files = GetFiles();
foreach (var file in files)
{
InfoFormat("FileSystemWatcher.OnFound started for {0}", file);
try
{
if (ContinueDoTasksOnlyOnNotOpenFiles && FileChange.IsFileLocked(file))
{
continue;
}
ClearFiles();
Files.Add(new FileInf(file, Id));
var tasks = GetTasks(OnFileFound);
foreach (var task in tasks)
{
task.Logs.Clear();
task.Run();
CurrentLogs.AddRange(task.Logs);
}
Files.RemoveAll(f => f.Path == file);
}
catch (IOException ex) when((ex.HResult & 0x0000FFFF) == 32)
{
Logger.InfoFormat("There is a sharing violation for the file {0}.", file);
}
catch (Exception ex)
{
ErrorFormat("An error while triggering FileSystemWatcher.OnFound on the file {0}. Message: {1}", file, ex.Message);
}
finally
{
Info("FileSystemWatcher.OnFound finished.");
}
try
{
var entry = Workflow.Database.GetEntry(Workflow.Id, Workflow.InstanceId);
entry.Logs = string.Join("\r\n", CurrentLogs);
Workflow.Database.UpdateEntry(entry.GetDbId(), entry);
}
catch (Exception ex)
{
ErrorFormat("An error while updating FileSystemWatcher.OnCreated database entry.", ex);
}
}
Info("Checking existing files finished.");
Info("Initializing PollingFileSystemWatcher...");
Watcher = new PollingFileSystemWatcher(FolderToWatch, Filter, new EnumerationOptions {
RecurseSubdirectories = IncludeSubFolders
});
// Add event handlers.
Watcher.ChangedDetailed += OnChanged;
// Begin watching.
Watcher.Start();
InfoFormat("PollingFileSystemWatcher.Path={0}", Watcher.Path);
InfoFormat("PollingFileSystemWatcher.Filter={0}", Watcher.Filter);
Info("PollingFileSystemWatcher Initialized.");
Info("Begin watching ...");
CurrentLogs.AddRange(Logs);
while (!IsStopped)
{
Thread.Sleep(1);
}
Watcher.Dispose();
}
catch (ThreadAbortException)
{
if (Watcher != null)
{
Watcher.Dispose();
}
throw;
}
catch (Exception e)
{
if (Watcher != null)
{
Watcher.Dispose();
}
ErrorFormat("An error occured while watching the folder {0}. Error: {1}", FolderToWatch, e.Message);
return(new TaskStatus(Status.Error, false));
}
Info("Task finished");
return(new TaskStatus(Status.Success));
}
