private void GenerateDeltaForForceSync(
IForceSyncItemService forceSyncItemService,
IForceSyncAnalysisProvider forceSyncAnalysisProvider)
{
int batchSize = 100;
List <string> forceSyncItemIds = new List <string>();
foreach (string forceSyncItemId in forceSyncItemService.GetItemsForForceSync())
{
TraceManager.TraceInformation(String.Format(CultureInfo.InvariantCulture,
"Will attempt to force sync work item {0} from migration source {1}",
forceSyncItemId, forceSyncItemService.MigrationSourceid));
forceSyncItemIds.Add(forceSyncItemId);
if (forceSyncItemIds.Count == batchSize)
{
forceSyncAnalysisProvider.GenerateDeltaForForceSync(forceSyncItemIds);
forceSyncItemIds.Clear();
}
}
if (forceSyncItemIds.Count > 0)
{
forceSyncAnalysisProvider.GenerateDeltaForForceSync(forceSyncItemIds);
}
}
/// <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);
}
IForceSyncAnalysisProvider forceSyncAnalysisProvider = analysisProvider as IForceSyncAnalysisProvider;
if (forceSyncAnalysisProvider != null)
{
IForceSyncItemService forceSyncItemService = m_serviceContainers[sourceId].GetService(typeof(IForceSyncItemService)) as IForceSyncItemService;
if (forceSyncItemService == null)
{
Debug.Fail("ForceSyncItemService not found");
}
else
{
GenerateDeltaForForceSync(forceSyncItemService, forceSyncAnalysisProvider);
}
}
}
private void OneDirectionProcessPipeline(
bool isLeftToRight,
Guid sourceMigrationSourceId,
Guid targetMigrationSourceId,
bool contextSyncNeeded,
bool bidirection)
{
try
{
m_orchPolicy.Check();
AnalysisEngine.SourceMigrationSourceId = sourceMigrationSourceId;
AnalysisEngine.InvokePreAnalysisAddins(sourceMigrationSourceId);
if (!AnalysisEngine.InvokeProceedToAnalysisOnAnalysisAddins(sourceMigrationSourceId))
{
// In case any of the AnalysisAddins perform cleanup in the PostAnalysis method
AnalysisEngine.InvokePostAnalysisAddins(sourceMigrationSourceId);
return;
}
TraceManager.TraceInformation("Pipeline flow from {0} to {1}", sourceMigrationSourceId, targetMigrationSourceId);
if (contextSyncNeeded)
{
TraceManager.TraceInformation("Generating context info tables for the migration source {0}", sourceMigrationSourceId);
AnalysisEngine.GenerateContextInfoTables(sourceMigrationSourceId);
m_orchPolicy.Check();
}
TraceManager.TraceInformation("Generating delta tables for the migration source {0}", sourceMigrationSourceId);
AnalysisEngine.GenerateDeltaTables(sourceMigrationSourceId);
m_orchPolicy.Check();
AnalysisEngine.InvokePostDeltaComputationAddins(sourceMigrationSourceId);
TraceManager.TraceInformation("Generating linking delta for the migration source {0}", sourceMigrationSourceId);
LinkEngine.GenerateLinkDelta(SessionId, sourceMigrationSourceId);
m_orchPolicy.Check();
AnalysisEngine.InvokePostAnalysisAddins(sourceMigrationSourceId);
// Mark the items provided by the ForceSyncItemService processed at this time
IForceSyncItemService forceSyncItemService = AnalysisEngine[sourceMigrationSourceId].GetService(typeof(IForceSyncItemService)) as IForceSyncItemService;
if (forceSyncItemService != null)
{
forceSyncItemService.MarkCurrentItemsProcessed();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Above: data collection at source side //
// Below: data migration/submission at target side //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MigrationEngine.InvokePreMigrationAddins(targetMigrationSourceId);
if (contextSyncNeeded)
{
TraceManager.TraceInformation("Establishing context for the migration source {0}", targetMigrationSourceId);
MigrationEngine.EstablishContext(targetMigrationSourceId);
m_orchPolicy.Check();
}
if (!AnalysisEngine.DisableTargetAnalysis)
{
TraceManager.TraceInformation("Generating delta tables for the migration source {0}", targetMigrationSourceId);
AnalysisEngine.GenerateDeltaTables(targetMigrationSourceId);
m_orchPolicy.Check();
// Mark the items provided by the ForceSyncItemService (if any) processed at this time
forceSyncItemService = AnalysisEngine[targetMigrationSourceId].GetService(typeof(IForceSyncItemService)) as IForceSyncItemService;
if (forceSyncItemService != null)
{
forceSyncItemService.MarkCurrentItemsProcessed();
}
}
TraceManager.TraceInformation("Generating migration instructions for the migration source {0}", targetMigrationSourceId);
AnalysisEngine.GenerateMigrationInstructions(targetMigrationSourceId);
m_orchPolicy.Check();
TraceManager.TraceInformation("Post-processing delta table entries from the migration source {0}", targetMigrationSourceId);
AnalysisEngine.PostProcessDeltaTableEntries(targetMigrationSourceId, bidirection);
m_orchPolicy.Check();
TraceManager.TraceInformation("Migrating to the migration source {0}", targetMigrationSourceId);
MigrationEngine.Migrate(targetMigrationSourceId, m_orchPolicy);
m_orchPolicy.Check();
MigrationEngine.InvokePostMigrationAddins(targetMigrationSourceId);
TraceManager.TraceInformation("Processing linking delta");
LinkEngine.AnalyzeLinkDelta(SessionId, sourceMigrationSourceId, bidirection);
m_orchPolicy.Check();
TraceManager.TraceInformation("Migrating links to the migration source {0}", targetMigrationSourceId);
LinkEngine.MigrateLinks(SessionId, targetMigrationSourceId);
m_orchPolicy.Check();
}
finally
{
// Record a sync point in the database
try
{
RecordSyncPoint(isLeftToRight, sourceMigrationSourceId, targetMigrationSourceId);
}
catch (Exception ex)
{
TraceManager.TraceWarning("{0}: Unable to record SyncPoint data due to exception: {1}", m_thread.Name, ex.ToString());
}
}
}
