public void DumpProject(VssProject project, int indent)
{
var indentStr = new string(' ', indent);
physicalNames.Add(project.PhysicalName);
writer.WriteLine("{0}{1}/ ({2})",
indentStr, project.Name, project.PhysicalName);
foreach (VssProject subproject in project.Projects)
{
DumpProject(subproject, indent + 2);
}
foreach (VssFile file in project.Files)
{
physicalNames.Add(file.PhysicalName);
writer.WriteLine("{0} {1} ({2}) - {3}",
indentStr, file.Name, file.PhysicalName, file.GetPath(project));
if (IncludeRevisions)
{
foreach (VssFileRevision version in file.Revisions)
{
writer.WriteLine("{0} #{1} {2} {3}",
indentStr, version.Version, version.User, version.DateTime);
}
}
}
}
public static RecursionStatus RecurseItems(
VssProject project, VssProjectCallback projectCallback, VssFileCallback fileCallback)
{
if (projectCallback != null)
{
RecursionStatus status = projectCallback(project);
if (status != RecursionStatus.Continue)
{
return status;
}
}
foreach (VssProject subproject in project.Projects)
{
RecursionStatus status = RecurseItems(
subproject, projectCallback, fileCallback);
if (status == RecursionStatus.Abort)
{
return status;
}
}
foreach (VssFile file in project.Files)
{
RecursionStatus status = fileCallback(project, file);
if (status == RecursionStatus.Abort)
{
return status;
}
}
return RecursionStatus.Continue;
}
public static RecursionStatus RecurseItems(
VssProject project, VssProjectCallback projectCallback, VssFileCallback fileCallback)
{
if (projectCallback != null)
{
RecursionStatus status = projectCallback(project);
if (status != RecursionStatus.Continue)
{
return status;
}
}
foreach (VssProject subproject in project.Projects)
{
RecursionStatus status = RecurseItems(
subproject, projectCallback, fileCallback);
if (status == RecursionStatus.Abort)
{
return status;
}
}
HashSet<string> locallyProcessedFiles = new HashSet<string>();
foreach (VssFile file in project.Files)
{
RecursionStatus status = fileCallback(project, file);
locallyProcessedFiles.Add(file.PhysicalName);
if (status == RecursionStatus.Abort)
{
return status;
}
}
foreach (VssRevision revision in project.Revisions)
{
var namedAction = revision.Action as VssNamedAction;
if (namedAction != null && !namedAction.Name.IsProject)
{
string physicalName = namedAction.Name.PhysicalName;
if (!locallyProcessedFiles.Contains(physicalName))
{
VssFile file = project.GetHistoricalFile(physicalName, namedAction.Name.LogicalName);
locallyProcessedFiles.Add(file.PhysicalName);
if (File.Exists(file.PhysicalPath) && File.Exists(file.DataPath))
{
RecursionStatus status = fileCallback(project, file);
if (status == RecursionStatus.Abort)
{
return status;
}
}
}
}
}
return RecursionStatus.Continue;
}
internal VssDatabase(string path, Encoding encoding)
{
if (Type.GetType("Mono.Runtime") != null)
{
RootProjectFile = RootProjectFile.ToLower();
}
this.basePath = path;
this.encoding = encoding;
iniPath = Path.Combine(path, "srcsafe.ini");
var iniReader = new SimpleIniReader(iniPath);
iniReader.Parse();
dataPath = Path.Combine(path, iniReader.GetValue("Data_Path", "data"));
var namesPath = Path.Combine(dataPath, "names.dat");
nameFile = new NameFile(namesPath, encoding);
rootProject = OpenProject(null, RootProjectFile, RootProjectName);
}
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);
});
}
public string GetPath(VssProject project)
{
return project.Path + VssDatabase.ProjectSeparator + Name;
}
public ProjectAnalyzer(WorkQueue workQueue, Logger logger, VssProject vssRootProject)
: base(workQueue, logger)
{
this.vssRootProject = vssRootProject;
}
private void ProcessProject(VssProject project, string path, PathMatcher exclusionMatcher)
{
try
{
ProjectLocation projectLocation;
if (sortedProjectLocations.TryGetValue(project.PhysicalName, out projectLocation))
logger.WriteLine("Unexpected: ProjectAnalyzer.ProcessProject: sortedProjectLocations already contains project: {0}", project.PhysicalName);
else
{
projectLocation = new ProjectLocation(project.PhysicalName, path);
sortedProjectLocations[project.PhysicalName] = projectLocation;
};
foreach (VssRevision vssRevision in project.Revisions)
{
var actionType = vssRevision.Action.Type;
var namedAction = vssRevision.Action as VssNamedAction;
if (namedAction != null)
{
var targetPath = path + VssDatabase.ProjectSeparator + namedAction.Name.LogicalName;
if (exclusionMatcher != null && exclusionMatcher.Matches(targetPath))
{
// project action targets an excluded file
continue;
}
if (namedAction.Name.IsProject)
{
if (
(actionType == VssActionType.Delete) ||
(actionType == VssActionType.Destroy)
)
deletedProjects.Add(namedAction.Name.PhysicalName);
else if (
(actionType == VssActionType.Recover) ||
(actionType == VssActionType.Share)
)
deletedProjects.Remove(namedAction.Name.PhysicalName);
}
else
{
if (
(actionType == VssActionType.Delete) ||
(actionType == VssActionType.Destroy)
)
projectLocation.DeletedFiles.Add(namedAction.Name.PhysicalName);
else if (
(actionType == VssActionType.Recover) ||
(actionType == VssActionType.Share)
)
projectLocation.DeletedFiles.Remove(namedAction.Name.PhysicalName);
}
}
}
}
catch (RecordException e)
{
var message = string.Format("ProjectAnalyzer.ProcessProject: Failed to process project for {0} ({1}): {2}",
path, project.PhysicalName, ExceptionFormatter.Format(e));
LogException(e, message);
ReportError(message);
}
}
private static string BuildPath(VssProject parent, string logicalName)
{
return (parent != null) ? parent.Path + ProjectSeparator + logicalName : logicalName;
}
internal VssProject OpenProject(VssProject parent, string physicalName, string logicalName)
{
var itemName = new VssItemName(logicalName, physicalName, true);
var logicalPath = BuildPath(parent, logicalName);
var physicalPath = GetDataPath(physicalName);
return new VssProject(this, itemName, physicalPath, logicalPath);
}
public VssItem GetItemPhysical(string physicalName)
{
physicalName = physicalName.ToUpper();
if (physicalName == RootProjectFile)
{
return rootProject;
}
var physicalPath = GetDataPath(physicalName);
var itemFile = new ItemFile(physicalPath, encoding);
var isProject = (itemFile.Header.ItemType == ItemType.Project);
var logicalName = GetFullName(itemFile.Header.Name);
var itemName = new VssItemName(logicalName, physicalName, isProject);
VssItem item;
if (isProject)
{
var parentFile = ((ProjectHeaderRecord)itemFile.Header).ParentFile;
var parent = (VssProject)GetItemPhysical(parentFile);
var logicalPath = BuildPath(parent, logicalName);
item = new VssProject(this, itemName, physicalPath, logicalPath);
}
else
{
item = new VssFile(this, itemName, physicalPath);
}
item.ItemFile = itemFile;
return item;
}
public void DumpProject(VssProject project)
{
DumpProject(project, 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);
}
});
}
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);
});
}
