/// <summary>
/// Generate delta table
/// </summary>
internal void GenerateDeltaTables(Guid sourceId)
{
Debug.Assert(m_serviceContainers.ContainsKey(sourceId),
string.Format(MigrationToolkitResources.UnknownSourceId, sourceId));
IAnalysisProvider analysisProvider;
if (!m_analysisProviders.TryGetValue(sourceId, out analysisProvider))
{
throw new MigrationException(string.Format(
MigrationToolkitResources.Culture,
MigrationToolkitResources.UnknownSourceId,
sourceId));
}
try
{
ChangeGroupService cgService =
m_serviceContainers[sourceId].GetService(typeof(ChangeGroupService)) as ChangeGroupService;
Debug.Assert(null != cgService, "Change group service is not properly initialized");
cgService.RemoveIncompleteChangeGroups();
analysisProvider.GenerateDeltaTable();
}
catch (MigrationUnresolvedConflictException)
{
// We have already created an unresolved conflict, just return.
return;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[sourceId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
/// <summary>
/// Initialize configuration services and add it to service container
/// </summary>
private void CreateServices()
{
Debug.Assert(m_serviceContainers.Count == 2);
ChangeGroupManager changeGroupManager = null;
foreach (KeyValuePair <Guid, ServiceContainer> container in m_serviceContainers)
{
ConfigurationService configurationService = new ConfigurationService(m_globalConfiguration, Configuration, container.Key);
container.Value.AddService(typeof(ConfigurationService), configurationService);
var sqlChangeGroupManager = new SqlChangeGroupManager(m_session, container.Key);
ChangeGroupService changeGroupService = new ChangeGroupService(sqlChangeGroupManager);
sqlChangeGroupManager.ChangeGroupService = changeGroupService;
container.Value.AddService(typeof(ChangeGroupService), changeGroupService);
if (null == changeGroupManager)
{
changeGroupManager = sqlChangeGroupManager;
}
else
{
changeGroupManager.OtherSideChangeGroupManager = sqlChangeGroupManager;
sqlChangeGroupManager.OtherSideChangeGroupManager = changeGroupManager;
}
}
}
/// <summary>
/// Initialize method of the session object
/// </summary>
internal void Initialize(int sessionRunId)
{
m_internalSessionRunId = sessionRunId;
// fully initialize the change group managers
foreach (var serviceContainer in m_serviceContainers.Values)
{
ChangeGroupService changeGroupService = serviceContainer.GetService(typeof(ChangeGroupService)) as ChangeGroupService;
changeGroupService.Initialize(sessionRunId);
}
}
private bool updateConversionHistory(MigrationConflict conflict, ConflictResolutionRule rule, IServiceContainer serviceContainer)
{
if (!rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId) ||
!rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.DeltaTableChangeId))
{
return(false);
}
ChangeGroupService changeGroupService = serviceContainer.GetService(typeof(ChangeGroupService)) as ChangeGroupService;
string migrationInstructionName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId];
string deltaTableName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.DeltaTableChangeId];
string comment = rule.RuleDescription;
return(changeGroupService.UpdateConversionHistoryAndRemovePendingChangeGroups(migrationInstructionName, deltaTableName, comment));
}
private void DetectBasicConflicts(ChangeGroupService targetChangeGroupService, Guid targetSystemId, Guid sourceSystemId)
{
TraceManager.TraceInformation("Starting basic conflict detection");
if (null == m_basicConflictAnalysisService)
{
return;
}
m_basicConflictAnalysisService.Configuration = m_session.Configuration;
m_basicConflictAnalysisService.TargetChangeGroupService = targetChangeGroupService;
m_basicConflictAnalysisService.ConflictManager = m_serviceContainers[targetSystemId].GetService(typeof(ConflictManager)) as ConflictManager;
m_basicConflictAnalysisService.TranslationService = m_translationService;
m_basicConflictAnalysisService.TargetSystemId = targetSystemId;
m_basicConflictAnalysisService.SourceSystemId = sourceSystemId;
m_basicConflictAnalysisService.Analyze();
TraceManager.TraceInformation("Finishing basic conflict detection");
}
private void ProviderDetectConflicts(Guid targetSystemId, ChangeGroupService targetChangeGroupService)
{
Debug.Assert(m_serviceContainers.ContainsKey(targetSystemId),
string.Format(MigrationToolkitResources.UnknownSourceId, targetSystemId));
IAnalysisProvider targetAnalysisProvider;
if (!m_analysisProviders.TryGetValue(targetSystemId, out targetAnalysisProvider))
{
throw new MigrationException(string.Format(
MigrationToolkitResources.Culture,
MigrationToolkitResources.UnknownSourceId,
targetSystemId));
}
try
{
int pageNumber = 0;
IEnumerable <ChangeGroup> changeGroups;
do
{
TraceManager.TraceInformation("Loading {0} ChangeGroup(s)", m_pageSize);
changeGroups = targetChangeGroupService.NextMigrationInstructionTablePage(pageNumber++, m_pageSize, true, false);
foreach (ChangeGroup nextChangeGroup in changeGroups)
{
TraceManager.TraceInformation("Target AnalysisProvider detecting conflicts in ChangeGroup #{0}", nextChangeGroup.ChangeGroupId);
targetAnalysisProvider.DetectConflicts(nextChangeGroup);
}
}while (changeGroups.Count() == m_pageSize);
}
catch (MigrationUnresolvedConflictException)
{
// We have already created an unresolved conflict, just return.
return;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[targetSystemId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
/// <summary>
/// Establish migration context (e.g. WIT metadata sync) on the "sourceId" side
/// </summary>
/// <param name="sourceId"></param>
internal virtual void EstablishContext(Guid sourceId)
{
Debug.Assert(m_serviceContainers.ContainsKey(sourceId),
string.Format(MigrationToolkitResources.UnknownSourceId, sourceId));
IMigrationProvider migrationProvider;
if (!m_migrationProviders.TryGetValue(sourceId, out migrationProvider))
{
throw new MigrationException(string.Format(
MigrationToolkitResources.Culture,
MigrationToolkitResources.UnknownSourceId,
sourceId));
}
Guid masterSourceId = GetMasterSourceId(sourceId);
Debug.Assert(!masterSourceId.Equals(Guid.Empty));
ChangeGroupService sourceSystemChangeGroupService =
m_serviceContainers[masterSourceId].GetService(typeof(ChangeGroupService)) as ChangeGroupService;
try
{
migrationProvider.EstablishContext(sourceSystemChangeGroupService);
}
catch (MigrationUnresolvedConflictException)
{
// We have already created an unresolved conflict, just return.
return;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[sourceId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
/// <summary>
/// Initialize analysis services
/// </summary>
private void RegisterServices(Guid sourceId, RuntimeSession session)
{
Debug.Assert(m_serviceContainers.ContainsKey(sourceId),
string.Format(MigrationToolkitResources.UnknownSourceId, sourceId));
ChangeActionRegistrationService changeActionRegistrationService = new ChangeActionRegistrationService();
m_serviceContainers[sourceId].AddService(typeof(ChangeActionRegistrationService), changeActionRegistrationService);
ContentTypeRegistrationService contentTypeRegistrationService = new ContentTypeRegistrationService();
m_serviceContainers[sourceId].AddService(typeof(ContentTypeRegistrationService), contentTypeRegistrationService);
ConflictManager conflictManagementService = new ConflictManager(sourceId);
conflictManagementService.ScopeId = new Guid(m_session.Configuration.SessionUniqueId);
m_serviceContainers[sourceId].AddService(typeof(ConflictManager), conflictManagementService);
conflictManagementService.InitializePhase1(m_serviceContainers[sourceId]);
RegisterGenericeConflicts(conflictManagementService);
RegisterSessionSpecificConflicts(conflictManagementService, session.Configuration.SessionType);
ICommentDecorationService commentDecorationService = new CommentDecorationService(m_session, m_serviceContainers[sourceId]);
m_serviceContainers[sourceId].AddService(typeof(ICommentDecorationService), commentDecorationService);
ChangeGroupService changeGroupService = m_serviceContainers[sourceId].GetService(typeof(ChangeGroupService)) as ChangeGroupService;
if (changeGroupService != null)
{
changeGroupService.PreChangeGroupSaved += new EventHandler <ChangeGroupEventArgs>(changeGroupService_PreChangeGroupSaved);
if (!m_changeGroupServices.ContainsKey(sourceId))
{
m_changeGroupServices.Add(sourceId, changeGroupService);
}
}
}
internal void Migrate(Guid targetSideSourceId, SessionOrchestrationPolicy orchPolicy)
{
try
{
Debug.Assert(m_serviceContainers.ContainsKey(targetSideSourceId), string.Format(MigrationToolkitResources.UnknownSourceId, targetSideSourceId));
ChangeGroupService changegroupService = (ChangeGroupService)m_serviceContainers[targetSideSourceId].GetService(
typeof(ChangeGroupService));
Debug.Assert(changegroupService != null, string.Format("Change group service on {0} is not loaded", targetSideSourceId));
changegroupService.DemoteInProgressActionsToPending();
int pageNumber = 0;
IEnumerable <ChangeGroup> changeGroups = null;
long?firstConflictedChangeGroupId = null;
if (StopMigrationEngineOnBasicConflict)
{
firstConflictedChangeGroupId = changegroupService.GetFirstConflictedChangeGroup(ChangeStatus.Pending);
}
do
{
// NOTE: we do not increment pageNumber here, because the processed ChangeGroups are marked "Complete" and no longer
// appear in the table
TraceManager.TraceInformation("Loading {0} ChangeGroup(s)", m_pageSize);
changeGroups = changegroupService.NextMigrationInstructionTablePage(pageNumber, m_pageSize, false, false);
foreach (ChangeGroup nextChangeGroup in changeGroups)
{
if (firstConflictedChangeGroupId.HasValue &&
firstConflictedChangeGroupId <= nextChangeGroup.ChangeGroupId)
{
// we should not process any conflicted change group or the following ones
// if StopMigrationEngineOnBasicConflict is the policy
return;
}
//ToDo Session.OnMigratingChangeStarting(args);
TraceManager.TraceInformation("Processing ChangeGroup #{0}", nextChangeGroup.ChangeGroupId);
ProcessMigrInstructionTableEntry(nextChangeGroup, targetSideSourceId);
nextChangeGroup.UpdateStatus(ChangeStatus.InProgress);
if (NoActiveMigrationInstructionInChangeGroup(nextChangeGroup))
{
nextChangeGroup.Complete();
continue;
}
ConversionResult result;
try
{
result = m_migrationProviders[targetSideSourceId].ProcessChangeGroup(nextChangeGroup);
}
catch (MigrationUnresolvedConflictException)
{
// We have already created an unresolved conflict, just return.
return;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[targetSideSourceId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
return;
}
if (!result.ContinueProcessing)
{
return;
}
if (!string.IsNullOrEmpty(result.ChangeId))
{
FinishChangeGroupMigration(nextChangeGroup, result);
InvokePostChangeGroupMigrationAddins(targetSideSourceId, nextChangeGroup);
}
orchPolicy.Check();
}
}while (changeGroups.Count() == m_pageSize);
}
catch (Microsoft.TeamFoundation.Migration.Toolkit.SessionOrchestrationPolicy.StopSingleTripException)
{
throw;
}
catch (Microsoft.TeamFoundation.Migration.Toolkit.SessionOrchestrationPolicy.StopSessionException)
{
throw;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[targetSideSourceId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
/// <summary>
/// Generate migration instructions
/// </summary>
internal void GenerateMigrationInstructions(Guid targetSystemId)
{
try
{
// Given target system, find change group service for source and for ourselves...
ConfigurationService configurationService = m_serviceContainers[targetSystemId].GetService(typeof(ConfigurationService)) as ConfigurationService;
// ToDo, not sure, we can probably just pass in ource system id to let target change group service to load it. But source/target may be different, not sqlchangegroupmanager
ChangeGroupService sourceChangeGroupService = m_serviceContainers[configurationService.MigrationPeer].GetService(typeof(ChangeGroupService)) as ChangeGroupService;
ChangeGroupService targetChangeGroupService = m_serviceContainers[targetSystemId].GetService(typeof(ChangeGroupService)) as ChangeGroupService;
// CopySourceDeltaTableToTarget
//ChangeGroup deltaTableEntry;
if (StopMigrationEngineOnBasicConflict)
{
// if one of the delta table entry on source side is conflicted, we stop
long?firstConflictedChangeGroupId = sourceChangeGroupService.GetFirstConflictedChangeGroup(ChangeStatus.DeltaPending);
if (firstConflictedChangeGroupId.HasValue)
{
return;
}
// if one of the migration instruction for target side is conflict, we also stop
firstConflictedChangeGroupId = targetChangeGroupService.GetFirstConflictedChangeGroup(ChangeStatus.Pending);
if (firstConflictedChangeGroupId.HasValue)
{
return;
}
}
ChangeActionRegistrationService changeActionRegistrationService =
m_serviceContainers[targetSystemId].GetService(typeof(ChangeActionRegistrationService)) as ChangeActionRegistrationService;
int pageNumber = 0;
IEnumerable <ChangeGroup> changeGroups;
do
{
// NOTE: we do not increment pageNumber here, because the processed ChangeGroups are marked "DeltaComplete" and no longer
// appear in the delta table
changeGroups = sourceChangeGroupService.NextDeltaTablePage(pageNumber, m_pageSize, false);
foreach (ChangeGroup deltaTableEntry in changeGroups)
{
TraceManager.TraceInformation(string.Format(
"Generating migration instruction for ChangeGroup {0}",
deltaTableEntry.ChangeGroupId));
ChangeGroup migrationInstructionChangeGroup = targetChangeGroupService.CreateChangeGroupForMigrationInstructionTable(deltaTableEntry);
// NOTE:
// migration instruction change group is created using the target change group manager/service
// however, the MigrationItems in it are created by the source-side adapter
// by setting the UseOtherSideMigrationItemSerializers flag, we tell this change group to use the source-side change group manager
// to find the registered IMigrationItem serializer to persist these MigrationItems
migrationInstructionChangeGroup.UseOtherSideMigrationItemSerializers = true;
migrationInstructionChangeGroup.ReflectedChangeGroupId = deltaTableEntry.ChangeGroupId;
foreach (MigrationAction action in deltaTableEntry.Actions)
{
try
{
BeforeCopyDeltaTableEntryToMigrationInstructionTable(action, configurationService.MigrationPeer);
}
catch (UnmappedWorkItemTypeException unmappedWITEx)
{
ConflictManager conflictManager =
m_serviceContainers[configurationService.MigrationPeer].GetService(typeof(ConflictManager)) as ConflictManager;
var conflict = WITUnmappedWITConflictType.CreateConflict(unmappedWITEx.SourceWorkItemType, action);
List <MigrationAction> actions;
var result = conflictManager.TryResolveNewConflict(conflictManager.SourceId, conflict, out actions);
if (!result.Resolved)
{
continue;
}
else
{
if (result.ResolutionType == ConflictResolutionType.SkipConflictedChangeAction)
{
action.State = ActionState.Skipped;
continue;
}
else
{
// NOTE:
// So far this conflict can only be:
// 1. manually resolved (skipped) AFTER
// the configuration is updated with the requirement WIT mapping;
// 2. skipping the conflicted migration action (i.e. not migrating the source
// Work Item type.
Debug.Assert(
false,
string.Format("WITUnmappedWITConflict is auto-resolved. Skipping this assertion will SKIP the original conflicted action '{0}'.",
action.ActionId.ToString()));
action.State = ActionState.Skipped;
continue;
}
}
}
if (action.State == ActionState.Skipped || action.ChangeGroup.ContainsBackloggedAction)
{
continue;
}
ChangeActionHandler actionHandler;
if (changeActionRegistrationService.TryGetChangeActionHandler(action.Action, action.ItemTypeReferenceName, out actionHandler))
{
try
{
actionHandler(action, migrationInstructionChangeGroup);
}
catch (MigrationUnresolvedConflictException)
{
// We have already created an unresolved conflict, just return.
return;
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[targetSystemId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
else
{
string analysisProviderName;
IAnalysisProvider analysisProvider;
if (m_analysisProviders.TryGetValue(targetSystemId, out analysisProvider))
{
analysisProviderName = analysisProvider.GetType().ToString();
}
else
{
Debug.Fail("Unable to find IAnalysisProvider with Id: " + targetSystemId);
analysisProviderName = "Unknown";
}
throw new MigrationException(
string.Format(MigrationToolkitResources.Culture, MigrationToolkitResources.UnknownChangeAction,
action.Action.ToString(), analysisProviderName));
}
}
if (!migrationInstructionChangeGroup.ContainsBackloggedAction &&
migrationInstructionChangeGroup.Actions.Count > 0)
{
ChangeStatus status = migrationInstructionChangeGroup.Status;
migrationInstructionChangeGroup.Status = ChangeStatus.ChangeCreationInProgress;
migrationInstructionChangeGroup.Owner = deltaTableEntry.Owner; // owner may be translated too
// Save the partial Change group into DB.
migrationInstructionChangeGroup.Save();
// Commit the status change together.
migrationInstructionChangeGroup.Status = status;
deltaTableEntry.Status = ChangeStatus.DeltaComplete;
migrationInstructionChangeGroup.Manager.BatchUpdateStatus(
new ChangeGroup[] { migrationInstructionChangeGroup, deltaTableEntry });
}
else
{
// If all change actions in the delta table entry are skipped.
// Just mark the delta table entry as completed.
deltaTableEntry.UpdateStatus(ChangeStatus.DeltaComplete);
}
if (this.StopRequested)
{
return;
}
}
}while (changeGroups.Count() == m_pageSize);
DetectBasicConflicts(targetChangeGroupService, targetSystemId, configurationService.MigrationPeer);
if (this.StopRequested)
{
return;
}
ProviderDetectConflicts(targetSystemId, targetChangeGroupService);
if (this.StopRequested)
{
return;
}
// dispose the target side delta table entries after we've done all conflict analysis
targetChangeGroupService.BatchMarkMigrationInstructionsAsPending();
}
catch (Exception e)
{
ConflictManager manager = m_serviceContainers[targetSystemId].GetService(typeof(ConflictManager)) as ConflictManager;
ErrorManager.TryHandleException(e, manager);
}
}
public virtual void EstablishContext(ChangeGroupService sourceSystemChangeGroupService)
{
return;
}