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()); } } }