Helper methods for working with VSS objects.
Example #1
0
        public void AnalyzeProject()
        {
            PathMatcher exclusionMatcher = null;

            if (!string.IsNullOrEmpty(excludeFiles))
            {
                var excludeFileArray = excludeFiles.Split(
                    new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                exclusionMatcher = new PathMatcher(excludeFileArray);
            }

            workQueue.AddLast(delegate(object work)
            {
                logger.WriteSectionSeparator();
                LogStatus(work, "Building active project list");

                logger.WriteLine("Root project: {0}", vssRootProject.Path);
                logger.WriteLine("Excluded files: {0}", excludeFiles);

                int excludedProjects = 0;
                var stopwatch        = Stopwatch.StartNew();
                VssUtil.RecurseItems(vssRootProject,
                                     delegate(VssProject subproject)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }

                    var path = subproject.Path;
                    if (exclusionMatcher != null && exclusionMatcher.Matches(path))
                    {
                        logger.WriteLine("Excluding project {0}", path);
                        ++excludedProjects;
                        return(RecursionStatus.Skip);
                    }

                    if (!deletedProjects.Contains(subproject.PhysicalName))
                    {
                        ProcessProject(subproject, path, exclusionMatcher);
                        ++projectCount;
                    }

                    return(RecursionStatus.Continue);
                },
                                     delegate(VssProject subproject, VssFile file)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }
                    return(RecursionStatus.Continue);
                });
                stopwatch.Stop();

                logger.WriteSectionSeparator();
                logger.WriteLine("Analysis complete in {0:HH:mm:ss}", new DateTime(stopwatch.ElapsedTicks));
                logger.WriteLine("Projects: {0} ({1} excluded)", projectCount, excludedProjects);
            });
        }
Example #2
0
        public void AddItem(VssProject project)
        {
            if (project == null)
            {
                throw new ArgumentNullException("project");
            }
            else if (project.Database != database)
            {
                throw new ArgumentException("Project database mismatch", "project");
            }

            rootProjects.AddLast(project);

            PathMatcher exclusionMatcher = null;

            if (!string.IsNullOrEmpty(excludeFiles))
            {
                var excludeFileArray = excludeFiles.Split(
                    new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                exclusionMatcher = new PathMatcher(excludeFileArray);
            }

            workQueue.AddLast(delegate(object work)
            {
                logger.WriteSectionSeparator();
                LogStatus(work, "Building revision list");

                logger.WriteLine("Root project: {0}", project.Path);
                logger.WriteLine("Excluded files: {0}", excludeFiles);

                int excludedProjects = 0;
                int excludedFiles    = 0;
                var stopwatch        = Stopwatch.StartNew();
                VssUtil.RecurseItems(project,
                                     delegate(VssProject subproject)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }

                    var path = subproject.Path;
                    if (exclusionMatcher != null && exclusionMatcher.Matches(path))
                    {
                        logger.WriteLine("Excluding project {0}", path);
                        ++excludedProjects;
                        return(RecursionStatus.Skip);
                    }

                    ProcessItem(subproject, path, exclusionMatcher);
                    ++projectCount;
                    return(RecursionStatus.Continue);
                },
                                     delegate(VssProject subproject, VssFile file)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }

                    var path = file.GetPath(subproject);
                    if (exclusionMatcher != null && exclusionMatcher.Matches(path))
                    {
                        logger.WriteLine("Excluding file {0}", path);
                        ++excludedFiles;
                        return(RecursionStatus.Skip);
                    }

                    // only process shared files once (projects are never shared)
                    if (!processedFiles.Contains(file.PhysicalName))
                    {
                        processedFiles.Add(file.PhysicalName);
                        ProcessItem(file, path, exclusionMatcher);
                        ++fileCount;
                    }
                    return(RecursionStatus.Continue);
                });
                stopwatch.Stop();

                logger.WriteSectionSeparator();
                logger.WriteLine("Analysis complete in {0:HH:mm:ss}", new DateTime(stopwatch.ElapsedTicks));
                logger.WriteLine("Projects: {0} ({1} excluded)", projectCount, excludedProjects);
                logger.WriteLine("Files: {0} ({1} excluded)", fileCount, excludedFiles);
                logger.WriteLine("Revisions: {0}", revisionCount);
            });
        }
Example #3
0
        public void AddItem(VssProject project)
        {
            if (project == null)
            {
                throw new ArgumentNullException("project");
            }

            PathMatcher exclusionMatcher = null;

            if (!string.IsNullOrEmpty(excludeFiles))
            {
                var excludeFileArray = excludeFiles.Split(
                    new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                exclusionMatcher = new PathMatcher(excludeFileArray);
            }

            workQueue.AddLast(delegate(object work)
            {
                logger.WriteSectionSeparator();
                LogStatus(work, "Building file location dictionary");

                logger.WriteLine("Root project: {0}", project.Path);
                logger.WriteLine("Excluded files: {0}", excludeFiles);

                int excludedFiles = 0;
                var stopwatch     = Stopwatch.StartNew();
                VssUtil.RecurseItems(project,
                                     delegate(VssProject subproject)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }
                    return(RecursionStatus.Continue);
                },
                                     delegate(VssProject subproject, VssFile file)
                {
                    if (workQueue.IsAborting)
                    {
                        return(RecursionStatus.Abort);
                    }

                    var path = file.GetPath(subproject);
                    if (exclusionMatcher != null && exclusionMatcher.Matches(path))
                    {
                        logger.WriteLine("Excluding file {0}", path);
                        ++excludedFiles;
                        return(RecursionStatus.Skip);
                    }

                    // Don't process files in deleted projects
                    if (!projectAnalyzer.DeletedProjects.Contains(subproject.PhysicalName))
                    {
                        ProjectLocation projectLocation;
                        if (!projectAnalyzer.SortedProjectLocations.TryGetValue(subproject.PhysicalName, out projectLocation))
                        {
                            // If the project is not found it is (i.e. should) be due to exclusionMatcher
                            //logger.WriteLine("Unexpected: FileAnalyzer: SortedProjectLocations does not contain project: {0}", subproject.PhysicalName);
                        }
                        else if (!projectLocation.DeletedFiles.Contains(file.PhysicalName))
                        {
                            // If the file is shared it might be in more than one project...
                            // But this should not happen using this alternate import method!
                            if (processedFiles.Contains(file.PhysicalName))
                            {
                                ++sharedFileCount;
                                logger.WriteLine("Unexpected: FileAnalyzer: File shared in more tha one project: {0}: {1}", file.PhysicalName, subproject.Path);
                            }
                            else
                            {
                                processedFiles.Add(file.PhysicalName);
                                FileLocation fileLocation;
                                if (sortedFileLocations.TryGetValue(file.PhysicalName, out fileLocation))
                                {
                                    logger.WriteLine("Unexpected: FileAnalyzer: sortedFileLocations already contains file: {0}", file.PhysicalName);
                                }
                                else
                                {
                                    fileLocation = new FileLocation(file.PhysicalName, file.GetPath(subproject));
                                    sortedFileLocations[file.PhysicalName] = fileLocation;
                                }
                                ++fileCount;
                            }
                        }
                    }

                    return(RecursionStatus.Continue);
                });
                stopwatch.Stop();

                logger.WriteSectionSeparator();
                logger.WriteLine("Analysis complete in {0:HH:mm:ss}", new DateTime(stopwatch.ElapsedTicks));
                logger.WriteLine("Files: {0} ({1} excluded)", fileCount, excludedFiles);
                logger.WriteLine("Shared Files: {0}", sharedFileCount);

                if (sharedFileCount > 0)
                {
                    workQueue.Abort();
                    MessageBox.Show("Shared files exist!  " +
                                    "This alternate logic depends on files existing in only one location.  " +
                                    "Please resolve before reattempting conversion.",
                                    "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            });
        }