internal static string CreateConflictDetails(
string sourceItem,
string targetItem,
string linkType,
NonCyclicReferenceClosure linkReferenceClosure)
{
CyclicLinkConflictDetails dtls =
new CyclicLinkConflictDetails(sourceItem, targetItem, linkType, linkReferenceClosure);
return(dtls.Properties.ToString());
}
private static string CreateConflictDetails(
Exception linkSubmissionException,
LinkChangeAction action,
NonCyclicReferenceClosure linkReferenceClosure)
{
string sourceItem;
string targetItem;
string linkType;
ParseException(linkSubmissionException, action, out sourceItem, out targetItem, out linkType);
return(CyclicLinkConflictDetails.CreateConflictDetails(sourceItem, targetItem, linkType, linkReferenceClosure));
}
public static MigrationConflict CreateConflict(
LinkChangeAction conflictedAction,
Exception linkSubmissionException,
NonCyclicReferenceClosure linkReferenceClosure)
{
string scopeHint = CreateScopeHint(linkSubmissionException, conflictedAction);
string conflictDetails = CreateConflictDetails(linkSubmissionException, conflictedAction, linkReferenceClosure);
MigrationConflict conflict = new MigrationConflict(new TFSCyclicLinkConflictType(), MigrationConflict.Status.Unresolved, conflictDetails, scopeHint);
conflict.ConflictedLinkChangeAction = conflictedAction;
return(conflict);
}
public void ExtractDirectedLinksClosure(
WorkItem workItem,
NonCyclicReferenceClosure closure)
{
if (null == workItem)
{
throw new ArgumentNullException("workItem");
}
if (null == closure)
{
throw new ArgumentNullException("closure");
}
Debug.Assert(ExtendedProperties.Directed);
ExtractDirectedLinks(workItem, closure);
}
public CyclicLinkConflictDetails(
string sourceItemId,
string targetItemId,
string linkTypeReferenceName,
NonCyclicReferenceClosure linkReferenceClosure)
: base(sourceItemId, targetItemId, linkTypeReferenceName)
{
LinkReferenceClosure = new List <LinkDescription>();
if (null != linkReferenceClosure)
{
foreach (var link in linkReferenceClosure.Links)
{
LinkReferenceClosure.Add(
new LinkDescription(link.SourceArtifactId, TfsWorkItemHandler.IdFromUri(link.TargetArtifact.Uri)));
}
}
}
private void ExtractDirectedLinks(
WorkItem workItem,
NonCyclicReferenceClosure closure)
{
List <int> workItemIdsToProcess = new List <int>();
foreach (WorkItemLink l in workItem.WorkItemLinks)
{
if (!TFStringComparer.LinkName.Equals(l.LinkTypeEnd.LinkType.ReferenceName, ReferenceName))
{
continue;
}
var sourceIdStr = l.SourceId.ToString(CultureInfo.InvariantCulture);
var targetIdStr = l.TargetId.ToString(CultureInfo.InvariantCulture);
var sourceUri = TfsWorkItemHandler.UriFromId(sourceIdStr);
var targetUri = TfsWorkItemHandler.UriFromId(targetIdStr);
var sourceArtifact = new ToolkitLinking.Artifact(sourceUri, s_sourceArtifactType);
var targetArtifact = new ToolkitLinking.Artifact(targetUri, s_targetArtifactType);
if (!closure.SourceArtifactUris.Contains(targetUri) &&
!closure.TargetArtifactUris.Contains(targetUri))
{
workItemIdsToProcess.Add(l.TargetId);
}
if (l.LinkTypeEnd.IsForwardLink)
{
var link = new ToolkitLinking.ArtifactLink(sourceIdStr, sourceArtifact, targetArtifact, l.Comment, this);
closure.AddValidLink(link);
}
}
foreach (var workItemId in workItemIdsToProcess)
{
var wi = m_store.GetWorkItem(workItemId);
if (null == wi)
{
continue;
}
ExtractDirectedLinks(wi, closure);
}
}
public override NonCyclicReferenceClosure CreateNonCyclicLinkReferenceClosure(
LinkType linkType,
IArtifact artifact)
{
if (null == linkType)
{
throw new ArgumentNullException("linkType");
}
if (null == artifact)
{
throw new ArgumentNullException("artifact");
}
Debug.Assert(linkType.ExtendedProperties.NonCircular);
var closure = new NonCyclicReferenceClosure(linkType);
var workItemLinkType = linkType as WorkItemLinkTypeBase;
if (null == workItemLinkType)
{
return(closure);
}
string id;
var idExtractionRslt = TryExtractArtifactId(artifact, out id);
Debug.Assert(idExtractionRslt);
var workItemId = int.Parse(id);
var workItem = m_migrationSource.WorkItemStore.WorkItemStore.GetWorkItem(workItemId);
if (null == workItem)
{
return(closure);
}
workItemLinkType.ExtractDirectedLinksClosure(workItem, closure);
return(closure);
}
private bool SubmitBatchedAddOrDeleteLinkChanges(
List <XmlDocument> updateDocuments,
Dictionary <int, LinkChangeAction> updateDocIndexToLinkChangeActionMap,
ITranslationService translationService,
ConfigurationService configService,
ConflictManager conflictManager)
{
bool succeeded = true;
UpdateResult[] results = TfsBatchUpdateHelper.Submit(Core, WorkItemServer, updateDocuments.ToArray());
if (results.Length != updateDocuments.Count)
{
throw new SynchronizationEngineException("Wrong number of link update results.");
}
// Collect list of successful LinkChangeActions (for LinkTypes with GetsActionsFromLinkChangeHistory true) to pass to SetServerLinkChangeIds()
List <LinkChangeAction> actionsNeedingServerLinkIdSet = new List <LinkChangeAction>();
for (int i = 0; i < results.Length; ++i)
{
UpdateResult rslt = results[i];
if (rslt.Exception != null)
{
if (rslt.Exception.Message.Contains("The specified link already exists"))
{
// it is ok to eat this exception
// mark the change action completed so it is not retried later
LinkChangeAction action = updateDocIndexToLinkChangeActionMap[i];
action.Status = LinkChangeAction.LinkChangeActionStatus.Skipped;
TraceManager.TraceInformation("Tried to add a link that already exists so skipping it: " + GetLinkChangeActionDescription(action));
System.Web.Services.Protocols.SoapException soapException = rslt.Exception as System.Web.Services.Protocols.SoapException;
if (soapException != null)
{
TraceManager.TraceVerbose("SoapException.Detail.InnerXml for ignored exception: " + soapException.Detail.InnerXml);
}
}
else if (updateDocIndexToLinkChangeActionMap[i].ChangeActionId == WellKnownChangeActionId.Delete && rslt.Exception.Message.Contains("This specified link does not exist"))
{
// it is ok to eat this exception and skip the action
// mark the change action completed so it is not retried later
LinkChangeAction action = updateDocIndexToLinkChangeActionMap[i];
action.Status = LinkChangeAction.LinkChangeActionStatus.Skipped;
TraceManager.TraceInformation("Tried to delete a link that does not exist so skipping it: " + GetLinkChangeActionDescription(action));
System.Web.Services.Protocols.SoapException soapException = rslt.Exception as System.Web.Services.Protocols.SoapException;
if (soapException != null)
{
TraceManager.TraceVerbose("SoapException.Detail.InnerXml for ignored exception: " + soapException.Detail.InnerXml);
}
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSMulitpleParentLinkConflictType.SingleParentViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
MigrationConflict conflict = TFSMulitpleParentLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSCyclicLinkConflictType.CircularityLinkHierarchyViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
ILinkProvider linkProvider = ServiceContainer.GetService(typeof(ILinkProvider)) as ILinkProvider;
Debug.Assert(null != linkProvider, "linkProvider is NULL");
LinkChangeAction conflictedAction = updateDocIndexToLinkChangeActionMap[i];
NonCyclicReferenceClosure linkRefClosure =
linkProvider.CreateNonCyclicLinkReferenceClosure(conflictedAction.Link.LinkType, conflictedAction.Link.SourceArtifact);
MigrationConflict conflict = TFSCyclicLinkConflictType.CreateConflict(conflictedAction, rslt.Exception, linkRefClosure);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSModifyLockedWorkItemLinkConflictType.ModifyLockedWorkItemLinkViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
MigrationConflict conflict = TFSModifyLockedWorkItemLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
(rslt.Exception.Message.StartsWith(TFSLinkAccessViolationConflictType.LinkAccessViolationMessage1, StringComparison.OrdinalIgnoreCase) ||
rslt.Exception.Message.StartsWith(TFSLinkAccessViolationConflictType.LinkAccessViolationMessage2, StringComparison.OrdinalIgnoreCase)))
{
MigrationConflict conflict = TFSLinkAccessViolationConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
}
else
{
LinkChangeAction action = updateDocIndexToLinkChangeActionMap[i];
// TODO
// Try resolve conflict and push to backlog if resolution fails
action.IsConflicted = true;
TraceManager.TraceError(String.Format(CultureInfo.InvariantCulture,
"Exception processing {0}: {1}", GetLinkChangeActionDescription(action), rslt.Exception.ToString()));
succeeded = false;
}
}
else // rslt.Exception == null
{
LinkChangeAction successfulAction = updateDocIndexToLinkChangeActionMap[i];
MarkLinkChangeActionCompleted(successfulAction);
TraceManager.TraceVerbose("Successful " + GetLinkChangeActionDescription(successfulAction));
List <LinkChangeAction> updatedActions = new List <LinkChangeAction>();
updatedActions.Add(successfulAction);
if (successfulAction.Link.LinkType.GetsActionsFromLinkChangeHistory)
{
actionsNeedingServerLinkIdSet.Add(successfulAction);
}
UpdateLinkConversionHistory(configService, translationService, rslt, updatedActions);
}
}
SetServerLinkChangeIds(actionsNeedingServerLinkIdSet);
return(succeeded);
}
private bool SubmitBatchedAddOrDeleteLinkChanges(
List <XmlDocument> updateDocuments,
Dictionary <int, LinkChangeAction> updateDocIndexToLinkChangeActionMap,
ITranslationService translationService,
ConfigurationService configService,
ConflictManager conflictManager)
{
bool succeeded = true;
UpdateResult[] results = TfsBatchUpdateHelper.Submit(Core, WorkItemServer, updateDocuments.ToArray());
if (results.Length != updateDocuments.Count)
{
throw new SynchronizationEngineException("Wrong number of link update results.");
}
// Collect list of successful LinkChangeActions (for LinkTypes with GetsActionsFromLinkChangeHistory true) to pass to SetServerLinkChangeIds()
List <LinkChangeAction> actionsNeedingServerLinkIdSet = new List <LinkChangeAction>();
for (int i = 0; i < results.Length; ++i)
{
if (results[i] == null)
{
continue;
}
UpdateResult rslt = results[i];
if (rslt.Exception != null)
{
MigrationConflict conflict = null;
ConflictResolutionResult resolutionRslt = null;
List <MigrationAction> actions;
bool createWitGeneralConflict = false;
System.Web.Services.Protocols.SoapException soapException = rslt.Exception as System.Web.Services.Protocols.SoapException;
if (soapException != null)
{
int?tfsErrorNumber = GetTfsErrorNumberFromSoapException(soapException);
if (tfsErrorNumber.HasValue)
{
LinkChangeAction linkChangeAction = updateDocIndexToLinkChangeActionMap[i];
switch (tfsErrorNumber)
{
case TfsConstants.TfsError_AddLink_LinkExists:
case TfsConstants.TfsError_DeleteLink_LinkNotFound:
// it is ok to eat these exception and skip the action
// mark the change action completed so it is not retried later
linkChangeAction.Status = LinkChangeAction.LinkChangeActionStatus.Skipped;
if (tfsErrorNumber == TfsConstants.TfsError_AddLink_LinkExists)
{
TraceManager.TraceInformation("Tried to add a link that already exists so skipping it: " + GetLinkChangeActionDescription(linkChangeAction));
}
else
{
TraceManager.TraceInformation("Tried to delete a link that does not exist so skipping it: " + GetLinkChangeActionDescription(linkChangeAction));
}
if (soapException.Detail != null)
{
TraceManager.TraceVerbose("SoapException.Detail.InnerXml for ignored exception: " + soapException.Detail.InnerXml);
}
break;
case TfsConstants.TfsError_AddLink_TooManyParents:
if (linkChangeAction.Group.IsForcedSync)
{
if (DeleteExistingParentLinkToForceSyncAddLink(linkChangeAction, updateDocuments[i]))
{
break;
}
}
conflict = TFSMulitpleParentLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
break;
case TfsConstants.TfsError_AddLink_Circular:
case TfsConstants.TfsError_AddLink_ChildIsAncestor:
ILinkProvider linkProvider = ServiceContainer.GetService(typeof(ILinkProvider)) as ILinkProvider;
Debug.Assert(null != linkProvider, "linkProvider is NULL");
LinkChangeAction conflictedAction = updateDocIndexToLinkChangeActionMap[i];
NonCyclicReferenceClosure linkRefClosure =
linkProvider.CreateNonCyclicLinkReferenceClosure(conflictedAction.Link.LinkType, conflictedAction.Link.SourceArtifact);
conflict = TFSCyclicLinkConflictType.CreateConflict(conflictedAction, rslt.Exception, linkRefClosure);
resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
break;
case TfsConstants.TfsError_LinkAuthorizationFailedLinkLocked:
conflict = TFSModifyLockedWorkItemLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
break;
case TfsConstants.TfsError_LinkAuthorizationFailed:
case TfsConstants.TfsError_LinkAuthorizationFailedNotServiceAccount:
conflict = TFSLinkAccessViolationConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
break;
default:
// TFS error doesn't match any that we explicitly handle
TraceManager.TraceError("SubmitBatchedAddOrDeleteLinkChanges:TFS error number in SoapException not explictly handled: {0}", tfsErrorNumber);
createWitGeneralConflict = true;
break;
}
}
else
{
TraceManager.TraceError("SubmitBatchedAddOrDeleteLinkChanges: Unable to get TFS error number from SoapException: {0}", soapException.ToString());
createWitGeneralConflict = true;
}
}
else // Exception is not SoapException
{
TraceManager.TraceError("SubmitBatchedAddOrDeleteLinkChanges: Exception returned is not SoapException: {0}", rslt.Exception.ToString());
createWitGeneralConflict = true;
}
if (createWitGeneralConflict)
{
conflict = WitGeneralConflictType.CreateConflict(rslt.Exception);
resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
}
}
else // rslt.Exception == null
{
LinkChangeAction successfulAction = updateDocIndexToLinkChangeActionMap[i];
MarkLinkChangeActionCompleted(successfulAction);
TraceManager.TraceVerbose("Successful " + GetLinkChangeActionDescription(successfulAction));
List <LinkChangeAction> updatedActions = new List <LinkChangeAction>();
updatedActions.Add(successfulAction);
if (successfulAction.Link.LinkType.GetsActionsFromLinkChangeHistory)
{
actionsNeedingServerLinkIdSet.Add(successfulAction);
}
UpdateLinkConversionHistory(configService, translationService, rslt, updatedActions);
}
}
SetServerLinkChangeIds(actionsNeedingServerLinkIdSet);
return(succeeded);
}
private bool SubmitBatchedAddOrDeleteLinkChanges(
List <XmlDocument> updateDocuments,
Dictionary <int, LinkChangeAction> updateDocIndexToLinkChangeActionMap,
ITranslationService translationService,
ConfigurationService configService,
ConflictManager conflictManager)
{
bool succeeded = true;
UpdateResult[] results = TfsBatchUpdateHelper.Submit(Core, WorkItemServer, updateDocuments.ToArray());
if (results.Length != updateDocuments.Count)
{
throw new SynchronizationEngineException("Wrong number of link update results.");
}
for (int i = 0; i < results.Length; ++i)
{
UpdateResult rslt = results[i];
if (rslt.Exception != null)
{
if (rslt.Exception.Message.Contains("The specified link already exists"))
{
// it is ok to eat this exception
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSMulitpleParentLinkConflictType.SingleParentViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
MigrationConflict conflict = TFSMulitpleParentLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSCyclicLinkConflictType.CircularityLinkHierarchyViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
ILinkProvider linkProvider = ServiceContainer.GetService(typeof(ILinkProvider)) as ILinkProvider;
Debug.Assert(null != linkProvider, "linkProvider is NULL");
LinkChangeAction conflictedAction = updateDocIndexToLinkChangeActionMap[i];
NonCyclicReferenceClosure linkRefClosure =
linkProvider.CreateNonCyclicLinkReferenceClosure(conflictedAction.Link.LinkType, conflictedAction.Link.SourceArtifact);
MigrationConflict conflict = TFSCyclicLinkConflictType.CreateConflict(conflictedAction, rslt.Exception, linkRefClosure);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
succeeded = false;
}
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
rslt.Exception.Message.StartsWith(
TFSModifyLockedWorkItemLinkConflictType.ModifyLockedWorkItemLinkViolationMessage,
StringComparison.OrdinalIgnoreCase))
{
MigrationConflict conflict = TFSModifyLockedWorkItemLinkConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
}
else if (rslt.Exception is System.Web.Services.Protocols.SoapException &&
null != rslt.Exception.Message &&
(rslt.Exception.Message.StartsWith(TFSLinkAccessViolationConflictType.LinkAccessViolationMessage1, StringComparison.OrdinalIgnoreCase) ||
rslt.Exception.Message.StartsWith(TFSLinkAccessViolationConflictType.LinkAccessViolationMessage2, StringComparison.OrdinalIgnoreCase)))
{
MigrationConflict conflict = TFSLinkAccessViolationConflictType.CreateConflict(
updateDocIndexToLinkChangeActionMap[i], rslt.Exception);
List <MigrationAction> actions;
var resolutionRslt = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!resolutionRslt.Resolved)
{
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
// returning "not succeeded" so that the caller keeps this change group in "ReadyForMigration" status
succeeded = false;
}
else
{
TraceManager.TraceError(rslt.Exception.ToString());
succeeded = false;
// TODO
// Try resolve conflict and push to backlog if resolution fails
updateDocIndexToLinkChangeActionMap[i].IsConflicted = true;
}
}
else
{
foreach (LinkChangeAction action in updateDocIndexToLinkChangeActionMap.Values)
{
MarkLinkChangeActionCompleted(action);
}
List <LinkChangeAction> updatedActions = new List <LinkChangeAction>(updateDocIndexToLinkChangeActionMap.Values);
if (rslt.Exception == null)
{
UpdateLinkConversionHistory(configService, translationService, rslt, updatedActions);
}
else if (rslt.Exception.Message.Contains("The specified link already exists"))
{
WorkItemLinkStore relatedArtifactsStore = new WorkItemLinkStore(configService.SourceId);
relatedArtifactsStore.UpdateSyncedLinks(updatedActions);
}
}
}
return(succeeded);
}
