private void initializeTfsClient()
{
TfsTeamProjectCollection tfsServer = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(ConfigurationService.ServerUrl));
if (!TfsUtil.IsTfs2010Server(tfsServer))
{
throw new MigrationException(string.Format("The target server {0} is not a TFS2010 server", ConfigurationService.ServerUrl));
}
m_tfsClient = (VersionControlServer)tfsServer.GetService(typeof(VersionControlServer));
m_analysisServiceContainer.AddService(typeof(VersionControlServer), m_tfsClient);
}
public void Add(BatchedItem change)
{
if (change == null)
{
throw new ArgumentNullException("change");
}
lock (m_locker)
{
if (!acceptingNewChanges)
{
Debug.Fail("ChangeOprimizer is not accepting new changes");
}
if (change.Action == WellKnownChangeActionId.Rename)
{
bool addToRenameList = true;
foreach (BatchedItem existingRenameChange in m_unresolvedRenames)
{
if (TfsUtil.isChildItemOf(change, existingRenameChange))
{
addToRenameList = false;
break;
}
}
if (addToRenameList)
{
m_unresolvedRenames.Add(change);
}
else
{
m_implicitRenames.Add(change.Target);
}
if (!m_renamePairs.ContainsKey(change.Target))
{
m_renamePairs.Add(change.Target, change.Source);
}
}
else if ((change.Action == WellKnownChangeActionId.Branch) ||
(change.Action == WellKnownChangeActionId.Add) ||
(change.Action == WellKnownChangeActionId.Undelete))
{
m_unresolvedAdditiveActions.Add(change);
}
else
{
// Deletes, Edits or Encodings
m_unresolvedChanges.Add(change);
}
}
}
private static void deleteFiles_inner(string directory)
{
foreach (string file in Directory.GetFiles(directory))
{
TfsUtil.DeleteFile(file);
}
foreach (string subDirectory in Directory.GetDirectories(directory))
{
deleteFiles_inner(subDirectory);
Directory.Delete(subDirectory);
}
}
private void initializeTfsClient()
{
TfsTeamProjectCollection tfsServer = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(ConfigurationService.ServerUrl));
if (!TfsUtil.IsTfs2010Server(tfsServer))
{
throw new MigrationException(string.Format("The target server {0} is not a TFS2010 server", ConfigurationService.ServerUrl));
}
tfsServer.EnsureAuthenticated();
TraceManager.TraceInformation("Authenticated User for Uri {0} is '{1}'", tfsServer.Uri, tfsServer.AuthorizedIdentity.DisplayName);
m_tfsClient = (VersionControlServer)tfsServer.GetService(typeof(VersionControlServer));
m_analysisServiceContainer.AddService(typeof(VersionControlServer), m_tfsClient);
}
private int[] getMappedTfsChange()
{
m_hwmDelta.Reload();
Debug.Assert(m_hwmDelta.Value >= 0, "High water mark of delta table must be non-negtive");
int latestChangeset = m_tfsClient.GetLatestChangesetId();
// No new changesets on server, return.
if (m_hwmDelta.Value >= latestChangeset)
{
return(new int[0]);
}
int startingChangeset = m_hwmDelta.Value + 1;
string skipComment = ConfigurationService.GetValue <string>(Constants.SkipComment, "**NOMIGRATION**");
string commentModifier = ConfigurationService.GetValue <string>(Constants.CommentModifier, TfsVCAdapterResource.DefaultCommentModifier);
SortedDictionary <int, bool> mappedChangesets = new SortedDictionary <int, bool>();
foreach (MappingEntry m in ConfigurationService.Filters)
{
if (m.Cloak)
{
continue;
}
try
{
foreach (Changeset changeset in m_tfsClient.QueryHistory(m.Path,
VersionSpec.Latest,
0,
RecursionType.Full,
null,
new ChangesetVersionSpec(startingChangeset),
new ChangesetVersionSpec(latestChangeset),
int.MaxValue, // All changes
false,
true))
{
if (mappedChangesets.ContainsKey(changeset.ChangesetId))
{
continue;
}
if (TfsUtil.IsOurTfsChange(changeset, TranslationService, m_conflictManagementService.SourceId))
{
TraceManager.TraceInformation("Skipping mirrored change {0}", changeset.ChangesetId);
continue;
}
if (!string.IsNullOrEmpty(skipComment))
{
if (changeset.Comment != null && changeset.Comment.Contains(skipComment))
{
TraceManager.TraceInformation("Changeset {0} contains the skip comment {1}",
changeset.ChangesetId,
skipComment);
continue;
}
}
if (!mappedChangesets.ContainsKey(changeset.ChangesetId))
{
mappedChangesets.Add(changeset.ChangesetId, true);
}
}
}
catch (ItemNotFoundException)
{
// the path does not contain any changesets
}
}
if (mappedChangesets.Count > 0)
{
int[] mappedChangesetsArray = new int[mappedChangesets.Count];
mappedChangesets.Keys.CopyTo(mappedChangesetsArray, 0);
return(mappedChangesetsArray);
}
else
{
// No new changesets are found, update the HWM as current latest
m_hwmDelta.Update(latestChangeset);
return(new int[0]);
}
}
private void detectConflicts()
{
// Sort m_unresolvedRenames by path length with shorter paths first
m_unresolvedRenames.Sort(delegate(BatchedItem lhs, BatchedItem rhs)
{
return(lhs.Source.Length.CompareTo(rhs.Source.Length));
});
// Find implicit renames, add them to m_implictRenames and m_implicitRenamesWithParentItems
// If they are not also explict renames, remove them from m_unresolvedRenames
for (int childIndex = m_unresolvedRenames.Count - 1; childIndex >= 0; childIndex--)
{
BatchedItem change = m_unresolvedRenames[childIndex];
bool removeFromUnresolvedRenames = false;
for (int parentIndex = 0; parentIndex < childIndex; parentIndex++)
{
BatchedItem shorterRename = m_unresolvedRenames[parentIndex];
bool childIsAlsoExplicitRename;
if (TfsUtil.isChildItemOfRename(change, shorterRename, out childIsAlsoExplicitRename))
{
m_implicitRenames.Add(change.Target);
m_implicitRenamesWithParentItems.Add(change.Target, shorterRename);
// There may be both an implicit rename of the item based on a parent rename and an explicit rename of this item
removeFromUnresolvedRenames = !childIsAlsoExplicitRename;
break;
}
}
if (removeFromUnresolvedRenames)
{
m_unresolvedRenames.RemoveAt(childIndex);
}
}
m_unresolvedAdditiveActions.Sort(delegate(BatchedItem lhs, BatchedItem rhs)
{
return(lhs.Target.Length.CompareTo(rhs.Target.Length));
});
for (int index = m_unresolvedAdditiveActions.Count - 1; index >= 0; index--)
{
foreach (BatchedItem rename in m_unresolvedRenames)
{
if (VersionControlPath.IsSubItem(m_unresolvedAdditiveActions[index].Target, rename.Source))
{
if ((m_unresolvedAdditiveActions[index].Action == WellKnownChangeActionId.Add) &&
(VersionControlPath.Equals(rename.Source, m_unresolvedAdditiveActions[index].Target)) &&
(VersionControlPath.IsSubItem(rename.Target, rename.Source)) &&
(!VersionControlPath.Equals(rename.Target, rename.Source)))
{
// This Add is created by a Rename to below itself. Skip it. Example:
// Rename $/foo/bar to $/foo/bar/bar2
// We will get two change actions, 1) Rename $/foo/bar to $/foo/bar/bar2
// 2) Add $/foo/bar.
// This is to skip the Add action as it will be created implicitly by the Rename.
if (!m_implicitAdds.Contains(m_unresolvedAdditiveActions[index].Target))
{
m_implicitAdds.Add(m_unresolvedAdditiveActions[index].Target);
}
m_unresolvedAdditiveActions.RemoveAt(index);
break;
}
// The additive item should be scheduled after the Rename.
// Unless the rename is a case only rename which does not change the namespace slot.
if (!VersionControlPath.Equals(rename.Source, rename.Target))
{
m_unresolvedAdditiveActions[index].ConflictItem = rename;
}
break;
}
}
}
for (int outerIndex = 0; outerIndex < m_unresolvedRenames.Count; outerIndex++)
{
BatchedItem processedChange = m_unresolvedRenames[outerIndex];
if (processedChange.ConflictItem != null)
{
continue;
}
// Find a parent item that was renamed
for (int innerIndex = 0; innerIndex < m_unresolvedRenames.Count; innerIndex++)
{
if (outerIndex == innerIndex)
{
continue;
}
BatchedItem change = m_unresolvedRenames[innerIndex];
if (VersionControlPath.IsSubItem(processedChange.Target, change.Source))
{
processedChange.ConflictItem = change;
break;
}
}
// Check for a rename cycles and chains that starts with the processedChange
// To do this: Follow the chain of renames until it ends, it cycles back to the processedChange, or
// the number of times through the loop reaches the size of m_renamePairs
// Note that the renameCycle list is only added to m_renameCycles (a List of Lists) if a cycle is
// found; otherwise it is was just a potential renameCycle that is tossed
List <BatchedItem> renameCycle = new List <BatchedItem>();
BatchedItem next;
if (!m_renamePairs.TryGetValue(processedChange.Target, out next))
{
Debug.Fail("Target of item in m_unresolvedRenames not found in m_renamePairs");
}
for (int i = 0; i < m_renamePairs.Count && next != null; i++)
{
string adjustedSource = null;
try
{
adjustedSource = adjustSourceForParentRenameIfNeeded(next.Source, next.Target, true);
}
catch
{
// Can occur if adjusted name is longer than max; in this case treat like not found in m_renamePairs by leaving adjustedSource null
}
BatchedItem renameSourceItem;
// m_renamePairs has the rename target as the key, so the following is checking if the
// source of the "next" rename item is the target of another rename
if (string.IsNullOrEmpty(adjustedSource) || !m_renamePairs.TryGetValue(adjustedSource, out renameSourceItem))
{
renameCycle = null;
break;
}
// Setting the ConflictItem is needed whether this is a cycle or just a chain
renameSourceItem.ConflictItem = next;
// Add to the renameCycle list though this instance of the list will be discarded unless a cycle is found below
renameCycle.Add(next);
next = renameSourceItem;
if (next.ID == processedChange.ID)
{
m_renameCycles.Add(renameCycle);
break;
}
}
foreach (BatchedItem additiveAction in m_unresolvedAdditiveActions)
{
if (additiveAction.Action == WellKnownChangeActionId.Undelete)
{
if (VersionControlPath.IsSubItem(processedChange.Target, additiveAction.Source))
{
Debug.Assert(processedChange.ConflictItem == null);
processedChange.ConflictItem = additiveAction;
continue;
}
}
else
{
// Add fld2, rename fld1/1.txt to fld2/1.txt
// We need to pend the Add first.
if (VersionControlPath.IsSubItem(processedChange.Target, additiveAction.Target))
{
if ((processedChange.ConflictItem == null) || VersionControlPath.IsSubItem(additiveAction.Target, processedChange.ConflictItem.Target))
{
processedChange.ConflictItem = additiveAction;
}
else
{
Debug.Assert(VersionControlPath.IsSubItem(processedChange.ConflictItem.Target, additiveAction.Target),
string.Format("Item {0} conflicted with two items: {1} and {2}",
processedChange.Target, processedChange.ConflictItem.Target, additiveAction.Target));
}
continue;
}
// Add fld1/file1.txt; rename fld -> fld1; rename go first
if (VersionControlPath.IsSubItem(additiveAction.Target, processedChange.Target))
{
if ((additiveAction.ConflictItem == null) || (VersionControlPath.IsSubItem(processedChange.Target, additiveAction.ConflictItem.Target)))
{
additiveAction.ConflictItem = processedChange;
}
else
{
Debug.Assert(VersionControlPath.IsSubItem(additiveAction.ConflictItem.Target, processedChange.Target),
string.Format("Item {0} conflicted with two items: {1} and {2}",
additiveAction.Target, additiveAction.ConflictItem.Target, processedChange.Target));
}
continue;
}
}
}
}
m_unresolvedChanges.AddRange(m_unresolvedAdditiveActions);
m_unresolvedChanges.AddRange(m_unresolvedRenames);
}
