private void Initialize(bool appRunOnStartup)
{
bool cacheFolderCreated;
_filteredCacheItems = ReadCache(appRunOnStartup, out _cacheUpToDate, out cacheFolderCreated, out _lastFullScanTime);
_fileSystemChanges = new FileSystemChanges();
if (cacheFolderCreated)
{
string cacheFolder = GetCacheFolder();
try
{
FileSystemChangeEventArgs e = new FileSystemChangeEventArgs(null, cacheFolder);
HandleFolderSystemChanged(this, e);
}
catch (PathTooLongException)
{
}
}
//Listen to the changes in the whole system to update the fullCache.
//This handler should be bound just after reading the full cache to ensure that _fullCache is initialized.
_fileSystemListener.FolderSystemChanged += HandleFolderSystemChanged;
_fileSystemListener.StartListening(null);
//Parse file system fully (asynchronously).
if (!_cacheUpToDate)
{
StartFileSystemParsing();
}
}
void ProcessCreation(FolderItem parentItem, FileSystemChangeEventArgs change)
{
var path = change.Path;
if (fileSystemProvider.FileExists(path))
{
var fileInfo = fileSystemProvider.GetFileInfo(path);
if (fileInfo == null)
{
return;
}
var fileItem = new FileItem(change.Name, fileInfo.Item2);
if (parentItem.FindChildren(fileItem.DisplayName) != null)
{
return;
}
parentItem.AddChildren(fileItem);
OnFileSystemItemAdded(parentItem, fileItem);
}
else if (fileSystemProvider.DirectoryExists(path))
{
var folderItem = new FolderItem(change.Name);
if (parentItem.FindChildren(folderItem.DisplayName) != null)
{
return;
}
parentItem.AddChildren(folderItem);
folderItem.PropertyChanged += ehPropertyChanged;
AddFolderToScan(folderItem);
OnFileSystemItemAdded(parentItem, folderItem);
}
}
void ProcessChange(FolderItem parentItem, FileSystemChangeEventArgs change)
{
if (change == null)
{
return;
}
switch (change.ChangeType)
{
case FileSystemChangeType.Change:
ProcessChange(parentItem, change.Path, change.Name);
break;
case FileSystemChangeType.Deletion:
var deletedItem = parentItem.RemoveChildren(change.Name);
if (deletedItem != null)
{
if (deletedItem is FolderItem deletedFolder)
{
deletedFolder.IsProcessing = false;
}
OnFileSystemItemDeleted(parentItem, deletedItem);
}
break;
case FileSystemChangeType.Creation:
ProcessCreation(parentItem, change);
break;
case FileSystemChangeType.Rename:
parentItem.RenameChildren(change.OldName, change.OldPath, change.Name, change.Path);
break;
}
}
private void HandleFileChange(
IFileMirrorPlugin plugin,
FileSystemChangeEventArgs e)
{
switch (e.ChangeType)
{
case FileSystemChangeType.Create:
plugin.CreateFile(e.FullPath);
break;
case FileSystemChangeType.Change:
plugin.UpdateFile(e.FullPath);
break;
case FileSystemChangeType.Rename:
plugin.RenameFile(e.OriginalFullPath, e.FullPath);
break;
case FileSystemChangeType.Delete:
plugin.DeleteFile(e.FullPath);
break;
default:
throw new NotSupportedException(string.Format("ChangeType '{0}' not supported.", e.ChangeType.ToString()));
}
}
public void SetUp()
{
_fileSystemListener = new FileSystemListener();
_fileSystemListener.FolderSystemChanged += HandleFolderSystemChanged;
_eventArgs = null;
DirectoryUtility.EnsureClearFolder(FolderName);
}
void ehChanged(object sender, FileSystemChangeEventArgs e)
{
changedEvents.Enqueue(e);
if (processChangesTask == null || processChangesTask.IsCompleted || processChangesTask.IsCanceled)
{
processChangesTokenSource = new System.Threading.CancellationTokenSource();
processChangesTask = Task.Run(ProcessChangesTask, processChangesTokenSource.Token);
}
}
protected virtual void OnFolderSystemChanged(string oldPath, string newPath)
{
if (FolderSystemChanged != null)
{
try
{
FileSystemChangeEventArgs args = new FileSystemChangeEventArgs(oldPath, newPath);
FolderSystemChanged(this, args);
}
catch (PathTooLongException)
{
}
}
}
private void _directoryWatcher_Changed(object sender, FileSystemChangeEventArgs e)
{
foreach (IFileMirrorPlugin plugin in this._plugins.OrderBy(p => p.Priority))
{
if (e.FileSystemObjectType == FileSystemObjectType.File)
{
HandleFileChange(plugin, e);
}
else if (e.FileSystemObjectType == FileSystemObjectType.Directory)
{
HandleDirectoryChange(plugin, e);
}
}
}
public static void UpdateFolders(List <FileSystemItem> folders, FileSystemChangeEventArgs e, Predicate <FileSystemItem> isCorrectPredicate)
{
if (folders == null || e == null)
{
return;
}
if (!string.IsNullOrEmpty(e.OldFullPath))
{
FileSystemItem deletedItem = FindItem(folders, e.OldFullPath);
if (deletedItem != null)
{
folders.Remove(deletedItem);
}
}
if (string.IsNullOrEmpty(e.NewFullPath))
{
return;
}
FileSystemItem addedItem;
try
{
addedItem = new FileSystemItem(e.NewFullPath);
}
catch (PathTooLongException)
{
return;
}
//Duplicates may appear in certain cases. Example:
//We store all the file system events gathered while parsing the system in a special list,
//and try to update the list for each of the events after parsing.
//But if an added folder was parsed after the event for this folder had occurred,
//the duplicate will be present.
FileSystemItem duplicate = FindItem(folders, e.NewFullPath);
bool isCorrect = (isCorrectPredicate == null) || isCorrectPredicate(addedItem);
if (isCorrect && duplicate == null)
{
folders.Add(addedItem);
}
}
private void HandleFolderSystemChanged(object sender, FileSystemChangeEventArgs e)
{
lock (_cacheSync)
{
_fileSystemChanges.Changes.Add(e);
//Though we write the cache back to file system in finalizer,
//we try to write it periodically also (to minimize the effect of finalization errors,
//e.g. when the computer is shut down unexpectedly).
_updatesCount++;
if (_updatesCount > _updatesCountToWrite)
{
SerializeChanges();
_updatesCount = 0;
}
Implementation.FileSystemParser.UpdateFolders(_filteredCacheItems, e, _fileSystemFilter.IsCorrect);
}
}
private void _fileSystemWatcher_Changed(object sender, FileSystemChangeEventArgs e)
{
Console.WriteLine(string.Concat(e.FullPath, " ", e.ChangeType.ToString(), "."));
IList <string> filesToProcess = this.GetFilesToProcess(e.FullPath);
foreach (string filePathToProcess in filesToProcess)
{
string argStr = this.ProcessFileCommandArgsService.BuildCommandArgs(
e.ChangeType,
e.FileSystemObjectType,
this.Config.WatchDirectory,
e.FullPath,
e.OriginalFullPath,
filePathToProcess,
this.Config.ExecutableArgs);
RunProcess(argStr);
}
}
void ProcessChangeForFolder(string parentPath, FileSystemChangeEventArgs change)
{
if (string.IsNullOrEmpty(parentPath))
{
return;
}
var parentItem = FindItem(parentPath) as FolderItem;
if (parentItem == null)
{
return;
}
while (parentItem.IsProcessing)
{
if (processChangesTokenSource != null && processChangesTokenSource.IsCancellationRequested)
{
return;
}
}
ProcessChange(parentItem, change);
}
private static string GetChangeItemLine(FileSystemChangeEventArgs item)
{
return(string.Format(CultureInfo.InvariantCulture, "{1}{0}{2}", Separator, item.OldFullPath ?? string.Empty, item.NewFullPath ?? string.Empty));
}
//All these events will be called after the full system parsing is finished
private void HandleFolderSystemChanged(object sender, FileSystemChangeEventArgs e)
{
_fileSystemChangeEvents.Add(e);
}
private void HandleFolderSystemChanged(object sender, FileSystemChangeEventArgs e)
{
_eventArgs = e;
}
