public void TestFileChanges()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
monitor.ScanInterval = 1;
monitor.AddDirectory(testFolder);
monitor.UpdateArchives();
AutoResetEvent are = new AutoResetEvent(false);
var expectedEventType = FileEventType.FileAdded;
var expectedFileName = Path.GetFullPath(Path.Combine(testFolder, "new.txt"));
monitor.FileChanged += (o, e) => {
if (e.EventType == expectedEventType && e.FilePath == expectedFileName)
{
are.Set();
}
};
monitor.StartMonitoring();
File.Create(expectedFileName).Close();
Assert.IsTrue(are.WaitOne(WaitInterval));
expectedEventType = FileEventType.FileChanged;
var expectedLastWriteTime = DateTime.Now;
File.SetLastWriteTime(expectedFileName, expectedLastWriteTime);
Assert.IsTrue(are.WaitOne(WaitInterval));
Assert.AreEqual(expectedLastWriteTime, archive.GetLastModifiedTime(expectedFileName));
expectedEventType = FileEventType.FileDeleted;
File.Delete(expectedFileName);
Assert.IsTrue(are.WaitOne(WaitInterval));
}
public void TestStartup()
{
AutoResetEvent are = new AutoResetEvent(false);
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
monitor.DirectoryAdded += (o, e) => { are.Set(); };
monitor.AddDirectory(testFolder);
Assert.IsTrue(are.WaitOne(WaitInterval));
int count = 0;
monitor.FileChanged += (o, e) => {
if (e.EventType == FileEventType.FileAdded)
{
count++;
if (count == numStartingFiles)
{
are.Set();
}
}
};
monitor.UpdateArchives();
Assert.IsTrue(are.WaitOne(WaitInterval));
Assert.AreEqual(numStartingFiles, archive.GetFiles().Count(), String.Format("only found {0} files in the archive", archive.GetFiles().Count()));
foreach (var fileName in Directory.EnumerateFiles(testFolder))
{
Assert.IsTrue(archive.ContainsFile(fileName));
Assert.IsFalse(archive.IsOutdated(fileName));
Assert.AreEqual(File.GetLastWriteTime(fileName), archive.GetLastModifiedTime(fileName));
}
}
public void TestRename() {
bool receivedFileAdd = false, receivedFileRename = false;
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
archive.FileChanged += (sender, e) => {
switch(e.EventType) {
case FileEventType.FileAdded:
receivedFileAdd = true;
break;
case FileEventType.FileRenamed:
receivedFileRename = true;
break;
}
};
string pathToFoo = Path.Combine(testDirectory, "foo.txt");
string pathToBar = Path.Combine(testDirectory, "bar.txt");
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
Assert.That(archive.ContainsFile(pathToFoo));
Assert.That(receivedFileAdd);
File.Move(pathToFoo, pathToBar);
Assert.That(archive.IsOutdated(pathToFoo));
archive.RenameFile(pathToFoo, pathToBar);
Assert.That(receivedFileRename);
Assert.That(archive.ContainsFile(pathToBar));
Assert.IsFalse(archive.ContainsFile(pathToFoo));
}
public void TestRename()
{
bool receivedFileAdd = false, receivedFileRename = false;
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
archive.FileChanged += (sender, e) => {
switch (e.EventType)
{
case FileEventType.FileAdded:
receivedFileAdd = true;
break;
case FileEventType.FileRenamed:
receivedFileRename = true;
break;
}
};
string pathToFoo = Path.Combine(testDirectory, "foo.txt");
string pathToBar = Path.Combine(testDirectory, "bar.txt");
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
Assert.That(archive.ContainsFile(pathToFoo));
Assert.That(receivedFileAdd);
File.Move(pathToFoo, pathToBar);
Assert.That(archive.IsOutdated(pathToFoo));
archive.RenameFile(pathToFoo, pathToBar);
Assert.That(receivedFileRename);
Assert.That(archive.ContainsFile(pathToBar));
Assert.IsFalse(archive.ContainsFile(pathToFoo));
}
/// <summary>
/// SrcML service starts to monitor the opened solution.
/// </summary>
/// <param name="srcMLArchiveDirectory"></param>
/// <param name="shouldReset"></param>
public void StartMonitoring(bool shouldReset, string srcMLBinaryDirectory)
{
// Get the path of the folder that storing the srcML archives
var openSolution = GetOpenSolution();
string baseDirectory = GetSrcMLArchiveFolder(openSolution);
SrcMLFileLogger.DefaultLogger.Info("SrcMLGlobalService.StartMonitoring( " + baseDirectory + " )");
try {
if (shouldReset)
{
SrcMLFileLogger.DefaultLogger.Info("Reset flag is set - Removing " + baseDirectory);
Directory.Delete(baseDirectory, true);
}
// Create a new instance of SrcML.NET's LastModifiedArchive
LastModifiedArchive lastModifiedArchive = new LastModifiedArchive(baseDirectory, LastModifiedArchive.DEFAULT_FILENAME,
_taskManager.GlobalScheduler);
// Create a new instance of SrcML.NET's SrcMLArchive
SrcMLArchive sourceArchive = new SrcMLArchive(baseDirectory, SrcMLArchive.DEFAULT_ARCHIVE_DIRECTORY, true,
new SrcMLGenerator(srcMLBinaryDirectory),
new ShortXmlFileNameMapping(Path.Combine(baseDirectory, SrcMLArchive.DEFAULT_ARCHIVE_DIRECTORY)),
_taskManager.GlobalScheduler);
CurrentSrcMLArchive = sourceArchive;
// Create a new instance of SrcML.NET's solution monitor
if (openSolution != null)
{
CurrentMonitor = new SourceMonitor(openSolution, DirectoryScanningMonitor.DEFAULT_SCAN_INTERVAL,
_taskManager.GlobalScheduler, baseDirectory, lastModifiedArchive, sourceArchive);
CurrentMonitor.DirectoryAdded += RespondToDirectoryAddedEvent;
CurrentMonitor.DirectoryRemoved += RespondToDirectoryRemovedEvent;
CurrentMonitor.UpdateArchivesStarted += CurrentMonitor_UpdateArchivesStarted;
CurrentMonitor.UpdateArchivesCompleted += CurrentMonitor_UpdateArchivesCompleted;
CurrentMonitor.AddDirectoriesFromSaveFile();
CurrentMonitor.AddSolutionDirectory();
}
// Subscribe events from Solution Monitor
if (CurrentMonitor != null)
{
CurrentMonitor.FileChanged += RespondToFileChangedEvent;
// Initialize the progress bar.
if (statusBar != null)
{
statusBar.Progress(ref cookie, 1, "", 0, 0);
}
// Start monitoring
var updateTask = CurrentMonitor.UpdateArchivesAsync();
CurrentMonitor.StartMonitoring();
OnMonitoringStarted(new EventArgs());
SaveTimer.Start();
}
} catch (Exception e) {
SrcMLFileLogger.DefaultLogger.Error(SrcMLExceptionFormatter.CreateMessage(e, "Exception in SrcMLGlobalService.StartMonitoring()"));
}
}
public void TestForbiddenDirectory()
{
var forbiddenDirectory = Environment.GetEnvironmentVariable("USERPROFILE");
var archive = new LastModifiedArchive(monitorFolder);
var monitor = new DirectoryScanningMonitor(monitorFolder, archive);
monitor.AddDirectory(forbiddenDirectory);
}
public void TestRelativePathInsertWithFullPathCheck()
{
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
string relativePathToFoo = Path.Combine(testDirectory, "foo.txt");
string fullPathToFoo = Path.GetFullPath(relativePathToFoo);
File.Create(relativePathToFoo).Dispose();
archive.AddOrUpdateFile(relativePathToFoo);
Assert.That(archive.ContainsFile(fullPathToFoo));
}
public void TestIsEmpty()
{
var archive = new LastModifiedArchive(testDirectory, "archive.txt");
Assert.That(archive.IsEmpty);
string pathToFoo = Path.GetFullPath(Path.Combine(testDirectory, "foo.txt"));
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
Assert.That(archive.IsEmpty, Is.False);
}
public void TestAddSimilarDirectory()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
AutoResetEvent are = new AutoResetEvent(false);
monitor.DirectoryAdded += (o, e) => are.Set();
monitor.AddDirectory(testFolder);
Assert.IsTrue(are.WaitOne(WaitInterval));
monitor.AddDirectory(testFolder + "NotSubDirectory");
Assert.IsTrue(are.WaitOne(WaitInterval));
}
public void TestIsMonitoringFile()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
monitor.AddDirectory(testFolder);
foreach (var fileName in Directory.EnumerateFiles(testFolder))
{
Assert.IsTrue(monitor.IsMonitoringFile(fileName), "should be able to use the file name with the relative path");
Assert.IsTrue(monitor.IsMonitoringFile(Path.GetFullPath(fileName)), "should be able to find the file name with the absolute path");
}
}
public void TestAddSubdirectory()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
AutoResetEvent are = new AutoResetEvent(false);
monitor.DirectoryAdded += (o, e) => are.Set();
monitor.AddDirectory(testFolder);
Assert.IsTrue(are.WaitOne(WaitInterval));
monitor.AddDirectory(Path.Combine(testFolder, "test"));
//Assert.IsFalse(are.WaitOne(WaitInterval));
}
public void TestAddDuplicateDirectory()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
AutoResetEvent are = new AutoResetEvent(false);
monitor.DirectoryAdded += (o, e) => { are.Set(); };
monitor.AddDirectory(testFolder);
Assert.IsTrue(are.WaitOne(WaitInterval));
monitor.AddDirectory(testFolder);
Assert.IsFalse(are.WaitOne(WaitInterval));
Assert.AreEqual(1, monitor.MonitoredDirectories.Count);
}
public void TestArchiveLoadRoundTrip()
{
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
var archivePath = archive.ArchivePath;
string pathToFoo = Path.GetFullPath(Path.Combine(testDirectory, "foo.txt"));
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
archive.Dispose();
Assert.That(File.Exists(archivePath));
archive = new LastModifiedArchive(testDirectory);
Assert.That(archive.ContainsFile(pathToFoo));
}
public void TestAddUpdateDelete()
{
bool receivedFileAdded = false, receivedFileUpdated = false, receivedFileDeleted = false;
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
archive.FileChanged += (sender, e) => {
switch (e.EventType)
{
case FileEventType.FileAdded:
receivedFileAdded = true;
break;
case FileEventType.FileChanged:
receivedFileUpdated = true;
break;
case FileEventType.FileDeleted:
receivedFileDeleted = true;
break;
}
};
string fileFoo = Path.Combine(testDirectory, "foo.txt");
File.Create(fileFoo).Dispose();
archive.AddOrUpdateFile(fileFoo);
Assert.That(receivedFileAdded);
Assert.That(archive.ContainsFile(fileFoo));
Assert.IsFalse(archive.IsOutdated(fileFoo));
System.Threading.Thread.Sleep(5000);
File.AppendAllText(fileFoo, "This is bar!\n");
Assert.That(archive.IsOutdated(fileFoo));
archive.AddOrUpdateFile(fileFoo);
Assert.That(receivedFileUpdated);
File.Delete(fileFoo);
Assert.That(archive.IsOutdated(fileFoo));
archive.DeleteFile(fileFoo);
Assert.That(receivedFileDeleted);
Assert.IsFalse(archive.ContainsFile(fileFoo));
}
public void TestRemoveDirectory()
{
var archive = new LastModifiedArchive(monitorFolder);
DirectoryScanningMonitor monitor = new DirectoryScanningMonitor(monitorFolder, archive);
AutoResetEvent directoryResetEvent = new AutoResetEvent(false);
monitor.DirectoryAdded += (o, e) => directoryResetEvent.Set();
monitor.DirectoryRemoved += (o, e) => directoryResetEvent.Set();
monitor.AddDirectory(testFolder);
Assert.IsTrue(directoryResetEvent.WaitOne(WaitInterval));
monitor.UpdateArchives();
Assert.AreEqual(numStartingFiles, monitor.GetArchivedFiles().Count());
monitor.RemoveDirectory("test1");
Assert.IsFalse(directoryResetEvent.WaitOne(WaitInterval));
Assert.AreEqual(numStartingFiles, monitor.GetArchivedFiles().Count());
AutoResetEvent fileDeletionResetEvent = new AutoResetEvent(false);
int count = numStartingFiles;
monitor.FileChanged += (o, e) => {
if (e.EventType == FileEventType.FileDeleted)
{
if (--count == 0)
{
fileDeletionResetEvent.Set();
}
}
};
monitor.RemoveDirectory(testFolder);
Assert.IsTrue(directoryResetEvent.WaitOne(WaitInterval));
Assert.IsTrue(fileDeletionResetEvent.WaitOne(WaitInterval));
Assert.AreEqual(0, monitor.GetArchivedFiles().Count());
foreach (var fileName in Directory.EnumerateFiles(testFolder))
{
Assert.IsTrue(File.Exists(fileName));
}
}
public void TestExcludedFiles()
{
var testDirectoryPath = Path.Combine(testFolder, "TestExcludedFiles");
var exludedFiles = new string[] {
Path.Combine(testDirectoryPath, ".test.txt"),
Path.Combine(testDirectoryPath, "#test.txt"),
Path.Combine(testDirectoryPath, "~autorecover.test.txt"),
Path.Combine(testDirectoryPath, "~test.txt"),
};
Directory.CreateDirectory(testDirectoryPath);
foreach (var filePath in exludedFiles)
{
File.Create(filePath).Close();
}
var archive = new LastModifiedArchive(monitorFolder);
using (var monitor = new DirectoryScanningMonitor(monitorFolder, archive)) {
monitor.AddDirectory(testDirectoryPath);
Assert.AreEqual(0, monitor.GetFilesFromSource().Count);
}
}
public void TestAddUpdateDelete() {
bool receivedFileAdded = false, receivedFileUpdated = false, receivedFileDeleted = false;
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
archive.FileChanged += (sender, e) => {
switch(e.EventType) {
case FileEventType.FileAdded:
receivedFileAdded = true;
break;
case FileEventType.FileChanged:
receivedFileUpdated = true;
break;
case FileEventType.FileDeleted:
receivedFileDeleted = true;
break;
}
};
string fileFoo = Path.Combine(testDirectory, "foo.txt");
File.Create(fileFoo).Dispose();
archive.AddOrUpdateFile(fileFoo);
Assert.That(receivedFileAdded);
Assert.That(archive.ContainsFile(fileFoo));
Assert.IsFalse(archive.IsOutdated(fileFoo));
System.Threading.Thread.Sleep(5000);
File.AppendAllText(fileFoo, "This is bar!\n");
Assert.That(archive.IsOutdated(fileFoo));
archive.AddOrUpdateFile(fileFoo);
Assert.That(receivedFileUpdated);
File.Delete(fileFoo);
Assert.That(archive.IsOutdated(fileFoo));
archive.DeleteFile(fileFoo);
Assert.That(receivedFileDeleted);
Assert.IsFalse(archive.ContainsFile(fileFoo));
}
public void TestExcludedDirectory()
{
var testExcludedDirectoryPath = Path.Combine(testFolder, "TestExcludedDirectory");
var excludedFolders = new string[] {
Path.Combine(testExcludedDirectoryPath, "TestResults"),
Path.Combine(testExcludedDirectoryPath, "Backup"),
Path.Combine(testExcludedDirectoryPath, "Backup1"),
Path.Combine(testExcludedDirectoryPath, "backup111"),
Path.Combine(testExcludedDirectoryPath, ".test")
};
foreach (var folder in excludedFolders)
{
Directory.CreateDirectory(folder);
File.Create(Path.Combine(folder, "test.txt")).Close();
}
var archive = new LastModifiedArchive(monitorFolder);
using (var monitor = new DirectoryScanningMonitor(monitorFolder, archive)) {
monitor.AddDirectory(testExcludedDirectoryPath);
Assert.AreEqual(0, monitor.GetFilesFromSource().Count);
}
}
public void TestRelativePathInsertWithFullPathCheck() {
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
string relativePathToFoo = Path.Combine(testDirectory, "foo.txt");
string fullPathToFoo = Path.GetFullPath(relativePathToFoo);
File.Create(relativePathToFoo).Dispose();
archive.AddOrUpdateFile(relativePathToFoo);
Assert.That(archive.ContainsFile(fullPathToFoo));
}
public void TestOutdatedWithNonExistentFiles() {
var archive = new LastModifiedArchive(testDirectory, "archive.txt");
Assert.IsFalse(archive.IsOutdated("foo.txt"));
}
public void TestIsEmpty() {
var archive = new LastModifiedArchive(testDirectory, "archive.txt");
Assert.That(archive.IsEmpty);
string pathToFoo = Path.GetFullPath(Path.Combine(testDirectory, "foo.txt"));
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
Assert.That(archive.IsEmpty, Is.False);
}
public void TestOutdatedWithNonExistentFiles()
{
var archive = new LastModifiedArchive(testDirectory, "archive.txt");
Assert.IsFalse(archive.IsOutdated("foo.txt"));
}
public void TestArchiveLoadRoundTrip() {
LastModifiedArchive archive = new LastModifiedArchive(testDirectory);
var archivePath = archive.ArchivePath;
string pathToFoo = Path.GetFullPath(Path.Combine(testDirectory, "foo.txt"));
File.Create(pathToFoo).Dispose();
archive.AddOrUpdateFile(pathToFoo);
archive.Dispose();
Assert.That(File.Exists(archivePath));
archive = new LastModifiedArchive(testDirectory);
Assert.That(archive.ContainsFile(pathToFoo));
}
