void HandleNonRenameChange(object sender, FileSystemEventArgs e)
        {
            var relativePath = GetRelativePath(e.FullPath);

            _logger.Log(LogLevel.DEBUG, $"Received FS {e.ChangeType} event for {relativePath}");

            if (!ShouldIgnore(relativePath, false))
            {
                _eventQueue.Enqueue(CreateSystemFileChange(ConvertFileChangeType(e.ChangeType), relativePath, e.FullPath));
            }
        }
Exemple #2
0
        static IEnumerable <IFilePathFilter> ReadGitIgnoreExclusions(string rootDirectoryPath, IRemoteDevLogger logger)
        {
            // Always ignore .git folder
            yield return(new GlobFilePathFilter(".git"));

            yield return(new GlobFilePathFilter(".git/**"));

            // Ignore files from root gitignore
            var gitIgnorePath = Path.Combine(rootDirectoryPath, ".gitignore");

            if (File.Exists(gitIgnorePath))
            {
                logger.Log(LogLevel.INFO, $"Using the gitignore found in {gitIgnorePath}");
                var filterCount = 0;

                using (var fs = File.OpenRead(gitIgnorePath))
                    using (var reader = new StreamReader(fs))
                    {
                        while (!reader.EndOfStream)
                        {
                            var filter = GitIgnoreParser.ParseLine(reader.ReadLine());
                            if (filter != null)
                            {
                                filterCount++;
                                yield return(filter);
                            }
                        }
                    }

                logger.Log(LogLevel.INFO, $"Found {filterCount} blob filters in the gitignore file");
            }
            else
            {
                logger.Log(LogLevel.WARN, "No .gitignore found in root directory. No file/folder changes will be ignored");
            }
        }
Exemple #3
0
        void HandleOnChangeEvent(object sender, FileSystemChange fileSystemChange)
        {
            var relativePath = fileSystemChange.GetRelativePath();

            _logger.Log(LogLevel.DEBUG, $"Worker received {fileSystemChange.FileSystemEntityType} {fileSystemChange.FileSystemChangeType} event for {relativePath}");

            if (fileSystemChange.FileSystemEntityType == FileSystemEntityType.File)
            {
                if (fileSystemChange.FileSystemChangeType == FileSystemChangeType.Deleted)
                {
                    DeleteFile(relativePath);
                }
                else
                {
                    PutFile(relativePath);
                }
            }
            else if (fileSystemChange.FileSystemEntityType == FileSystemEntityType.Directory)
            {
                if (fileSystemChange.FileSystemChangeType == FileSystemChangeType.Deleted)
                {
                    DeleteDirectory(relativePath);
                }
                else if (fileSystemChange.FileSystemChangeType == FileSystemChangeType.Created)
                {
                    CreateDirectory(relativePath);
                }
                else
                {
                    _logger.Log(LogLevel.DEBUG, $"No need to process {fileSystemChange.FileSystemEntityType} {fileSystemChange.FileSystemChangeType} for {relativePath}");
                }
            }
            else
            {
                if (fileSystemChange.FileSystemChangeType == FileSystemChangeType.Deleted)
                {
                    DeleteFile(relativePath);
                    DeleteDirectory(relativePath);
                }
                else
                {
                    _logger.Log(LogLevel.WARN, $"Cannot to process {fileSystemChange.FileSystemEntityType} {fileSystemChange.FileSystemChangeType} for {relativePath}");
                }
            }
        }