public void GivenFolder_WhenFolderEmpty_ThenFolderScanned()
{
// Arrange
var directory = Directory.CreateDirectory(Guid.NewGuid().ToString());
var context = DbContextFactory.CreateImMemory();
var monitor = new FolderMonitor(context, scanFrequencySeconds: 20);
// Act
var recorded = Record.Exception(
() => Assert.Raises <ResourceAddedEventArgs>(
handler => monitor.ResourceAdded += handler,
handler => monitor.ResourceAdded -= handler,
() =>
{
using (monitor)
{
monitor.StartMonitoring(new[] { directory.FullName });
Thread.Sleep((int)TimeSpan.FromSeconds(5).TotalMilliseconds);
}
}));
// Assert
Assert.IsType <RaisesException>(recorded);
Assert.Empty(context.Resources);
directory.Delete();
}
public void GivenResource_WhenFileRemoved_ThenResourceDeleted()
{
// Arrange
var directory = Directory.CreateDirectory(Guid.NewGuid().ToString());
var resource = new Resource
{
Name = Guid.NewGuid().ToString(),
Path = directory.FullName,
Hash = Guid.NewGuid().ToString(),
Size = 200
};
var context = DbContextFactory.CreateImMemory();
context.Resources.Add(resource);
context.SaveChanges();
// Act
using (var monitor = new FolderMonitor(context, scanFrequencySeconds: 20))
{
monitor.StartMonitoring(
new[] { directory.FullName });
Thread.Sleep((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
}
// Assert
Assert.Empty(context.Resources);
directory.Delete();
}
static void Main(string[] args)
{
FolderMonitor dev1 = new FolderMonitor(@"D:\\Lesha\\c#");
dev1._isMonitoring = true;
dev1.Monitoring();
Console.ReadLine();
}
public void GivenTrackedFile_WhenFileChanged_ThenFileUpdated()
{
// Arrange
var directory = Directory.CreateDirectory(Guid.NewGuid().ToString());
var fileName = Guid.NewGuid().ToString();
using (var writer = File.CreateText(Path.Combine(directory.FullName, fileName)))
{
writer.WriteLine("Hello world!");
}
var resource = new Resource
{
Name = fileName,
Path = directory.FullName,
Hash = Guid.NewGuid().ToString(),
Size = 0
};
var context = DbContextFactory.CreateImMemory();
context.Resources.Add(resource);
context.SaveChanges();
// Act
var monitor = new FolderMonitor(context, scanFrequencySeconds: 20);
var raised = Assert.Raises <ResourceChangedEventArgs>(
handler => monitor.ResourceChanged += handler,
handler => monitor.ResourceChanged -= handler,
() =>
{
using (monitor)
{
monitor.StartMonitoring(
new[] { directory.FullName });
Thread.Sleep((int)TimeSpan.FromSeconds(5).TotalMilliseconds);
}
});
// Assert
Assert.NotNull(raised);
Assert.Equal(monitor, raised.Sender);
var fileInfo = new FileInfo(Path.Combine(directory.FullName, fileName));
AssertEventArgs(fileInfo, raised.Arguments);
resource = context.Resources.FirstOrDefault(r => r.Name == fileInfo.Name);
Assert.NotNull(resource);
AssertResource(fileInfo, resource);
fileInfo.Delete();
directory.Delete();
}
public void Add(object referenceObject, string path,
Delegates.FileChangedHandlerDelegate fileChanged,
Delegates.FileCreatedHandlerDelegate fileCreated,
Delegates.FileDeletedHandlerDelegate fileDeleted,
Delegates.FileRenamedHandlerDelegate fileRenamed)
{
string folder = GetFolder(path);
FolderMonitor folderMonitor = null;
if (_FolderMonitors.ContainsKey(folder))
{
if (!_FolderMonitors[folder].ReferencedObjects.Exists(x => x.Equals(referenceObject)))
{
folderMonitor = _FolderMonitors[folder];
}
else
{
return;
}
}
else
{
folderMonitor = new FolderMonitor(folder);
if (!_FolderMonitors.TryAdd(folder, folderMonitor))
{
throw new Exception(string.Format("failed to add folder '{0}' monitor.", folder));
}
}
folderMonitor.ReferencedObjects = folderMonitor.ReferencedObjects.Append(referenceObject);
if (fileChanged != null)
{
folderMonitor.FileChanged += fileChanged;
}
if (fileCreated != null)
{
folderMonitor.FileCreated += fileCreated;
}
if (fileDeleted != null)
{
folderMonitor.FileDeleted += fileDeleted;
}
if (fileRenamed != null)
{
folderMonitor.FileRenamed += fileRenamed;
}
folderMonitor.Start();
}
public void MOQ_Watcher_Filter_IgnoresTxt()
{
Mock <IStorageProvider> mockStorageProvider = new Mock <IStorageProvider>();
FolderMonitor folderMonitor = new FolderMonitor(filePath, mockStorageProvider.Object);
folderMonitor.Observe();
createTestFile(".txt");
deleteTestFile(".txt");
mockStorageProvider.Verify(t => t.CreateBlob(It.IsAny <string>(), It.IsAny <string>()), Times.Never());
//Assert.IsFalse(folderMonitor.Running);
}
private static IServiceProvider ConfigureServices(ServiceConfig config)
{
ConfigureLogging(config.LogFilePath);
var services = new ServiceCollection();
services.AddSingleton(config);
services.AddDbContext <IScanServiceContext, ScanServiceContext>(
ConfigureDbContext);
services.AddTransient <IResourceMonitor, FolderMonitor>(
provider =>
{
var monitor = new FolderMonitor(provider.GetService <IScanServiceContext>(), config.FolderScanFrequencySeconds);
var handlers = provider.GetServices <IResourceMonitorEventHandler>();
foreach (var handler in handlers)
{
monitor.ResourceAdded += handler.ResourceAddedEventHandler;
monitor.ResourceChanged += handler.ResourceChangedEventHandler;
}
return(monitor);
});
services.AddTransient <IResourceMonitorEventHandler, ResourceStreamingHandler>(
provider => new ResourceStreamingHandler(
new MessageSequenceBuilder(),
new ServiceBusQueueMessageSender(config.DataQueueConnectionString, config.DataQueueName),
() => config.MessageMaxSizeBytes));
services.AddTransient <IAvailabilityCheck>(
provider => new AvailabilityCheck(
new ServiceBusQueueMessageSender(
config.MonitoringQueueConnectionString,
config.MonitoringQueueName),
new ScanServiceContext(GetDbContextOptions()),
config.ClientId,
config.AvailabilityCheckFrequencySeconds));
services.AddTransient <IMessageReceiver>(
provider => new ServiceBusSubscriptionMessageReceiver(
config.ConfigTopicConnectionString,
config.ConfigTopicName,
config.ConfigTopicSubscriptionName));
services.AddTransient <IExternalConfigurationProvider, ExternalConfigurationProvider>();
return(services.BuildServiceProvider());
}
public void MOQ_Watcher_Filter_FindsPDF()
{
Mock <IStorageProvider> mockStorageProvider = new Mock <IStorageProvider>();
FolderMonitor folderMonitor = new FolderMonitor(filePath, mockStorageProvider.Object);
folderMonitor.Observe();
createTestFile(".pdf");
deleteTestFile(".pdf");
mockStorageProvider.Verify(t => t.CreateBlob(filePath, "unitTestFile.pdf"));
//Assert.IsTrue(folderMonitor.Running);
}
public void GivenFolders_WhenOneFolderNotEmpty_ThenNewResourcesAdded()
{
// Arrange
var emptyDir = Directory.CreateDirectory(Guid.NewGuid().ToString());
var notEmptyDir = Directory.CreateDirectory(Guid.NewGuid().ToString());
var filePath = Path.Combine(notEmptyDir.FullName, Guid.NewGuid().ToString());
using (var writer = File.CreateText(filePath))
{
writer.WriteLine("Hello world!");
}
// Act
var context = DbContextFactory.CreateImMemory();
var monitor = new FolderMonitor(context, scanFrequencySeconds: 20);
var raised = Assert.Raises <ResourceAddedEventArgs>(
handler => monitor.ResourceAdded += handler,
handler => monitor.ResourceAdded -= handler,
() =>
{
using (monitor)
{
monitor.StartMonitoring(
new[] { emptyDir.FullName, notEmptyDir.FullName });
Thread.Sleep((int)TimeSpan.FromSeconds(5).TotalMilliseconds);
}
});
// Assert
Assert.NotNull(raised);
Assert.Equal(monitor, raised.Sender);
var fileInfo = new FileInfo(filePath);
AssertEventArgs(fileInfo, raised.Arguments);
var resource = context.Resources.FirstOrDefault(r => r.Name == fileInfo.Name);
Assert.NotNull(resource);
AssertResource(fileInfo, resource);
fileInfo.Delete();
notEmptyDir.Delete();
emptyDir.Delete();
}
public void Remove(object referenceObject, string path,
Delegates.FileChangedHandlerDelegate fileChanged,
Delegates.FileCreatedHandlerDelegate fileCreated,
Delegates.FileDeletedHandlerDelegate fileDeleted,
Delegates.FileRenamedHandlerDelegate fileRenamed)
{
string folder = GetFolder(path);
FolderMonitor folderMonitor = null;
if (_FolderMonitors.ContainsKey(folder) && _FolderMonitors[folder].ReferencedObjects.Exists(x => x.Equals(referenceObject)))
{
folderMonitor = _FolderMonitors[folder];
}
else
{
return;
}
folderMonitor.ReferencedObjects = folderMonitor.ReferencedObjects.Remove(x => x.Equals(referenceObject));
if (fileChanged != null)
{
folderMonitor.FileChanged -= fileChanged;
}
if (fileCreated != null)
{
folderMonitor.FileCreated -= fileCreated;
}
if (fileDeleted != null)
{
folderMonitor.FileDeleted -= fileDeleted;
}
if (fileRenamed != null)
{
folderMonitor.FileRenamed -= fileRenamed;
}
if (folderMonitor.ReferencedObjects.Length == 0)
{
folderMonitor.Stop();
if (!_FolderMonitors.TryRemove(folder, out folderMonitor))
{
// TODO: throw
}
}
}
// ReSharper disable once UnusedParameter.Local
static void Main(string[] args)
{
//string control;
Console.WriteLine("Enter path for the directory you want to monitor:");
var path = Console.ReadLine();
Console.WriteLine("Enter interval of monitoring:");
var intr = Convert.ToInt32(Console.ReadLine());
var monitor1 = new FolderMonitor(path, intr);
var thread = new Thread(monitor1.Monitoring);
thread.Start();
while (true)
{
Console.ReadLine();
monitor1.IsActive = !monitor1.IsActive;
Console.WriteLine(!monitor1.IsActive ? "Monitoring paused." : "Monitoring resumed.");
}
// ReSharper disable once FunctionNeverReturns
}
static void Main(string[] args)
{
FolderMonitor dev1 = new FolderMonitor(@"E:\dev1");
dev1.IsMonitoring = true;
//dev1.Monitoring();
Thread thread = new Thread(dev1.Monitoring);
thread.Start();
thread.Priority = ThreadPriority.Highest;
for (;;)
{
string str = Console.ReadLine();
dev1.IsMonitoring = !dev1.IsMonitoring;
Console.WriteLine("!!!");
}
Console.ReadLine();
}
static void Main(string[] args)
{
FolderMonitor folderMonitor = new FolderMonitor();
string controlString;
do
{
Console.Clear();
Console.WriteLine("Welcome to the folder check utility.\n\n");
Console.WriteLine("1 - Add new folder to check\n2 - Save current status on disk\n" +
"3 - Look changes from last saved status\n4 - Choose(view list) monitored folder\n" +
"5 - Delete monitored folder from list\n6 - List directory.\n0 - Exit");
controlString = Console.ReadLine();
if (controlString == "1")
{
folderMonitor.AddNewFolderToList();
}
if (controlString == "2")
{
folderMonitor.SaveCurrentFolderStatus();
}
if (controlString == "3")
{
folderMonitor.ChangesList();
}
if (controlString == "4")
{
folderMonitor.ChooseMonitoredFolder();
}
if (controlString == "5")
{
folderMonitor.DeleteChoosenFolder();
}
if (controlString == "6")
{
folderMonitor.ListCurrentDirectory();
}
}while (controlString != "0");
}
static void Main(string[] args)
{
//Отслеживает удаление и создание файлов
//Отслеживает изменения файлов
FolderMonitor FolderMon = new FolderMonitor();
string path = @"D:\dev1";
FolderMon.FolderInitialize(path);
FolderMon._isMonitoring = true;
// FolderMon.Monitoring();
Thread thread = new Thread(FolderMon.MonitoringThead);
thread.Start();
thread.Priority = ThreadPriority.Normal;
Console.ReadLine();
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component
.For <ServiceConfig>()
.Instance(_config)
.LifeStyle.Singleton);
kernel.Register(
Component.For <MethodCallLoggingAdvice>()
.ImplementedBy <MethodCallLoggingAdvice>());
kernel.Register(
Component
.For <IScanServiceContext>()
.UsingFactoryMethod(ConfigureDbContext)
.LifeStyle.Transient);
kernel.Register(
Component
.For <IResourceMonitor>()
.Interceptors <MethodCallLoggingAdvice>()
.UsingFactoryMethod(
k =>
{
var monitor = new FolderMonitor(
k.Resolve <IScanServiceContext>(),
_config.FolderScanFrequencySeconds);
var handlers = k.ResolveAll <IResourceMonitorEventHandler>();
foreach (var handler in handlers)
{
monitor.ResourceAdded += handler.ResourceAddedEventHandler;
monitor.ResourceChanged += handler.ResourceChangedEventHandler;
}
return(monitor);
}));
kernel.Register(
Component.For <IResourceMonitorEventHandler>()
.Interceptors <MethodCallLoggingAdvice>()
.UsingFactoryMethod(
_ => new ResourceStreamingHandler(
new MessageSequenceBuilder(),
new ServiceBusQueueMessageSender(
_config.DataQueueConnectionString,
_config.DataQueueName),
() => _config.MessageMaxSizeBytes))
.LifeStyle.Transient);
kernel.Register(
Component.For <IAvailabilityCheck>()
.Interceptors <MethodCallLoggingAdvice>()
.UsingFactoryMethod(
_ => new AvailabilityCheck(
new ServiceBusQueueMessageSender(
_config.MonitoringQueueConnectionString,
_config.MonitoringQueueName),
ConfigureDbContext(),
_config.ClientId,
_config.AvailabilityCheckFrequencySeconds))
.LifeStyle.Transient);
kernel.Register(
Component.For <IMessageReceiver>()
.Interceptors <MethodCallLoggingAdvice>()
.UsingFactoryMethod(
_ => new ServiceBusSubscriptionMessageReceiver(
_config.ConfigTopicConnectionString,
_config.ConfigTopicName,
_config.ConfigTopicSubscriptionName))
.LifeStyle.Transient);
kernel.Register(
Component.For <IExternalConfigurationProvider>()
.ImplementedBy(typeof(ExternalConfigurationProvider))
.Interceptors <MethodCallLoggingAdvice>()
.LifeStyle.Transient);
}
static void Main(string[] args)
{
FolderMonitor fm = new FolderMonitor(@"H:\C# Training");
fm.StartMonitoring();
}
public void Setup()
{
_fakeWatcher = Substitute.For <IFileSystemWatcherWrapper>();
_uut = new FolderMonitor(_fakeWatcher);
}
