Exemple #1
0
        /// <inheritdoc />
        protected override async Task ProcessAddedAsync(IConnectionFactory factory, directorywatcher.interfaces.IFileSystemEvent e, CancellationToken token)
        {
            var file = e.FileSystemInfo as FileInfo;

            if (!CanProcessFile(file))
            {
                return;
            }

            // the given file is going to be processed.
            Logger.Verbose($"File event: {e.FullName} (Created)");

            // just add the file.
            await Files.AddOrUpdateFileAsync(file, token).ConfigureAwait(false);
        }
        /// <inheritdoc />
        protected override async Task ProcessAddedAsync(IConnectionFactory factory, directorywatcher.interfaces.IFileSystemEvent e, CancellationToken token)
        {
            var directory = e.FileSystemInfo as DirectoryInfo;

            if (!CanProcessDirectory(directory))
            {
                return;
            }

            // the given file is going to be processed.
            Logger.Verbose($"Directory event: {directory?.FullName} (Created)");

            // just add the directory.
            await Folders.AddOrUpdateDirectoryAsync(directory, token).ConfigureAwait(false);
        }
Exemple #3
0
        /// <inheritdoc />
        protected override async Task ProcessRemovedAsync(IConnectionFactory factory, directorywatcher.interfaces.IFileSystemEvent e, CancellationToken token)
        {
            if (!(e.FileSystemInfo is FileInfo file))
            {
                return;
            }

            // we cannot call CanProcessFile as it is now deleted.
            if (Directory.IsIgnored(file))
            {
                return;
            }

            // the given file is going to be processed.
            Logger.Verbose($"File event: {e.FullName} (Deleted)");

            // do we have the file on record?
            if (await Files.FileExistsAsync(file, token).ConfigureAwait(false))
            {
                // just delete the folder.
                await Files.DeleteFileAsync(file, token).ConfigureAwait(false);
            }
        }
        /// <inheritdoc />
        protected override async Task ProcessRemovedAsync(IConnectionFactory factory, directorywatcher.interfaces.IFileSystemEvent e, CancellationToken token)
        {
            var directory = e.FileSystemInfo as DirectoryInfo;

            if (null == directory)
            {
                return;
            }

            // we cannot call CanProcessDirectory as it is now deleted.
            if (Directory.IsIgnored(directory))
            {
                return;
            }

            // the given file is going to be processed.
            Logger.Verbose($"Directory event: {directory.FullName} (Deleted)");

            // do we have the directory on record?
            if (await Folders.DirectoryExistsAsync(directory, token).ConfigureAwait(false))
            {
                // just delete the directory.
                await Folders.DeleteDirectoryAsync(directory, token).ConfigureAwait(false);
            }
        }
        /// <inheritdoc />
        protected override async Task ProcessTouchedAsync(IConnectionFactory factory, directorywatcher.interfaces.IFileSystemEvent e, CancellationToken token)
        {
            var directory = e.FileSystemInfo as DirectoryInfo;

            if (!CanProcessDirectory(directory))
            {
                return;
            }

            // we know the directory changed ... but does it even exist on our record?
            if (!await Folders.DirectoryExistsAsync(directory, token).ConfigureAwait(false))
            {
                for (;;)
                {
                    // add the directory
                    Logger.Verbose($"Directory event: {e.FullName} (Changed - But not on file)");

                    // just add the directory.
                    await Folders.AddOrUpdateDirectoryAsync(directory, token).ConfigureAwait(false);

                    // get the parent directory ... if there is one.
                    directory = directory?.Parent;
                    if (null == directory)
                    {
                        break;
                    }

                    // if the new directory exists then we do not need to worry any further.
                    if (await Folders.DirectoryExistsAsync(directory, token).ConfigureAwait(false))
                    {
                        break;
                    }
                }
                return;
            }

            // the given directory is going to be processed.
            Logger.Verbose($"Directory event: {e.FullName} (Changed)");

            // then make sure to touch the folder accordingly
            await Folders.FolderUpdates.TouchDirectoriesAsync(new [] { directory }, UpdateType.Changed, token).ConfigureAwait(false);
        }