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 Main(string[] args)
{
lock (configLock)
{
if (File.Exists(Constants.ConfigFilePath))
{
try
{
config = JsonConvert.DeserializeObject <Config>(File.ReadAllText(Constants.ConfigFilePath));
// Set up file watcher for config file
var configWatcher = new PollingFileSystemWatcher(Directory.GetParent(Constants.ConfigFilePath).FullName, "config.json");
configWatcher.PollingInterval = 1000;
configWatcher.Changed += UpdateConfig;
configWatcher.Start();
}
catch (Exception ex)
{
Console.WriteLine($"Error reading config file: {ex.Message}");
Console.WriteLine(ex);
}
}
}
SetupPlaybackWatcher();
Task.Delay(Timeout.Infinite).Wait();
}
public static void FileSystemWatcher_MultipleDispose()
{
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose();
watcher.Dispose();
}
private static void MonitorDirectory(string path)
{
PollingFileSystemWatcher fileSystemWatcher = new PollingFileSystemWatcher(path);
fileSystemWatcher.ChangedDetailed += FileSystemWatcher_Changed;
fileSystemWatcher.Start();
}
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 static void FileSystemWatcher_ctor_Null()
{
// Not valid
Assert.Throws <ArgumentNullException>("path", () => new PollingFileSystemWatcher(null));
Assert.Throws <ArgumentNullException>("filter", () => new PollingFileSystemWatcher(Environment.CurrentDirectory, null));
// Valid
var watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory, options: null);
}
public static void FileSystemWatcher_ctor_Defaults()
{
string path = Environment.CurrentDirectory;
var watcher = new PollingFileSystemWatcher(path);
Assert.Equal(path, watcher.Path);
Assert.Equal("*", watcher.Filter);
Assert.NotNull(watcher.EnumerationOptions);
Assert.Equal(1000, watcher.PollingInterval);
}
public void RoundTripAfterDisposedTest()
{
PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory);
watcher.Dispose();
PollingFileSystemWatcher deserialized = RoundTrip(watcher);
Assert.Throws <ObjectDisposedException>(() => deserialized.Start());
}
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_ctor_OptionalParams()
{
string currentDir = Directory.GetCurrentDirectory();
const string filter = "*.csv";
var watcher = new PollingFileSystemWatcher(currentDir, filter, new EnumerationOptions {
RecurseSubdirectories = true
});
Assert.Equal(currentDir, watcher.Path);
Assert.Equal(filter, watcher.Filter);
Assert.True(watcher.EnumerationOptions.RecurseSubdirectories);
}
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);
}
public PlaybackWatcher(Config config)
{
// Get config values
this.playbackTextFilePath = string.IsNullOrWhiteSpace(config?.outputFilePath) ? Constants.PlaybackTextFilePath : config.outputFilePath;
this.formatString = config?.formatString;
this.updateOnTimeChange = config?.updateOnTimeChange ?? false;
int playbackPollingInterval = config?.updateInterval ?? 5;
// Set up file watcher for gpmdp playback
playbackWatcher = new PollingFileSystemWatcher(Directory.GetParent(Constants.PlaybackFilePath).FullName, "playback.json");
playbackWatcher.PollingInterval = playbackPollingInterval * 1000;
playbackWatcher.Changed += WriteTextFile;
}
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 InitializeRecordsFileSystemWatcher()
{
Logger.Info("Initializing records PollingFileSystemWatcher...");
Watcher = new PollingFileSystemWatcher(WexflowEngine.RecordsHotFolder, "*");
// Add event handlers.
Watcher.ChangedDetailed += OnRecordChanged;
// Begin watching.
Watcher.Start();
Logger.InfoFormat("Record.PollingFileSystemWatcher.Path={0}", Watcher.Path);
Logger.InfoFormat("Record.PollingFileSystemWatcher.Filter={0}", Watcher.Filter);
Logger.Info("Records PollingFileSystemWatcher Initialized.");
}
public static void InitializePollingFileSystemWatcher()
{
Logger.Info("Initializing PollingFileSystemWatcher...");
Watcher = new PollingFileSystemWatcher(WexflowEngine.WorkflowsFolder, "*.xml");
// Add event handlers.
Watcher.ChangedDetailed += OnChanged;
// Begin watching.
Watcher.Start();
Logger.InfoFormat("PollingFileSystemWatcher.Path={0}", Watcher.Path);
Logger.InfoFormat("PollingFileSystemWatcher.Filter={0}", Watcher.Filter);
Logger.Info("PollingFileSystemWatcher Initialized.");
}
public static void FileSystemWatcher_Recursive()
{
string currentDir = Utility.GetRandomDirectory();
string fileName = Path.GetRandomFileName();
string subDirectory = new DirectoryInfo(currentDir).CreateSubdirectory("sub").FullName;
string fullName = Path.Combine(subDirectory, fileName);
bool eventRaised = false;
using (PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(currentDir, options: new EnumerationOptions {
RecurseSubdirectories = true
})
{
PollingInterval = 1
})
{
AutoResetEvent signal = new AutoResetEvent(false);
watcher.Error += (e, error) =>
{
throw error.GetException();
};
watcher.ChangedDetailed += (e, changes) =>
{
Assert.Equal(1, changes.Changes.Length);
FileChange change = changes.Changes[0];
Assert.Equal(WatcherChangeTypes.Created, change.ChangeType);
Assert.Equal(fileName, change.Name);
Assert.Equal(subDirectory, change.Directory);
eventRaised = true;
watcher.PollingInterval = Timeout.Infinite;
signal.Set();
};
watcher.Start();
using (FileStream file = File.Create(fullName)) { }
signal.WaitOne(10000);
}
try
{
Assert.True(eventRaised);
}
finally
{
Directory.Delete(currentDir, true);
}
}
public void RoundTripReturnSeparateObjectTest()
{
PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(Environment.CurrentDirectory)
{
PollingInterval = Timeout.Infinite
};
PollingFileSystemWatcher deserialized = RoundTrip(watcher);
watcher.PollingInterval = 0;
Assert.False(ReferenceEquals(watcher, deserialized));
Assert.Equal(Timeout.Infinite, deserialized.PollingInterval);
}
private static PollingFileSystemWatcher RoundTrip(PollingFileSystemWatcher watcher)
{
PollingFileSystemWatcher deserialized;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, watcher);
stream.Position = 0;
deserialized = (PollingFileSystemWatcher)formatter.Deserialize(stream);
}
return(deserialized);
}
public void RoundTripPropertyTest()
{
string path = Environment.CurrentDirectory;
string filter = "*.abc";
EnumerationOptions options = new EnumerationOptions {
RecurseSubdirectories = true
};
PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(path, filter, options)
{
PollingInterval = Timeout.Infinite
};
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);
}
public static void FileSystemWatcher_Filter()
{
string currentDir = Utility.GetRandomDirectory();
string fileName = $"{Path.GetRandomFileName()}.csv";
string fullName = Path.Combine(currentDir, fileName);
bool eventRaised = false;
using (PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(currentDir, filter: "*.csv")
{
PollingInterval = 1
})
{
AutoResetEvent signal = new AutoResetEvent(false);
watcher.ChangedDetailed += (e, changes) =>
{
Assert.Equal(1, changes.Changes.Length);
FileChange change = changes.Changes[0];
Assert.Equal(WatcherChangeTypes.Created, change.ChangeType);
Assert.Equal(fileName, change.Name);
Assert.Equal(currentDir, change.Directory);
eventRaised = true;
watcher.PollingInterval = Timeout.Infinite;
signal.Set();
};
watcher.Start();
using (FileStream file = File.Create(fullName)) { }
signal.WaitOne(1000);
}
try
{
Assert.True(eventRaised);
}
finally
{
Directory.Delete(currentDir, true);
}
}
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 static void FileSystemWatcher_PollingInterval_ChangeAfterStart()
{
string currentDir = Utility.GetRandomDirectory();
string fileName = Path.GetRandomFileName();
string fullName = Path.Combine(currentDir, fileName);
bool eventRaised = false;
using (PollingFileSystemWatcher watcher = new PollingFileSystemWatcher(currentDir)
{
PollingInterval = Timeout.Infinite
})
{
AutoResetEvent signal = new AutoResetEvent(false);
watcher.Changed += (e, changes) =>
{
eventRaised = true;
watcher.PollingInterval = Timeout.Infinite;
signal.Set();
};
watcher.Start();
using (FileStream file = File.Create(fullName)) { }
watcher.PollingInterval = 0;
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));
}
