private void generateSnapshotForVCSession()
{
foreach (var setting in m_configurationService.VcCustomSetting.Settings.Setting)
{
if (setting.SettingKey == "SnapshotStartPoint")
{
m_sessionLevelSnapshotTime = parseSnapShotStartPoint(setting.SettingValue);
}
}
m_hwmDelta.Reload();
if (m_hwmDelta.Value >= m_sessionLevelSnapshotTime)
{
// We've already passed snapshot changeset Id, just return.
m_sessionlevelSnapshotCompleted = true;
return;
}
ChangeGroup snapshotGroup = createChangeGroupForSnapshot(m_sessionLevelSnapshotTime, 0);
m_clearCaseServer.SetConfigSpecForSnapshotStartPoint(m_sessionLevelSnapshotTime);
try
{
foreach (MappingEntry mappingEntry in m_configurationService.Filters)
{
if (mappingEntry.Cloak)
{
continue;
}
string localMappingPath = m_clearCaseServer.GetViewLocalPathFromServerPath(mappingEntry.Path);
foreach (string subDirectory in Directory.GetDirectories(localMappingPath, "*", SearchOption.AllDirectories))
{
createAddActionForSnapshot(snapshotGroup, subDirectory, true);
}
foreach (string subFile in Directory.GetFiles(localMappingPath, "*", SearchOption.AllDirectories))
{
createAddActionForSnapshot(snapshotGroup, subFile, false);
}
}
}
finally
{
m_clearCaseServer.ResetConfigSpec();
}
snapshotGroup.Save();
m_hwmDelta.Update(m_sessionLevelSnapshotTime);
m_changeGroupService.PromoteDeltaToPending();
m_sessionlevelSnapshotCompleted = true;
}
/// <summary>
/// 1. Read snapshot information from configuration.
/// 2. Populate the 2 in-memory snapshot table
/// </summary>
private void initializeSnapshotTable()
{
m_hwmDelta.Reload();
// Read snapshot information from configuration.
foreach (MappingEntry mappingEntry in ConfigurationService.Filters)
{
if ((!string.IsNullOrEmpty(mappingEntry.SnapshotStartPoint)) && !mappingEntry.Cloak)
{
int snapshotChangeset;
try
{
snapshotChangeset = int.Parse(mappingEntry.SnapshotStartPoint);
int peerSnapshotChangeset;
if (int.TryParse(mappingEntry.PeerSnapshotStartPoint, out peerSnapshotChangeset))
{
// create conversion history
ConversionResult convRslt = new ConversionResult(ConfigurationService.SourceId, ConfigurationService.MigrationPeer);
convRslt.ChangeId = mappingEntry.PeerSnapshotStartPoint;
convRslt.ItemConversionHistory.Add(new ItemConversionHistory(mappingEntry.SnapshotStartPoint, string.Empty, convRslt.ChangeId, string.Empty));
try
{
convRslt.Save(ConfigurationService.SourceId);
}
catch (System.Data.DataException)
{
// conversion history already updated
}
continue;
}
}
catch (Exception e)
{
throw new MigrationException(
string.Format(TfsVCAdapterResource.Culture, TfsVCAdapterResource.PathSnapShotFormatError, mappingEntry.SnapshotStartPoint),
e);
}
if (snapshotChangeset < m_hwmDelta.Value)
{
m_processedSnapShotChangeset.Add(mappingEntry.Path, snapshotChangeset);
}
else
{
m_unprocessedSnapshotChangeset.Add(mappingEntry.Path, snapshotChangeset);
}
}
}
}
/// <summary>
/// Generates the delta table.
/// </summary>
public override void GenerateDeltaTable()
{
string viewName = this.configurationService.Filters[0].Path;
TraceManager.TraceInformation("WSSWIT:AP:GenerateDeltaTable:View - {0}", viewName);
highWaterMarkDelta.Reload();
GetSharePointTaskUpdates(viewName);
highWaterMarkDelta.Update(DateTime.Now);
changeGroupService.PromoteDeltaToPending();
}
private void initializeDestinationTfsClient()
{
try
{
m_destinationTfs = VersionSpecificUtils.GetVersionControlServer(ConfigurationService.PeerServerUrl);
if (m_hwmLastSyncedTfsChangeset != null)
{
ConfigurationService.RegisterHighWaterMarkWithSession(m_hwmLastSyncedTfsChangeset);
m_hwmLastSyncedTfsChangeset.Reload();
if (m_hwmLastSyncedTfsChangeset.Value < 1)
{
m_hwmLastSyncedTfsChangeset.Update(1);
}
}
}
catch (Exception ex)
{
// The destination must be a TFS server.
throw new MigrationException(string.Format(TfsFileSystemResources.ErrorConnectingTargetTfsServer, ex.Message), ex);
}
}
/// <summary>
/// Generate the delta table.
/// </summary>
public override void GenerateDeltaTable()
{
TraceManager.TraceInformation("WSSVC:AP:GenerateDeltaTable");
highWaterMarkDelta.Reload();
TraceManager.TraceInformation("\tWSSVC:AP:Initial HighWaterMark {0} ", highWaterMarkDelta.Value);
deltaTableStartTime = DateTime.Now;
TraceManager.TraceInformation("\tWSSVC:AP:CutOff {0} ", deltaTableStartTime);
GetSharePointUpdates();
highWaterMarkDelta.Update(deltaTableStartTime);
TraceManager.TraceInformation("\tWSSVC:AP:Updated HighWaterMark {0} ", highWaterMarkDelta.Value);
changeGroupService.PromoteDeltaToPending();
}
public override void GenerateDeltaTable()
{
TraceManager.TraceInformation("POC:AP:GenerateDeltaTable");
m_hwmDelta.Reload();
TraceManager.TraceInformation(" POC:HighWaterMark {0} ", m_hwmDelta.Value);
deltaTableStartTime = DateTime.Now;
TraceManager.TraceInformation(" POC:CutOff {0} ", deltaTableStartTime);
ReadOnlyCollection <MappingEntry> filters = ConfigurationService.Filters;
GetPocUpdates(filters[0].Path);
m_hwmDelta.Update(deltaTableStartTime);
m_changeGroupService.PromoteDeltaToPending();
}
public override bool ProceedToAnalysis(AnalysisContext analysisContext)
{
m_semaphoreFileTouchedTime = GetSemaphoreFileTouchedTime();
m_hwmSemaphoreFile.Reload();
if (m_semaphoreFileTouchedTime > m_hwmSemaphoreFile.Value)
{
// Persisted DateTime is rounded down to the nearest second in the DB. Add
// a second to the HWM to make sure we don't take changes due to shaved milliseconds.
TimeSpan oneSecond = new TimeSpan(0, 0, 1);
m_hwmSemaphoreFile.Update(m_semaphoreFileTouchedTime + oneSecond);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Generate the delta table
/// </summary>
public void GenerateDeltaTable()
{
// Load the current high water mark from any previous run of this session
m_hwmDelta.Reload();
m_renameList = null;
m_renameListUpdated = false;
// Removing the in-progress change groups created by this side (fils system)
m_changeGroupService.RemoveInProgressChangeGroups();
if (m_changeGroupService.GetInProgressMigrationInstructionCount() > 0)
{
// If there are in-progress migration instructions translated from the other side, mark this delta table as contentcon flict detection only.
m_contentConflictDetectionOnly = true;
TraceManager.TraceInformation("Migration instruction in progress, the delta table will be generated for content conflict detection only");
}
else
{
m_contentConflictDetectionOnly = false;
}
DateTime newHighWaterMarkTime = DateTime.Now;
List <String> pathsToBeVerified = new List <String>();
int versionToBeSynced = 0;
// In a two-way sync, versionToBeSynced is set to the last sync point - either the latest changeset migrated from TFS or the latest changeset migrated to TFS
// In one way sync, versionToBeSynced is always set to the GetLatestChangesetId of TFS
if (m_hwmLastSyncedTfsChangeset != null)
{
// m_hwmLastSyncedTfsChangeset is the latest TFS changeset migrated to the file system side.
// This highwater mark will be set when TfsFileSystemAnalysisProvider is combined with another provider to form a two-way sync.
m_hwmLastSyncedTfsChangeset.Reload();
// m_lastHighWaterMarkMigratedToPeer is the latest TFS changeset migrated from this TfsFileSystemAnalysisProvider.
m_lastHighWaterMarkMigratedToPeer.Reload();
versionToBeSynced = m_lastHighWaterMarkMigratedToPeer.Value > m_hwmLastSyncedTfsChangeset.Value ?
m_lastHighWaterMarkMigratedToPeer.Value : m_hwmLastSyncedTfsChangeset.Value;
}
else
{
versionToBeSynced = m_destinationTfs.GetLatestChangesetId();
}
FileSystemVerifier fileSystemVerifier = new FileSystemVerifier();
ChangeGroup changeGroup = m_changeGroupService.CreateChangeGroupForDeltaTable(DateTime.Now.ToString());
populateChangeGroupMetaData(changeGroup);
foreach (MappingEntry m in ConfigurationService.Filters)
{
if (m.Cloak)
{
continue;
}
string canonicalPath = removeTrailingSlash(m.Path);
fileSystemVerifier.AddPathForVerification(canonicalPath);
analyzeFolder(canonicalPath, versionToBeSynced, changeGroup);
}
if (!fileSystemVerifier.Verify())
{
TraceManager.TraceError(
"Analysis failed as the local file system state was changed during the analysis phase. No changes were created.");
markChangeGroupAsObsolete(changeGroup);
return;
}
if (changeGroup.Actions.Count > 0)
{
// We only want to promote deltas to pending if we actually created and saved a change group.
changeGroup.Save();
m_changeGroupService.PromoteDeltaToPending();
}
else
{
markChangeGroupAsObsolete(changeGroup);
}
m_lastTfsChangesetAnalyzed.Update(versionToBeSynced);
m_hwmDelta.Update(newHighWaterMarkTime);
TraceManager.TraceInformation(String.Format(CultureInfo.InvariantCulture,
TfsFileSystemResources.UpdatedHighWaterMark, newHighWaterMarkTime));
}
public void GenerateDeltaTable()
{
try
{
if (!m_isLoginUserSQLEditor)
{
ValidateIsSQLEditor();
m_isLoginUserSQLEditor = true;
}
// load high watermark; as for CQ, we store local time for queries
m_hwmDelta.Reload();
DateTime hwmDeltaValue = m_hwmDelta.Value;
if (hwmDeltaValue.Equals(default(DateTime)))
{
hwmDeltaValue = new DateTime(1900, 1, 1);
}
hwmDeltaValue = hwmDeltaValue.AddSeconds(-1); // go back 1 second as we'll drop the millisec below
m_migrationContext.CurrentHWMBaseLine = hwmDeltaValue;
// HACK HACK HACK
//string hwmDeltaValueStr = hwmDeltaValue.ToString("o"); // using "ISO 8601" DateTime string format
string hwmDeltaValueStr = hwmDeltaValue.ToString("u").Replace("Z", ""); // using "ISO 8601" DateTime string format
if (hwmDeltaValueStr.LastIndexOf('.') >= 0)
{
hwmDeltaValueStr = hwmDeltaValueStr.Substring(0, hwmDeltaValueStr.LastIndexOf('.')); // drop the millisec
}
// HACK HACK HACK
DateTime newHwmValue = DateTime.Now;
foreach (CQRecordFilter filter in m_filters)
{
ComputeDeltaPerRecordType(filter, hwmDeltaValueStr);
}
// persist results and hwm
TraceManager.TraceInformation("Promote delta to pending.");
m_changeGroupService.PromoteDeltaToPending();
m_hwmDelta.Update(newHwmValue);
TraceManager.TraceInformation("Persisted CQ HWM: {0}", ClearQuestConstants.CqRecordHwm);
TraceManager.TraceInformation("Updated CQ HWM: {0}", newHwmValue.ToString());
}
catch (ClearQuestInsufficientPrivilegeException privEx)
{
ConflictResolutionResult rslt = UtilityMethods.HandleInsufficientPriviledgeException(privEx, m_conflictManagerService);
if (rslt.Resolved)
{
// todo: currently not expected, as we only enabled manual/skip resolution action
}
}
catch (ClearQuestCOMDllNotFoundException cqComNotFoundEx)
{
UtilityMethods.HandleCOMDllNotFoundException(cqComNotFoundEx, ErrorManager, m_conflictManagerService);
}
catch (ClearQuestCOMCallException cqComCallEx)
{
UtilityMethods.HandleCQComCallException(cqComCallEx, ErrorManager, m_conflictManagerService);
}
catch (Exception ex)
{
ErrorManager errMgr = null;
if (m_analysisServiceContainer != null)
{
errMgr = m_analysisServiceContainer.GetService(typeof(ErrorManager)) as ErrorManager;
}
UtilityMethods.HandleGeneralException(ex, errMgr, m_conflictManagerService);
}
}
public virtual ReadOnlyCollection <LinkChangeGroup> GenerateNextLinkDeltaSlice(
LinkService linkService,
int maxDeltaSliceSize)
{
try
{
var linkChangeGroups = new List <LinkChangeGroup>();
if (null == ExtractLinkChangeActionsCallback)
{
return(linkChangeGroups.AsReadOnly());
}
// load main Highwater Mark
m_hwmLink.Reload();
DateTime hwmLinkValue = m_hwmLink.Value;
string hwmLinkValueStr = hwmLinkValue.ToString(CultureInfo.InvariantCulture);
// load Work Items for extracting links
string sourceId = m_migrationSource.UniqueId;
string storeName = m_migrationSource.WorkItemStore.StoreName;
// Get items based on primary Highwater Mark
TraceManager.TraceInformation(TfsWITAdapterResources.GettingModifiedItems, sourceId, storeName);
IEnumerable <TfsMigrationWorkItem> items = m_migrationSource.WorkItemStore.GetItems(ref hwmLinkValueStr);
TraceManager.TraceInformation(TfsWITAdapterResources.ReceivedModifiedItems, sourceId, storeName);
// Record the updated HWM value
DateTime newHwmLinkValue = Convert.ToDateTime(hwmLinkValueStr, CultureInfo.InvariantCulture);
// store to be used to analyze deleted links
WorkItemLinkStore store = new WorkItemLinkStore(new Guid(sourceId));
// extract links
var inMaxDeltaSliceSize = maxDeltaSliceSize;
foreach (TfsMigrationWorkItem tfsMigrationWorkItem in items)
{
if (tfsMigrationWorkItem.WorkItem == null)
{
continue;
}
TraceManager.TraceInformation("Generating linking delta for Work Item: {0}", tfsMigrationWorkItem.WorkItem.Id.ToString());
var perWorkItemlinkChangeGroups = new List <LinkChangeGroup>();
ExtractLinkChangeActionsCallback(tfsMigrationWorkItem, perWorkItemlinkChangeGroups, store);
if (perWorkItemlinkChangeGroups.Count == 0)
{
TraceManager.TraceInformation("Number of links: {0}", 0);
continue;
}
LinkChangeGroup consolidatedLinkChangeGroup = perWorkItemlinkChangeGroups[0];
for (int i = 1; i < perWorkItemlinkChangeGroups.Count; ++i)
{
foreach (LinkChangeAction action in perWorkItemlinkChangeGroups[i].Actions)
{
consolidatedLinkChangeGroup.AddChangeAction(action);
}
}
TraceManager.TraceInformation("Number of links: {0}", consolidatedLinkChangeGroup.Actions.Count.ToString());
// VERY IMPORTANT: use the RelatedArtifactsStore to detect link deletion
store.UpdatePerItemLinkChangeGroupsByCheckingRelatedItemRecords(
tfsMigrationWorkItem.Uri, consolidatedLinkChangeGroup, this);
if (consolidatedLinkChangeGroup.Actions.Count > 0)
{
linkChangeGroups.Add(consolidatedLinkChangeGroup);
}
maxDeltaSliceSize -= consolidatedLinkChangeGroup.Actions.Count;
if (maxDeltaSliceSize <= 0)
{
// size limit reached - persist groups to DB
linkService.AddChangeGroups(linkChangeGroups);
linkChangeGroups.Clear();
maxDeltaSliceSize = inMaxDeltaSliceSize;
}
}
// persist remaining groups to DB
linkService.AddChangeGroups(linkChangeGroups);
// clean up the returned link change group collection
// when the caller (toolkit) receives an empty collection, it understands there is no more
// delta to generate for the moment, and proceeds to next phase
linkChangeGroups.Clear();
// update primary Highwater Mark
m_hwmLink.Update(newHwmLinkValue);
TraceManager.TraceInformation("Persisted WIT linking HWM: {0}", Toolkit.Constants.HwmDeltaLink);
TraceManager.TraceInformation(TfsWITAdapterResources.UpdatedHighWatermark, hwmLinkValueStr);
return(linkChangeGroups.AsReadOnly());
}
catch (Exception exception)
{
ErrorManager errMgr = m_serviceContainer.GetService(typeof(ErrorManager)) as ErrorManager;
errMgr.TryHandleException(exception);
return(new List <LinkChangeGroup>().AsReadOnly());
}
}
public ChangeSummary GetSummaryOfChangesSince(string lastProcessedChangeItemId, List <string> filterStrings)
{
ChangeSummary changeSummary = new ChangeSummary();
changeSummary.ChangeCount = 0;
changeSummary.FirstChangeModifiedTimeUtc = DateTime.MinValue;
// Now find all history records for changes since the High Water Mark
m_hwmDelta.Reload();
DateTime since = m_hwmDelta.Value;
List <CCHistoryRecord> historyRecordList = m_clearCaseServer.GetHistoryRecords(m_configurationService.Filters, since, false);
long lastProcessedEventId;
try
{
lastProcessedEventId = long.Parse(lastProcessedChangeItemId);
}
catch (FormatException)
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture,
CCResources.InvalidChangeItemIdFormat, lastProcessedChangeItemId));
}
CCHistoryRecord nextHistoryRecordToBeMigrated = null;
// Of all of the history records since the HWM, find the oldest one (based on EventId which increases over time)
foreach (CCHistoryRecord historyRecord in historyRecordList)
{
// We only want to count history records with OperationTypes of Checkin and Rmname for the backlog,
// not individual element operation or other operations such as mklabel that are not processed by the ClearCaseAnalysisProvider
// *** NOTE: If the ClearCaseAnalysisProvider is changed to process other OperationTypes, this code needs to change as well ***
// TODO: Should we create a common static list of processed OperationTypes so that there is just one place to update?
if (historyRecord.EventId > lastProcessedEventId &&
(historyRecord.OperationType == OperationType.Checkin || historyRecord.OperationType == OperationType.Rmname))
{
// Don't count DirectoryVersion check-in records in the backlog as these may produce false positives in the backlog
if (!string.Equals(historyRecord.OperationDescription, OperationDescription.DirectoryVersion, StringComparison.Ordinal))
{
changeSummary.ChangeCount++;
if (nextHistoryRecordToBeMigrated == null || historyRecord.EventId < nextHistoryRecordToBeMigrated.EventId)
{
nextHistoryRecordToBeMigrated = historyRecord;
}
/* Uncomment for debugging
* Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
* "CCSyncMonitorProvider including backlog item for history record: EventId: {0}, OperationType: {1}, AbsoluteVobPath: {2}, VersionTime: {3}",
* historyRecord.EventId, historyRecord.OperationType, historyRecord.AbsoluteVobPath, historyRecord.VersionTime));
*/
}
}
}
if (nextHistoryRecordToBeMigrated != null)
{
changeSummary.FirstChangeModifiedTimeUtc = nextHistoryRecordToBeMigrated.VersionTime.ToUniversalTime();
}
return(changeSummary);
}
private void SetServerLinkChangeIds(List <LinkChangeAction> linkChangeActions)
{
if (linkChangeActions.Count == 0)
{
return;
}
m_hwmSubmittedLinkChangeId.Reload();
long hwmSubmittedValue = m_hwmSubmittedLinkChangeId.Value;
Dictionary <int, List <LinkChangeAction> > linkChangeActionsByLowerId = new Dictionary <int, List <LinkChangeAction> >();
foreach (LinkChangeAction action in linkChangeActions)
{
int workItemIdKey = GetLowerWorkItemId(action);
if (!linkChangeActionsByLowerId.ContainsKey(workItemIdKey))
{
linkChangeActionsByLowerId.Add(workItemIdKey, new List <LinkChangeAction>());
}
linkChangeActionsByLowerId[workItemIdKey].Add(action);
}
/*
* TraceManager.TraceVerbose(String.Format(
* "SetServerLinkChangeIds calling WorkItemServer.GetWorkItemLinkChanges to find Ids for {0} successful link actions starting with RowNumber {1}",
* linkChangeActions.Count, hwmSubmittedValue));
*/
Stopwatch stopwatch = Stopwatch.StartNew();
int serverLinkChangeIdsSet = 0;
foreach (WorkItemLinkChange linkChange in WorkItemServer.GetWorkItemLinkChanges(Guid.NewGuid().ToString(), hwmSubmittedValue))
{
int linkChangeKey = GetLowerWorkItemId(linkChange);
List <LinkChangeAction> actions;
if (linkChangeActionsByLowerId.TryGetValue(linkChangeKey, out actions))
{
foreach (LinkChangeAction action in actions)
{
if (LinkChangeMatchesLinkAction(linkChange, action))
{
action.ServerLinkChangeId = linkChange.RowVersion.ToString();
serverLinkChangeIdsSet++;
hwmSubmittedValue = linkChange.RowVersion;
// Don't break here because there could be more than one LinkChangeAction in the list that matches the WorkItemLinkChange
// break;
}
}
}
}
stopwatch.Stop();
TraceManager.TraceVerbose("Time to call GetWorkItemLinkChanges() and process return values: {0} seconds", stopwatch.Elapsed.TotalSeconds);
if (serverLinkChangeIdsSet < linkChangeActions.Count)
{
// Look for any LinkChangeActions that did not get the ServerLinkChangeId set
foreach (LinkChangeAction linkChangeAction in linkChangeActions)
{
if (linkChangeAction.ServerLinkChangeId == null)
{
string msg = String.Format(
"Unable to set ServerLinkChangeId on at least one LinkChangeAction: {0} '{1}'->'{2}' ({3})",
linkChangeAction.ChangeActionId == WellKnownChangeActionId.Add ? "Add" : "Delete",
linkChangeAction.Link.SourceArtifact.Uri, linkChangeAction.Link.TargetArtifact.Uri, linkChangeAction.Link.LinkType.ReferenceName);
TraceManager.TraceWarning(msg);
break;
}
}
}
/*
* else
* {
* TraceManager.TraceVerbose(String.Format("SetServerLinkChangeIds set values for {0} link actions ending with RowNumber {1}",
* serverLinkChangeIdsSet, hwmSubmittedValue));
* }
*/
m_hwmSubmittedLinkChangeId.Update(hwmSubmittedValue);
TraceManager.TraceInformation("Persisted WIT linking sequence HWM: {0} (MigrationSourceId: {1})",
TfsConstants.HwmSubmittedLinkChangeId, m_hwmSubmittedLinkChangeId.SourceUniqueId.ToString());
TraceManager.TraceInformation(TfsWITAdapterResources.UpdatedHighWatermark, hwmSubmittedValue);
}
private void generateSnapshotForVCSession()
{
foreach (var setting in m_configurationService.VcCustomSetting.Settings.Setting)
{
if (setting.SettingKey == "SnapshotStartPoint")
{
m_sessionLevelSnapshotTime = parseSnapShotStartPoint(setting.SettingValue);
}
}
m_hwmDelta.Reload();
if (m_hwmDelta.Value >= m_sessionLevelSnapshotTime)
{
// We've already passed snapshot changeset Id, just return.
m_sessionlevelSnapshotCompleted = true;
return;
}
ChangeGroup snapshotGroup = createChangeGroupForSnapshot(m_sessionLevelSnapshotTime, 0);
m_clearCaseServer.SetConfigSpecForSnapshotStartPoint(m_sessionLevelSnapshotTime);
try
{
foreach (MappingEntry mappingEntry in m_configurationService.Filters)
{
if (mappingEntry.Cloak)
{
continue;
}
string localMappingPath = m_clearCaseServer.GetViewLocalPathFromServerPath(mappingEntry.Path);
foreach (string subDirectory in Directory.GetDirectories(localMappingPath, "*", SearchOption.AllDirectories))
{
string serverPath = m_clearCaseServer.GetServerPathFromViewLocalPath(subDirectory);
snapshotGroup.CreateAction(
WellKnownChangeActionId.Add,
new ClearCaseMigrationItem(
m_clearCaseServer.ViewName,
m_clearCaseServer.ApplicationClass.get_Element(serverPath).Version.ExtendedPath,
true),
null,
serverPath,
null,
null,
WellKnownContentType.VersionControlledFolder.ReferenceName,
null);
}
foreach (string subFile in Directory.GetFiles(localMappingPath, "*", SearchOption.AllDirectories))
{
string serverPath = m_clearCaseServer.GetServerPathFromViewLocalPath(subFile);
snapshotGroup.CreateAction(
WellKnownChangeActionId.Add,
new ClearCaseMigrationItem(
m_clearCaseServer.ViewName,
m_clearCaseServer.ApplicationClass.get_Element(serverPath).Version.ExtendedPath,
true),
null,
serverPath,
null,
null,
WellKnownContentType.VersionControlledFile.ReferenceName,
null);
}
}
}
finally
{
m_clearCaseServer.ResetConfigSpec();
}
snapshotGroup.Save();
m_hwmDelta.Update(m_sessionLevelSnapshotTime);
m_changeGroupService.PromoteDeltaToPending();
m_sessionlevelSnapshotCompleted = true;
}
private int[] getMappedSubversionChanges()
{
m_hwmDelta.Reload();
Debug.Assert(m_hwmDelta.Value >= 0, "High water mark of delta table must be non-negtive");
int latestChangeset = m_repository.GetLatestRevisionNumber();
if (m_hwmDelta.Value >= latestChangeset)
{
// No new changesets on server, return.
return(new int[0]);
}
int startingChangeset = m_hwmDelta.Value + 1;
string skipComment = m_configurationService.GetValue <string>(Constants.SkipComment, "**NOMIGRATION**");
var lookup = new HashSet <int>();
foreach (var mappedPath in m_configurationManager.MappedServerPaths)
{
var records = m_repository.QueryHistoryRange(mappedPath, startingChangeset, latestChangeset, false);
// Todo: Skip mirrored changes created by migration tool itself
//Iterate across all records and filter out those records that are already in the list
foreach (var record in records.Values)
{
//check wether we alredy have this record. If this is the case, we can simply continue with the next record
if (lookup.Contains(record.Revision))
{
continue;
}
//The skip comment is empty. Therefore we can skip the evaluation of the skip comment
if (!string.IsNullOrEmpty(skipComment))
{
if (record.Comment != null && record.Comment.Contains(skipComment))
{
//The record has the skip commnet. Just print an information and resume with the next one
TraceManager.TraceInformation("LogRecord {0} contains the skip comment {1}", record.Revision, skipComment);
continue;
}
}
//Add the record to the hashmap. We alredy verified that this is the first record
lookup.Add(record.Revision);
}
}
if (lookup.Count > 0)
{
int[] revisions = lookup.ToArray();
Array.Sort(revisions);
return(revisions);
}
else
{
// No new changesets are found, update the HWM as current latest
m_hwmDelta.Update(latestChangeset);
return(new int[0]);
}
}
private void queryHistory(ChangeGroupService changeGroupService)
{
m_hwmDelta.Reload();
DateTime since = m_hwmDelta.Value;
List <CCHistoryRecord> historyRecordList = m_clearCaseServer.GetHistoryRecords(m_configurationService.Filters, since, true);
historyRecordList.Sort();
CCVersion version;
CCItem currentItem = null;
CCItem previousLnItem = null;
string previousLnItemLeafName = null;
string previousMkElemItemPath = null;
List <CCHistoryRecord> processedRecordList = new List <CCHistoryRecord>();
foreach (CCHistoryRecord historyRecord in historyRecordList)
{
switch (historyRecord.OperationType)
{
case OperationType.Checkin:
version = m_clearCaseServer.ApplicationClass.get_Version(historyRecord.VersionExtendedPath);
currentItem = new CCItem(version, ClearCasePath.GetVobName(historyRecord.AbsoluteVobPath));
if (string.Equals(historyRecord.OperationDescription, OperationDescription.Version))
{
if (ClearCasePath.Equals(previousMkElemItemPath, currentItem.AbsoluteVobPath))
{
// File version checkin following a mkelem, create an Add
historyRecord.AbsoluteVobPath = currentItem.AbsoluteVobPath;
historyRecord.ChangeAction = WellKnownChangeActionId.Add;
historyRecord.IsDirectory = version.IsDirectory;
processedRecordList.Add(historyRecord);
previousMkElemItemPath = null;
}
else
{
// File version checkin following a mkelem, create an Edit
historyRecord.AbsoluteVobPath = currentItem.AbsoluteVobPath;
historyRecord.ChangeAction = WellKnownChangeActionId.Edit;
historyRecord.IsDirectory = version.IsDirectory;
processedRecordList.Add(historyRecord);
}
}
else if (string.Equals(historyRecord.OperationDescription, OperationDescription.DirectoryVersion) &&
(ClearCasePath.Equals(previousMkElemItemPath, currentItem.AbsoluteVobPath)))
{
// Directory version checkin following a mkelem, create an Add
historyRecord.AbsoluteVobPath = currentItem.AbsoluteVobPath;
historyRecord.ChangeAction = WellKnownChangeActionId.Add;
historyRecord.IsDirectory = version.IsDirectory;
processedRecordList.Add(historyRecord);
previousMkElemItemPath = null;
}
break;
case OperationType.Mkattr:
case OperationType.Mkpool:
case OperationType.Mkreplica:
case OperationType.Mktype:
// ToDo
// writeHistoryRecord(historyFields);
break;
case OperationType.Lnname:
version = m_clearCaseServer.ApplicationClass.get_Version(historyRecord.VersionExtendedPath);
currentItem = new CCItem(version, ClearCasePath.GetVobName(historyRecord.AbsoluteVobPath));
previousLnItem = currentItem;
previousLnItemLeafName = ClearCaseEventSpec.ParseLnNameComment(historyRecord.Comment);
break;
case OperationType.Mkbranch:
// ToDo
if (string.Equals(historyRecord.OperationDescription, OperationDescription.Version) ||
string.Equals(historyRecord.OperationDescription, OperationDescription.DirectoryVersion))
{
/*version = m_clearCaseServer.ApplicationClass.get_Version(historyRecord.VersionExtendedPath);
* currentItem = new CCItem(version, vob);
* historyRecord.AbsoluteVobPath = currentItem.AbsoluteVobPath;
* historyRecord.ChangeAction = WellKnownChangeActionId.Add;
* historyRecord.IsDirectory = version.IsDirectory;
* historyRecordList.Add(historyRecord);
* */
}
break;
case OperationType.Mkelem:
if (string.Equals(historyRecord.OperationDescription, OperationDescription.DirectoryElement))
{
// Todo
/*if (currentState == OperationState.Initialized)
* {
* currentState = OperationState.CreateDirectoryElement;
* currentItem = new Item(historyFields[1], ItemType.Element, m_vobName);
* }
* else
* {
* logStateTransitionError(currentState, operationType, operationDescription);
* }*/
}
else if (string.Equals(historyRecord.OperationDescription, OperationDescription.Branch))
{
// Todo
/*
* if ((currentState == OperationState.AddDirectoryToParent)
|| (currentState == OperationState.CreateDirectoryElement))
||{
|| currentState = OperationState.CreateDirectoryBranch;
|| currentItem = new Item(historyFields[1], ItemType.Branch, m_vobName);
||}
||else
||{
|| logStateTransitionError(currentState, operationType, operationDescription);
||}
* */
}
else if (string.Equals(historyRecord.OperationDescription, OperationDescription.DirectoryVersion) ||
string.Equals(historyRecord.OperationDescription, OperationDescription.Version))
{
version = m_clearCaseServer.ApplicationClass.get_Version(historyRecord.VersionExtendedPath);
currentItem = new CCItem(version, ClearCasePath.GetVobName(historyRecord.AbsoluteVobPath));
previousMkElemItemPath = currentItem.AbsoluteVobPath;
//if (currentState == OperationState.CreateDirectoryBranch)
//{
/*version = m_clearCaseServer.ApplicationClass.get_Version(historyFields[1]);
* currentItem = new Item(version, vob);
* if (IsPathMapped(currentItem.AbsoluteVobPath) &&
* IsOurChange(ClearCasePath.removeViewLocationFromVersion(version.ExtendedPath, m_clearCaseServer.ViewRootPath)))
* {
* createMigrationAction(
* version,
* null,
* currentItem.AbsoluteVobPath,
* versionTime,
* WellKnownChangeActionId.Add,
* version.IsDirectory);
* }*/
// Verify the version to be 0
//currentState = OperationState.Initialized;
//}
//else
//{
// logStateTransitionError(currentState, operationType, operationDescription);
//}
}
else
{
//logStateTransitionError(currentState, operationType, operationDescription);
}
break;
case OperationType.Mkhlink:
// ToDo
// writeHistoryRecord(historyFields);
break;
case OperationType.Mklabel:
break;
case OperationType.Rmname:
bool isDirectory;
string rmItemName = ClearCaseEventSpec.ParseRmNameComment(historyRecord.Comment, out isDirectory);
if (rmItemName == null)
{
TraceManager.TraceWarning(String.Format("Skipping rmname operation: Unable to determine element type from history record comment: '{0}'", historyRecord.Comment));
continue;
}
version = m_clearCaseServer.ApplicationClass.get_Version(historyRecord.VersionExtendedPath);
currentItem = new CCItem(version, ClearCasePath.GetVobName(historyRecord.AbsoluteVobPath));
if (currentItem.Equals(previousLnItem))
{
historyRecord.AbsoluteVobPath = ClearCasePath.Combine(currentItem.AbsoluteVobPath, previousLnItemLeafName);
historyRecord.AbsoluteVobPathFrom = ClearCasePath.Combine(currentItem.AbsoluteVobPath, rmItemName);
historyRecord.ChangeAction = WellKnownChangeActionId.Rename;
historyRecord.IsDirectory = isDirectory;
processedRecordList.Add(historyRecord);
previousLnItem = null;
previousLnItemLeafName = null;
// todo, path not mapped exception
}
else
{
// delete operation
historyRecord.AbsoluteVobPath = ClearCasePath.Combine(currentItem.AbsoluteVobPath, rmItemName);
historyRecord.ChangeAction = WellKnownChangeActionId.Delete;
historyRecord.IsDirectory = isDirectory;
processedRecordList.Add(historyRecord);
}
break;
case OperationType.Undefined:
break;
case OperationType.Mkvob:
// Add of Vob itself.
// ToDo
// writeHistoryRecord(historyFields);
default:
break;
}
}
reviseHistoryRecordsForRename(processedRecordList);
m_hwmEventId.Reload();
long lastProcessedEventId = m_hwmEventId.Value;
foreach (CCHistoryRecord historyRecord in processedRecordList)
{
if (historyRecord.EventId <= lastProcessedEventId)
{
// The event has been processed in previous sync.
TraceManager.TraceInformation("Skipping history record because the event was processed in a previous sync pass of this session");
continue;
}
if (Utils.IsOurChange(historyRecord))
{
TraceManager.TraceInformation("Skipping history record because it represents a change migrated by the Integration Platform");
continue;
}
if (Utils.IsPathMapped(historyRecord.AbsoluteVobPath, m_configurationService))
{
if (historyRecord.ChangeAction == WellKnownChangeActionId.Rename)
{
if (Utils.IsPathMapped(historyRecord.AbsoluteVobPathFrom, m_configurationService))
{
m_currentChangeGroup = createMigrationAction(historyRecord, historyRecord.ChangeAction);
}
else
{
// ToDo Path not mapped conflict
m_currentChangeGroup = createMigrationAction(historyRecord, WellKnownChangeActionId.Add);
}
}
else
{
m_currentChangeGroup = createMigrationAction(historyRecord, historyRecord.ChangeAction);
}
}
else
{
// ToDo path not mapped conflict
if ((historyRecord.ChangeAction == WellKnownChangeActionId.Rename) && (Utils.IsPathMapped(historyRecord.AbsoluteVobPathFrom, m_configurationService)))
{
m_currentChangeGroup = createMigrationAction(historyRecord, WellKnownChangeActionId.Delete);
}
else
{
TraceManager.TraceWarning("Skipping history record because the path '{0}' is not mapped in a filter string", historyRecord.AbsoluteVobPath);
}
}
}
if (m_currentChangeGroup != null)
{
m_currentChangeGroup.Save();
}
if (processedRecordList.Count > 0)
{
m_hwmDelta.Update(processedRecordList.Last().VersionTime);
}
m_changeGroupService.PromoteDeltaToPending();
}
public ReadOnlyCollection <LinkChangeGroup> GenerateNextLinkDeltaSlice(
LinkService linkService,
int maxDeltaSliceSize)
{
try
{
var linkChangeGroups = new List <LinkChangeGroup>();
if (null == ExtractLinkChangeActionsCallback)
{
return(linkChangeGroups.AsReadOnly());
}
// load high watermark; as for CQ, we store local time for queries
m_hwmLink.Reload();
DateTime hwmDeltaValue = m_hwmLink.Value;
if (hwmDeltaValue.Equals(default(DateTime)))
{
hwmDeltaValue = new DateTime(1900, 1, 1);
}
hwmDeltaValue = hwmDeltaValue.AddSeconds(-1); // go back 1 second as we'll drop the millisec below
string hwmDeltaValueStr = hwmDeltaValue.ToString(m_migrationContext.CQQueryDateTimeFormat, CultureInfo.InvariantCulture);
// record current time to update HWM after processing
DateTime newHwmValue = CQUtilityMethods.GetTimeForNewHighWaterMark(m_migrationContext.CQTimeOffsetFromServerHistoryTimesInMinutes);
// store to be used for analysis
WorkItemLinkStore store = new WorkItemLinkStore(m_configurationService.SourceId);
// extract links
var inMaxDeltaSliceSize = maxDeltaSliceSize;
foreach (CQRecordFilter filter in m_filters)
{
CQRecordQueryBase recordQuery = CQRecordQueryFactory.CreateQuery(m_userSession, filter, hwmDeltaValueStr, this);
foreach (ClearQuestOleServer.OAdEntity record in recordQuery)
{
// HACK HACK
if (record == null)
{
continue;
}
// HACK HACK
string recDispName = CQWrapper.GetEntityDisplayName(record);
TraceManager.TraceInformation("Generating linking delta for CQ Record: {0}", recDispName);
var perWorkItemlinkChangeGroups = new List <LinkChangeGroup>();
ExtractLinkChangeActionsCallback(m_userSession, record, perWorkItemlinkChangeGroups);
if (perWorkItemlinkChangeGroups.Count == 0)
{
TraceManager.TraceInformation("Number of links: {0}", 0);
continue;
}
LinkChangeGroup consolidatedLinkChangeGroup = perWorkItemlinkChangeGroups[0];
for (int i = 1; i < perWorkItemlinkChangeGroups.Count; ++i)
{
foreach (LinkChangeAction action in perWorkItemlinkChangeGroups[i].Actions)
{
consolidatedLinkChangeGroup.AddChangeAction(action);
}
}
TraceManager.TraceInformation("Number of links: {0}", consolidatedLinkChangeGroup.Actions.Count.ToString());
// VERY IMPORTANT STEP: update the link delta to store
string hostRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(record);
store.UpdatePerItemLinkChangeGroupsByCheckingRelatedItemRecords(
hostRecMigrItemId, consolidatedLinkChangeGroup, this);
if (consolidatedLinkChangeGroup.Actions.Count > 0)
{
linkChangeGroups.Add(consolidatedLinkChangeGroup);
}
maxDeltaSliceSize -= consolidatedLinkChangeGroup.Actions.Count;
if (maxDeltaSliceSize <= 0)
{
// size limit reached - persist groups to DB, then empty the slice and process next slice
linkService.AddChangeGroups(linkChangeGroups);
linkChangeGroups.Clear();
maxDeltaSliceSize = inMaxDeltaSliceSize;
}
}
}
// persist remaining groups to DB
linkService.AddChangeGroups(linkChangeGroups);
// clean up the returned link change group collection
// when the caller (toolkit) receives an empty collection, it understands there is no more
// delta to generate for the moment, and proceeds to next phase
linkChangeGroups.Clear();
// update primary Highwater Mark
m_hwmLink.Update(newHwmValue);
TraceManager.TraceInformation("Persisted CQ linking HWM: {0}", ClearQuestConstants.CqLinkHwm);
TraceManager.TraceInformation("Updated CQ linking HWM: {0}", newHwmValue.ToString());
return(linkChangeGroups.AsReadOnly());
}
catch (Exception exception)
{
// [teyang] TODO CONFLICT HANDLING
//MigrationConflict genericeConflict = WitGeneralConflictType.CreateConflict(exception);
//var conflictManager = m_conflictManager.GetService(typeof(ConflictManager)) as ConflictManager;
//Debug.Assert(null != conflictManager);
//List<MigrationAction> resolutionActions;
//ConflictResolutionResult resolveRslt =
// conflictManager.TryResolveNewConflict(conflictManager.SourceId, genericeConflict, out resolutionActions);
//Debug.Assert(!resolveRslt.Resolved);
TraceManager.TraceException(exception);
return(new List <LinkChangeGroup>().AsReadOnly());
}
}
/// <summary>
/// Process the change group.
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
public ConversionResult ProcessChangeGroup(ChangeGroup group)
{
ConversionResult rslt;
CCBatchingContext ctx = new CCBatchingContext(m_clearCaseServer, GetChangeComment(group),
group, m_ccConfiguration.DownloadFolder, m_conflictManagementService, m_ccConfiguration, m_overrideTargetChange);
int processedActionCount = 0;
m_changeGroupHighWaterMark.Reload();
if (m_changeGroupHighWaterMark.Value == group.ChangeGroupId)
{
// Todo get the last action id from ClearCase history
}
try
{
foreach (MigrationAction action in group.Actions)
{
if (processedActionCount > 50000)
{
TraceManager.TraceInformation("Processed 50,000 actions");
processedActionCount = 0;
}
processedActionCount++;
if (action.State != ActionState.Pending)
{
continue;
}
if (action.Action == WellKnownChangeActionId.Add)
{
if (string.Equals(action.ItemTypeReferenceName, WellKnownContentType.VersionControlLabel.ReferenceName, StringComparison.Ordinal))
{
ctx.CacheLabel(action);
}
else if (string.Equals(action.ItemTypeReferenceName, WellKnownContentType.VersionControlLabelItem.ReferenceName, StringComparison.Ordinal) ||
string.Equals(action.ItemTypeReferenceName, WellKnownContentType.VersionControlRecursiveLabelItem.ReferenceName, StringComparison.Ordinal))
{
ctx.CacheLabelItem(action);
}
else
{
// Todo handle branch and undelete seperately.
if (ClearCasePath.IsVobRoot(ClearCasePath.GetFullPath(action.Path)))
{
TraceManager.TraceWarning("Skipped the change action that creates vob itself");
continue;
}
ctx.AddSingleItem(action, WellKnownChangeActionId.Add);
}
}
else if ((action.Action == WellKnownChangeActionId.Branch) ||
(action.Action == WellKnownChangeActionId.BranchMerge) ||
(action.Action == WellKnownChangeActionId.Undelete))
{
// Todo handle branch and undelete seperately.
if (ClearCasePath.IsVobRoot(ClearCasePath.GetFullPath(action.Path)))
{
TraceManager.TraceWarning("Skipped the change action that creates vob itself");
continue;
}
ctx.AddSingleItem(action, WellKnownChangeActionId.Add);
}
else if (action.Action == WellKnownChangeActionId.Edit)
{
ctx.AddSingleItem(action, WellKnownChangeActionId.Edit);
}
else if (action.Action == WellKnownChangeActionId.Delete)
{
ctx.AddSingleItem(action, WellKnownChangeActionId.Delete);
}
else if (action.Action == WellKnownChangeActionId.Rename)
{
if (ClearCasePath.Equals(action.Path, action.FromPath))
{
// Skip case-only rename.
continue;
}
ctx.AddSingleItem(action, WellKnownChangeActionId.Rename);
}
else if (action.Action == WellKnownChangeActionId.Merge)
{
continue;
}
else if (action.Action == WellKnownChangeActionId.AddFileProperties)
{
ctx.AddSingleItem(action, WellKnownChangeActionId.AddFileProperties);
}
}
rslt = new ConversionResult(m_configurationService.SourceId, m_configurationService.MigrationPeer);
rslt.ChangeId = m_clearCaseServer.GetRelativePathFromVobAbsolutePath(ctx.Flush());
rslt.ItemConversionHistory.Add(new ItemConversionHistory(group.Name, string.Empty, rslt.ChangeId, string.Empty));
rslt.ContinueProcessing = true;
m_changeGroupHighWaterMark.Update(group.ChangeGroupId);
if (m_hwmLastSyncedTfsChangeset != null)
{
m_hwmLastSyncedTfsChangeset.Update(int.Parse(group.Name));
}
}
catch (Exception e)
{
// Undo any pending checkouts that would have been checked in by the call to ctx.Flush() if no exception occurred.
// (If ctx.Flush() has already been called, this will just return.)
// It will catch and log any exception as an error, but will not throw it so that the original exception is raised as the conflict.
ctx.CancelCachedCheckouts();
if (!(e is MigrationUnresolvedConflictException))
{
TraceManager.TraceInformation("Raising generic conflict for exception: {0}", e.Message);
createGenericConflict(e, group);
}
rslt = new ConversionResult(Guid.Empty, group.SourceId);
rslt.ContinueProcessing = false;
}
return(rslt);
}
