private static RTMigrationItem CreateCachedCSSNode( RTMigrationSource migrationSource, string nodeUri, string path) { var nodeCache = RTMigrationItem.CreateRTMigrationItem(0, nodeUri, string.Empty); nodeCache.MigrationSource = migrationSource; nodeCache.ItemData = path; return(nodeCache); }
private RTConversionHistory UpdateGroupConvHist( RuntimeEntityModel context, RTSessionRun rtSessionRun, RTMigrationSource rtMigrationSource) { RTConversionHistory runTimeConverHistory = RTConversionHistory.CreateRTConversionHistory( DateTime.UtcNow, -1, false); runTimeConverHistory.SessionRun = rtSessionRun; runTimeConverHistory.SourceMigrationSource = rtMigrationSource; context.AddToRTConversionHistorySet(runTimeConverHistory); return(runTimeConverHistory); }
/// <summary> /// Saves the conversion history and associate it with a particular session run and migration source; /// Additionally, mark the Reflected Change Group (the delta table entry of this processed change group) to be sync-ed. /// </summary> /// <param name="sessionRunId">int.MinValue if sessionRunId is not available</param> /// <param name="migrationSourceId"></param> /// <param name="sessionId"></param> /// <param name="reflectedChangeGroupId"></param> /// <returns></returns> internal bool Save( int sessionRunId, Guid migrationSourceId, Guid sessionId, long?reflectedChangeGroupId) { if (string.IsNullOrEmpty(ChangeId)) { return(false); } using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { if (ItemConversionHistory.Count > 0) { var sessionRunQuery = (sessionRunId == int.MinValue) ? from sr in context.RTSessionRunSet where sr.Config.LeftSourceConfig.MigrationSource.UniqueId.Equals(migrationSourceId) || sr.Config.RightSourceConfig.MigrationSource.UniqueId.Equals(migrationSourceId) select sr : context.RTSessionRunSet.Where(sr => sr.Id == sessionRunId); if (sessionRunQuery.Count() == 0) { return(false); } RTSessionRun rtSessionRun = sessionRunQuery.First(); var migrationSourceQuery = context.RTMigrationSourceSet.Where(ms => ms.UniqueId.Equals(migrationSourceId)); if (migrationSourceQuery.Count() == 0) { return(false); } RTMigrationSource rtMigrationSource = migrationSourceQuery.First(); RTConversionHistory rtConvHist = UpdateGroupConvHist(context, rtSessionRun, rtMigrationSource); UpdateItemConversionHistory(rtConvHist, context); } if (!sessionId.Equals(Guid.Empty) && reflectedChangeGroupId.HasValue) { MarkDeltaTableSynced(context, sessionId, reflectedChangeGroupId.Value); } context.TrySaveChanges(); return(true); } }
public ConflictRuleViewModel(RTConflict conflict, ApplicationViewModel appViewModel) : base(appViewModel) { m_conflict = conflict; base.Scope = m_conflict.ScopeHint; int migrationSourceId = (int)m_conflict.SourceSideMigrationSourceReference.EntityKey.EntityKeyValues.First().Value; if (!s_migrationSourceTable.ContainsKey(migrationSourceId)) { lock (s_migrationSourceTable) { if (!s_migrationSourceTable.ContainsKey(migrationSourceId)) { m_conflict.SourceSideMigrationSourceReference.Load(); s_migrationSourceTable.Add(migrationSourceId, m_conflict.SourceSideMigrationSource); } } } m_rtMigrationSource = s_migrationSourceTable[migrationSourceId]; int conflictTypeId = (int)m_conflict.ConflictTypeReference.EntityKey.EntityKeyValues.First().Value; if (!s_conflictTypeTable.ContainsKey(conflictTypeId)) { lock (s_conflictTypeTable) { if (!s_conflictTypeTable.ContainsKey(conflictTypeId)) { m_conflict.ConflictTypeReference.Load(); s_conflictTypeTable.Add(conflictTypeId, m_conflict.ConflictType); } } } SetConflictManager(m_conflict.ScopeId, m_rtMigrationSource.UniqueId, s_conflictTypeTable[conflictTypeId].ReferenceName); }
private bool updateConversionHistory(MigrationConflict conflict, ConflictResolutionRule rule) { if (!rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId) || !rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.DeltaTableChangeId)) { return(false); } string migrationInstructionName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId]; string deltaTableName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.DeltaTableChangeId]; using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { ChangeGroup conflictChangeGroup = conflict.ConflictedChangeAction.ChangeGroup; Guid deltaSideSourceId; // Mark all delta table entry as DeltaComplete var deltaTableEntries = from d in context.RTChangeGroupSet where d.SessionUniqueId == conflictChangeGroup.SessionId && d.Status == (int)ChangeStatus.DeltaPending select d; foreach (RTChangeGroup deltaTableEntry in deltaTableEntries) { deltaTableEntry.Status = (int)ChangeStatus.DeltaComplete; deltaTableEntry.ContainsBackloggedAction = false; } // Mark all migration instruction entry as Complete var migrationInstructionEntries = from d in context.RTChangeGroupSet where d.SessionUniqueId == conflictChangeGroup.SessionId && (d.Status == (int)ChangeStatus.Pending || d.Status == (int)ChangeStatus.InProgress || d.Status == (int)ChangeStatus.PendingConflictDetection) select d; foreach (RTChangeGroup migrationInstructionEntry in migrationInstructionEntries) { migrationInstructionEntry.Status = (int)ChangeStatus.Complete; migrationInstructionEntry.ContainsBackloggedAction = false; } // Mark the source side highwatermark var sourceSideHighWaterMark = (from hwm in context.RTHighWaterMarkSet where hwm.SessionUniqueId == conflictChangeGroup.SessionId && hwm.SourceUniqueId != conflictChangeGroup.SourceId && hwm.Name == Constants.HwmDelta select hwm).First(); Debug.Assert(sourceSideHighWaterMark != null, "Can't find the source side HWM"); sourceSideHighWaterMark.Value = deltaTableName; deltaSideSourceId = sourceSideHighWaterMark.SourceUniqueId; // Mark the target side highwatermark var targetHighWaterMark = (from hwm in context.RTHighWaterMarkSet where hwm.SessionUniqueId == conflictChangeGroup.SessionId && hwm.SourceUniqueId == conflictChangeGroup.SourceId && hwm.Name == Constants.HwmDelta select hwm).First(); Debug.Assert(targetHighWaterMark != null, "Can't find the target side HWM"); targetHighWaterMark.Value = migrationInstructionName; // Create the conversion history entry RTConversionHistory conversionHistory = RTConversionHistory.CreateRTConversionHistory( DateTime.UtcNow, -1, true); conversionHistory.Comment = rule.RuleDescription; var session = (from s in context.RTSessionConfigSet where s.SessionUniqueId == conflictChangeGroup.SessionId select s).First(); Debug.Assert(session != null, "Cannot find session in DB"); RTSessionRun sessionRun = (from sr in context.RTSessionRunSet where sr.Id == session.Id select sr).First(); Debug.Assert(sessionRun != null, "Cannot find session run in DB"); conversionHistory.SessionRun = sessionRun; RTMigrationSource migrationSource = (from ms in context.RTMigrationSourceSet where ms.UniqueId.Equals(conflictChangeGroup.SourceId) select ms).First(); Debug.Assert(migrationSource != null, "Cannot find the migration source to persist conversion history"); RTMigrationSource deltaSideMigrationSource = (from ms in context.RTMigrationSourceSet where ms.UniqueId.Equals(deltaSideSourceId) select ms).First(); Debug.Assert(deltaSideMigrationSource != null, "Cannot find the migration source to persist conversion history"); conversionHistory.SourceMigrationSource = migrationSource; context.AddToRTConversionHistorySet(conversionHistory); RTMigrationItem sourceItem = RTMigrationItem.CreateRTMigrationItem(0, deltaTableName, Constants.ChangeGroupGenericVersionNumber); sourceItem.MigrationSource = migrationSource; RTMigrationItem targetItem = RTMigrationItem.CreateRTMigrationItem(0, migrationInstructionName, Constants.ChangeGroupGenericVersionNumber); targetItem.MigrationSource = deltaSideMigrationSource; RTItemRevisionPair pair = RTItemRevisionPair.CreateRTItemRevisionPair( sourceItem.Id, targetItem.Id); pair.LeftMigrationItem = sourceItem; pair.RightMigrationItem = targetItem; pair.ConversionHistory = conversionHistory; // Create a new HistoryNotFoundConflict Resolution Rule context.TrySaveChanges(); } return(true); }
/// <summary> /// Update the conversion history with the given migration instruction and delta table entry. This will add the entry to conversion history and remove all pending change groups. /// </summary> /// <param name="migrationInstructionName"></param> /// <param name="deltaTableName"></param> /// <param name="comment"></param> /// <returns></returns> public override bool UpdateConversionHistoryAndRemovePendingChangeGroups(string migrationInstructionName, string deltaTableName, string comment) { if (string.IsNullOrEmpty(migrationInstructionName) || (string.IsNullOrEmpty(deltaTableName))) { return(false); } using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance()) { Guid deltaSideSourceId; Guid sessionId = new Guid(Session.SessionUniqueId); // Mark all delta table entry as DeltaComplete var deltaTableEntries = from d in context.RTChangeGroupSet where d.SessionUniqueId == sessionId && d.Status == (int)ChangeStatus.DeltaPending select d; foreach (RTChangeGroup deltaTableEntry in deltaTableEntries) { deltaTableEntry.Status = (int)ChangeStatus.DeltaComplete; deltaTableEntry.ContainsBackloggedAction = false; } // Mark all migration instruction entry as Complete var migrationInstructionEntries = from d in context.RTChangeGroupSet where d.SessionUniqueId == sessionId && (d.Status == (int)ChangeStatus.Pending || d.Status == (int)ChangeStatus.InProgress || d.Status == (int)ChangeStatus.PendingConflictDetection) select d; foreach (RTChangeGroup migrationInstructionEntry in migrationInstructionEntries) { migrationInstructionEntry.Status = (int)ChangeStatus.Complete; migrationInstructionEntry.ContainsBackloggedAction = false; } // Mark the source side highwatermark var sourceSideHighWaterMark = (from hwm in context.RTHighWaterMarkSet where hwm.SessionUniqueId == sessionId && hwm.SourceUniqueId != SourceId && hwm.Name == Constants.HwmDelta select hwm).First(); Debug.Assert(sourceSideHighWaterMark != null, "Can't find the source side HWM"); sourceSideHighWaterMark.Value = deltaTableName; deltaSideSourceId = sourceSideHighWaterMark.SourceUniqueId; // Mark the target side highwatermark var targetHighWaterMark = (from hwm in context.RTHighWaterMarkSet where hwm.SessionUniqueId == sessionId && hwm.SourceUniqueId == SourceId && hwm.Name == Constants.HwmDelta select hwm).First(); Debug.Assert(targetHighWaterMark != null, "Can't find the target side HWM"); targetHighWaterMark.Value = migrationInstructionName; // Prepare to create the conversion history entry (unless a matching one exists) RTMigrationSource migrationSource = (from ms in context.RTMigrationSourceSet where ms.UniqueId.Equals(SourceId) select ms).First(); Debug.Assert(migrationSource != null, "Cannot find the migration source to persist conversion history"); RTMigrationSource deltaSideMigrationSource = (from ms in context.RTMigrationSourceSet where ms.UniqueId.Equals(deltaSideSourceId) select ms).First(); Debug.Assert(deltaSideMigrationSource != null, "Cannot find the migration source to persist conversion history"); // A MigrationItem row may already exist; if so use it bool sourceMigrationItemExists; var sourceItemQuery = (from mi in context.RTMigrationItemSet where mi.MigrationSource.UniqueId.Equals(migrationSource.UniqueId) && mi.ItemId == deltaTableName && mi.ItemVersion == Constants.ChangeGroupGenericVersionNumber select mi); RTMigrationItem sourceItem; if (sourceItemQuery.Count() > 0) { sourceItem = sourceItemQuery.First(); sourceMigrationItemExists = true; } else { sourceItem = RTMigrationItem.CreateRTMigrationItem(0, deltaTableName, Constants.ChangeGroupGenericVersionNumber); sourceItem.MigrationSource = migrationSource; sourceMigrationItemExists = false; } // A MigrationItem row may already exist; if so use it bool targetMigrationItemExists; var targetItemQuery = (from mi in context.RTMigrationItemSet where mi.MigrationSource.UniqueId.Equals(deltaSideMigrationSource.UniqueId) && mi.ItemId == migrationInstructionName && mi.ItemVersion == Constants.ChangeGroupGenericVersionNumber select mi); RTMigrationItem targetItem; if (targetItemQuery.Count() > 0) { targetItem = targetItemQuery.First(); targetMigrationItemExists = true; } else { targetItem = RTMigrationItem.CreateRTMigrationItem(0, migrationInstructionName, Constants.ChangeGroupGenericVersionNumber); targetItem.MigrationSource = deltaSideMigrationSource; targetMigrationItemExists = false; } // If both the source and target migration items exist in the DB, there is no need to create a duplicate conversion // history record, and attempting to do so will cause a constraint violation. if (!sourceMigrationItemExists || !targetMigrationItemExists) { // Create the conversion history entry RTConversionHistory conversionHistory = RTConversionHistory.CreateRTConversionHistory( DateTime.UtcNow, -1, true); conversionHistory.Comment = comment; var session = (from s in context.RTSessionConfigSet where s.SessionUniqueId == sessionId select s).First(); Debug.Assert(session != null, "Cannot find session in DB"); RTSessionRun sessionRun = (from sr in context.RTSessionRunSet where sr.Id == session.Id select sr).First(); Debug.Assert(sessionRun != null, "Cannot find session run in DB"); conversionHistory.SessionRun = sessionRun; conversionHistory.SourceMigrationSource = migrationSource; context.AddToRTConversionHistorySet(conversionHistory); RTItemRevisionPair pair = RTItemRevisionPair.CreateRTItemRevisionPair( sourceItem.Id, targetItem.Id); pair.LeftMigrationItem = sourceItem; pair.RightMigrationItem = targetItem; pair.ConversionHistory = conversionHistory; } // Create a new HistoryNotFoundConflict Resolution Rule context.TrySaveChanges(); } return(true); }
public Endpoint( MonitorWatcher watcher, RuntimeEntityModel context, RTSession rtSession, RTMigrationSource rtMigrationSource, bool isRightMigrationSource, RTMigrationSource peerMigrationSource) { m_monitorWatcher = watcher; // TODO: Consider moving all of this initialization code to a new EndpointContext class that contains everything that the // Poll() method needs to do its job, and then have MonitorWatcher.GetEndpoints() pass the EndpointContext object as the single // arg to this constructor. this.Context = context; this.RTMigrationSource = rtMigrationSource; this.IsRightMigrationSource = isRightMigrationSource; this.PeerRTMigrationSource = peerMigrationSource; BusinessModelManager businessModelManager = new BusinessModelManager(); if (rtSession.SessionGroup == null) { rtSession.SessionGroupReference.Load(); } Config = businessModelManager.LoadConfiguration(rtSession.SessionGroup.GroupUniqueId); if (Config == null) { throw new ApplicationException( String.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.SessionGroupNotFound, rtSession.SessionGroup.GroupUniqueId.ToString())); } // TODO: Modify ProdviderManager to take a constructor that does not require a Config and that just loads // all providers in the Plugins directory, then move this code up to the MonitorWatcher constructor and pass the // providerHandlers down as another argument to this constructor ProviderManager providerManager = new ProviderManager(Config); Dictionary <Guid, ProviderHandler> providerHandlers = providerManager.LoadProvider(new DirectoryInfo(Constants.PluginsFolderName)); ProviderHandler providerHandler; if (!providerHandlers.TryGetValue(this.RTMigrationSource.UniqueId, out providerHandler)) { throw new Exception(string.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.ProviderHandlerNotLoadedForMigrationSouce, this.RTMigrationSource.FriendlyName)); } Debug.Assert(providerHandler.Provider != null); SyncMonitorProvider = providerHandler.Provider.GetService(typeof(ISyncMonitorProvider)) as ISyncMonitorProvider; if (SyncMonitorProvider == null) { throw new NotImplementedException(string.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.ProviderDoesNotImplementISyncMonitor, providerHandler.ProviderName)); } // Find the Session object corresponding to the RTSession if (Config.SessionGroup != null && Config.SessionGroup.Sessions != null) { foreach (var aSession in Config.SessionGroup.Sessions.Session) { if (string.Equals(aSession.SessionUniqueId, rtSession.SessionUniqueId.ToString(), StringComparison.Ordinal)) { Session = aSession; break; } } } if (Session == null) { throw new Exception(string.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.SessionNotFoundForMigrationSource, rtSession.SessionGroup.GroupUniqueId.ToString(), RTMigrationSource.FriendlyName)); } Guid migrationSourceGuid = new Guid(isRightMigrationSource ? Session.RightMigrationSourceUniqueId : Session.LeftMigrationSourceUniqueId); Microsoft.TeamFoundation.Migration.BusinessModel.MigrationSource migrationSource = Config.GetMigrationSource(migrationSourceGuid); Session.MigrationSources.Add(migrationSourceGuid, migrationSource); var serviceContainer = new ServiceContainer(); serviceContainer.AddService(typeof(ITranslationService), new SyncMonitorTranslationService(Session)); // We pass null for the global Configuration to the ConfigurationService constructor because its not handy and not needed in this context serviceContainer.AddService(typeof(ConfigurationService), new ConfigurationService(null, Session, migrationSourceGuid)); SyncMonitorProvider.InitializeServices(serviceContainer); SyncMonitorProvider.InitializeClient(migrationSource); int filterPairIndex = IsRightMigrationSource ? 1 : 0; foreach (var filterPair in Session.Filters.FilterPair) { if (!filterPair.Neglect) { m_filterStrings.Add(VCTranslationService.TrimTrailingPathSeparator(filterPair.FilterItem[filterPairIndex].FilterString)); } } }
public OneWaySessionViewModel(RTSessionConfig session, RTMigrationSource source, RTMigrationSource target) { Session = session; Source = source; Target = target; }
public LightWeightSource(RTMigrationSource source) { FriendlyName = source.FriendlyName; UniqueId = source.UniqueId; }
public MigrationSourceViewModel(RTMigrationSource migrationSource) { m_migrationSource = migrationSource; }
/// <summary> /// Get a list of migration sources and their high water marks from the database /// </summary> /// <returns></returns> private Dictionary <string, Endpoint> GetActiveEndpoints(RuntimeEntityModel context) { // TODO: Once a session completes, we should report one more row in LATENCY_DATA that shows that there is no // longer any backlog. This means that we need to save the list of endPoints from the previous call to EndPoints // and include them as well as the ones that are currently active. int sessionsBeingMonitored = 0; Dictionary <string, Endpoint> endpoints = new Dictionary <string, Endpoint>(); // Find all the sessions that are not in the Completed State var sessionQuery = (from rtSession in context.RTSessionSet where rtSession.State != (int)BusinessModelManager.SessionStateEnum.Completed select rtSession); foreach (RTSession rtSession in sessionQuery) { // For a uni-directional migration or sync, we only want to monitor the source side // so we need to determine the WorkflowType rtSession.SessionGroupReference.Load(); Debug.Assert(rtSession.SessionGroup != null); bool isUniDirectional = IsSessionUniDirectional(context, rtSession.SessionGroup); rtSession.LeftMigrationSourceReference.Load(); Debug.Assert(rtSession.LeftMigrationSource != null); rtSession.RightMigrationSourceReference.Load(); Debug.Assert(rtSession.RightMigrationSource != null); bool sessionEndpointAdded = false; bool isRightMigrationSource = false; RTMigrationSource[] migrationSources; if (isUniDirectional) { migrationSources = new RTMigrationSource[1] { rtSession.LeftMigrationSource }; } else { migrationSources = new RTMigrationSource[2] { rtSession.LeftMigrationSource, rtSession.RightMigrationSource }; } foreach (RTMigrationSource migrationSource in migrationSources) { try { if (migrationSource == null) { LogError(String.Format(CultureInfo.InvariantCulture, "Session {0} found with a null value for the {1} migration source (ignoring)", rtSession.SessionUniqueId, isRightMigrationSource ? "right" : "left")); continue; } LogVerbose(String.Format(CultureInfo.InvariantCulture, "Found active migration source '{0}' for session with Id: {1}", migrationSource.FriendlyName, rtSession.SessionUniqueId)); RTMigrationSource peerMigrationSource = isRightMigrationSource ? rtSession.LeftMigrationSource : rtSession.RightMigrationSource; Endpoint endpoint = new Endpoint(this, context, rtSession, migrationSource, isRightMigrationSource, peerMigrationSource); if (endpoints.ContainsKey(endpoint.UniqueId)) { LogWarning("Skipping endpoint with same Id as endpoint previously found: " + endpoint.UniqueId); continue; } endpoints.Add(endpoint.UniqueId, endpoint); if (!sessionEndpointAdded) { sessionsBeingMonitored++; sessionEndpointAdded = true; } LogVerbose(String.Format(CultureInfo.InvariantCulture, "Successfully initialized monitoring for migration source '{0}'", migrationSource.FriendlyName)); } catch (NotImplementedException) { // It's OK for an adapter to not implement the ISyncMonitorProvider interface LogInfo(String.Format(CultureInfo.InvariantCulture, "Skipping monitoring for endpoint '{0}' because the adapter does not implement the ISyncMonitorProvider interface", migrationSource.FriendlyName)); } catch (Exception ex) { LogWarning(String.Format(CultureInfo.InvariantCulture, "Unable to setup monitoring for endpoint '{0}': {1}", migrationSource.FriendlyName, ex.ToString())); } // Will be true 2nd time through foreach for the session.RightMigrationSource isRightMigrationSource = true; } } if (endpoints.Count > 0) { LogInfo(String.Format(CultureInfo.InvariantCulture, MigrationToolkitResources.SyncMonitorCollectingBacklogData, endpoints.Count, sessionsBeingMonitored)); } else { LogVerbose(MigrationToolkitResources.SyncMonitorNoActiveSessions); } return(endpoints); }