public void Stop()
{
if (!m_syncStateMachine.TryTransit(PipelineSyncCommand.STOP))
{
TraceManager.TraceWarning("Unable to stop session in current state: {0}", m_syncStateMachine.CurrentState);
}
}
internal bool InvokeProceedToAnalysisOnAnalysisAddins(Guid migrationSourceId)
{
foreach (AnalysisAddin analysisAddin in m_addinManagementService.GetMigrationSourceAnalysisAddins(migrationSourceId))
{
Debug.Assert(m_analysisContextsByMigrationSource.ContainsKey(migrationSourceId));
Debug.Assert(m_analysisProviders.ContainsKey(migrationSourceId));
AnalysisContext analysisContext;
if (m_analysisContextsByMigrationSource.TryGetValue(migrationSourceId, out analysisContext))
{
try
{
if (!analysisAddin.ProceedToAnalysis(analysisContext))
{
TraceManager.TraceWarning(String.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.AnalysisAddinSkippingPass,
analysisAddin.GetType().ToString()));
return(false);
}
}
catch (Exception ex)
{
ProcessAddinException(analysisAddin, migrationSourceId, ex);
}
}
}
return(true);
}
internal void PauseSessionUntilConflictsResolved(SessionWorker worker)
{
bool unresolvedConflictsFound = false;
while (m_syncStateMachine.CurrentState == PipelineState.PausedByConflict)
{
if (ConflictManager.DoesSessionHaveUnresolvedConflicts(worker.LeftMigrationSourceid, worker.RightMigrationSourceid))
{
if (!unresolvedConflictsFound)
{
TraceManager.TraceWarning("Session paused due to blocking conflict(s); resolve conflicts for this session to resume");
unresolvedConflictsFound = true;
}
// sleep at "PausedByConflict"
Thread.Sleep(ResumeAfterConflictPollingMilliSecs);
}
else
{
if (unresolvedConflictsFound)
{
TraceManager.TraceInformation("Resuming session {0} that was previously paused by one or more conflicts", m_syncStateMachine.OwnerUniqueId);
}
break;
}
}
m_syncStateMachine.TryTransit(PipelineSyncCommand.START_NEW_TRIP);
}
public static ICollection <ProviderHandler> LoadProvider(params DirectoryInfo[] probingDirectories)
{
if (s_providers == null || s_providers.Count == 0)
{
// Initialize a list that will contain all plugin types discovered
s_providers = new List <ProviderHandler>();
if (probingDirectories != null)
{
// Iterate over the probing directories and look for plugins
foreach (DirectoryInfo directory in probingDirectories)
{
Debug.Assert(directory.Exists, string.Format("Plugins directory does not exist: {0}", directory.FullName));
if (directory.Exists)
{
// Try to load plugins from each dll
foreach (FileInfo file in directory.GetFiles("*.dll"))
{
try
{
// Load the dll into an assembly
Assembly assembly = Assembly.LoadFrom(file.FullName);
// Iterate over all types contained in the assembly
foreach (Type type in assembly.GetTypes())
{
// Only consider public, concrete types that implement IProvider
if (type.IsPublic && !type.IsAbstract && (type.GetInterface(typeof(IProvider).Name) != null))
{
ProviderHandler handler = ProviderHandler.FromType(type);
if (null == handler ||
handler.ProviderId == null ||
handler.ProviderId == Guid.Empty)
{
continue;
}
s_providers.Add(handler);
TraceManager.TraceInformation("Provider {0} {1} is available", handler.ProviderName, handler.ProviderId.ToString());
}
}
}
catch (ReflectionTypeLoadException)
{
TraceManager.TraceInformation("Provider {0} is unavailable. One or more of the requested types cannot be loaded.", file.FullName);
}
catch (Exception)
{
// We try to load all .dll files and some of them just are not providers.
// Just log a warning and move along
TraceManager.TraceWarning("Failed to load the possible provider file: {0}", file.FullName);
}
}
}
}
}
}
return(s_providers);
}
public bool CanResolve(MigrationConflict conflict, ConflictResolutionRule rule)
{
if (rule.ActionRefNameGuid.Equals(new VCContentConflictUserMergeChangeAction().ReferenceName))
{
if (!conflict.ScopeHint.Contains(';'))
{
TraceManager.TraceWarning("Manual resolution rule of content conflict must be change group specific");
return(false);
}
}
return(ConflictTypeHandled.ScopeInterpreter.IsInScope(conflict.ScopeHint, rule.ApplicabilityScope));
}
public void Resume()
{
if (m_syncStateMachine.TryTransit(PipelineSyncCommand.RESUME))
{
if (SessionControlResume != null)
{
SessionControlResume(this, new SessionControlEventArgs());
}
}
else
{
TraceManager.TraceWarning("Unable to resume session in current state: {0}", m_syncStateMachine.CurrentState);
}
}
internal VCTranslationService(
Session session,
Guid leftMigrationSourceId,
Guid rightMigrationSourceId,
IProvider leftProvider,
IProvider rightProvider,
UserIdentityLookupService userIdLookupService)
: base(session, userIdLookupService)
{
IServerPathTranslationService leftPathTranslationService =
leftProvider.GetService(typeof(IServerPathTranslationService)) as IServerPathTranslationService;
if (null == leftPathTranslationService)
{
TraceManager.TraceWarning(MigrationToolkitResources.ErrorMissingVCPathTranslationService,
leftMigrationSourceId.ToString());
// default to UnixStyle Server Path translation service
leftPathTranslationService = new UnixStyleServerPathTranslationService();
}
leftPathTranslationService.Initialize(session.Filters[leftMigrationSourceId]);
IServerPathTranslationService rightPathTranslationService =
rightProvider.GetService(typeof(IServerPathTranslationService)) as IServerPathTranslationService;
if (null == rightPathTranslationService)
{
TraceManager.TraceWarning(MigrationToolkitResources.ErrorMissingVCPathTranslationService,
rightMigrationSourceId.ToString());
// default to UnixStyle Server Path translation service
rightPathTranslationService = new UnixStyleServerPathTranslationService();
}
rightPathTranslationService.Initialize(session.Filters[rightMigrationSourceId]);
m_serverPathTranslationService = new VCServerPathTranslationService(leftMigrationSourceId,
leftPathTranslationService,
rightMigrationSourceId,
rightPathTranslationService,
m_session.Filters.FilterPair);
m_migratinSourcePair.Add(leftMigrationSourceId, rightMigrationSourceId);
m_migratinSourcePair.Add(rightMigrationSourceId, leftMigrationSourceId);
}
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);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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();
}
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());
}
}
}
