public IEnumerable <IVCDiffItem> GetFolderSubDiffItems(IVCDiffItem folderDiffItem)
{
List <IVCDiffItem> diffItems = new List <IVCDiffItem>();
try
{
string directoryPath = m_clearCaseServer.GetViewLocalPathFromServerPath(folderDiffItem.ServerPath);
if (Directory.Exists(directoryPath))
{
foreach (string file in Directory.GetFiles(directoryPath))
{
string serverPath = m_clearCaseServer.GetServerPathFromViewLocalPath(file);
diffItems.Add(new ClearCaseDiffItem(serverPath, file, VCItemType.File));
}
foreach (string subDirectory in Directory.GetDirectories(directoryPath))
{
string serverPath = m_clearCaseServer.GetServerPathFromViewLocalPath(subDirectory);
if (ClearCasePath.Equals(ClearCasePath.GetFileName(serverPath), ClearCasePath.LostFoundFolder))
{
continue;
}
diffItems.Add(new ClearCaseDiffItem(serverPath, null, VCItemType.Folder));
}
}
}
catch (Exception ex)
{
throw new VersionControlDiffException(string.Format(CultureInfo.InvariantCulture,
CCResources.GetDiffItemsException, folderDiffItem.ServerPath, ex.Message), ex);
}
return(diffItems);
}
private void addRename(CCBatchedItem item)
{
string removeItem = null;
foreach (KeyValuePair <string, CCBatchedItem> renameItemInlist in m_unresolvedRenames)
{
if (ClearCasePath.Equals(ClearCasePath.MakeRelative(item.Target, renameItemInlist.Value.Target),
ClearCasePath.MakeRelative(item.Source, renameItemInlist.Value.Source)))
{
// Parent rename is already added, just return.
return;
}
else if (ClearCasePath.Equals(ClearCasePath.MakeRelative(renameItemInlist.Value.Target, item.Target),
ClearCasePath.MakeRelative(renameItemInlist.Value.Source, item.Source)))
{
// A child rename is already, remove the child rename.
removeItem = renameItemInlist.Key;
break;
}
}
if (!string.IsNullOrEmpty(removeItem))
{
m_unresolvedRenames.Remove(removeItem);
}
m_unresolvedRenames.Add(item.Target, item);
}
private void reviseRenameList(CCHistoryRecord renameHistoryRecord, Dictionary <string, string> renameList)
{
bool needToAddToRenameList = true;
List <string> subItemRenameToBeModified = new List <string>();
foreach (string renameToPath in renameList.Keys)
{
if (ClearCasePath.Equals(renameList[renameToPath], renameHistoryRecord.AbsoluteVobPath))
{
subItemRenameToBeModified.Add(renameToPath);
needToAddToRenameList = false;
continue;
}
if (ClearCasePath.IsSubItem(renameList[renameToPath], renameHistoryRecord.AbsoluteVobPath))
{
subItemRenameToBeModified.Add(renameToPath);
}
}
foreach (string subItem in subItemRenameToBeModified)
{
renameList[subItem] =
ClearCasePath.Combine(renameHistoryRecord.AbsoluteVobPathFrom, renameList[subItem].Substring(renameHistoryRecord.AbsoluteVobPath.Length));
}
if (needToAddToRenameList)
{
renameList.Add(renameHistoryRecord.AbsoluteVobPath, renameHistoryRecord.AbsoluteVobPathFrom);
}
}
/// <summary>
/// Find the mapping entry for the given path.
/// </summary>
/// <param name="serverPath"></param>
/// <returns>Null if the path is not mapped or cloaked. Otherwise, return the mapping entry.</returns>
internal static MappingEntry FindMappedPath(string serverPath, ConfigurationService configurationService)
{
MappingEntry mostSpecificMapping = null;
foreach (MappingEntry current in configurationService.Filters)
{
if (ClearCasePath.IsSubItem(serverPath, ClearCasePath.GetFullPath(current.Path)))
{
if (mostSpecificMapping == null ||
ClearCasePath.IsSubItem(ClearCasePath.GetFullPath(current.Path),
ClearCasePath.GetFullPath(mostSpecificMapping.Path)))
{
mostSpecificMapping = current;
}
}
}
if ((mostSpecificMapping != null) && (!mostSpecificMapping.Cloak))
{
return(mostSpecificMapping);
}
else
{
return(null);
}
}
private void reviseNameForRename(CCHistoryRecord historyRecord, Dictionary <string, string> renameList)
{
if (renameList.Count == 0)
{
return;
}
string path = historyRecord.AbsoluteVobPath;
while (!ClearCasePath.IsVobRoot(path))
{
if (renameList.ContainsKey(path))
{
historyRecord.AbsoluteVobPath =
ClearCasePath.Combine(renameList[path], historyRecord.AbsoluteVobPath.Substring(path.Length));
break;
}
path = ClearCasePath.GetFolderName(path);
}
if (historyRecord.ChangeAction == WellKnownChangeActionId.Rename)
{
string fromPath = historyRecord.AbsoluteVobPathFrom;
while (!ClearCasePath.IsVobRoot(fromPath))
{
if (renameList.ContainsKey(fromPath))
{
historyRecord.AbsoluteVobPathFrom =
ClearCasePath.Combine(renameList[fromPath], historyRecord.AbsoluteVobPathFrom.Substring(fromPath.Length));
break;
}
fromPath = ClearCasePath.GetFolderName(fromPath);
}
}
}
/// <summary>
/// Constructor.
/// Construct the clearcase item from a version object on ClearCase
/// </summary>
/// <param name="version"></param>
public CCItem(CCVersion version, string vobName)
{
ItemType = ItemType.Version;
VersionExtendedPath = version.ExtendedPath;
AbsoluteVobPath = vobName;
string[] splittedPath = VersionExtendedPath.Split(new string[] { ClearCasePath.ExtendedNamingSuffix }, StringSplitOptions.None);
Branch = ClearCasePath.GetBranchName(splittedPath[splittedPath.Length - 1]);
List <string> parentPaths = new List <string>();
while (!ClearCasePath.IsVobRoot(version.Element.Path))
{
parentPaths.Add(ClearCasePath.GetFileName(version.Element.Path));
try
{
version = version.Parent;
}
catch (COMException)
{
// This is a ClearCase CAL bug.
// Ignore the root node.
parentPaths.RemoveAt(parentPaths.Count - 1);
break;
}
}
parentPaths.Reverse();
foreach (string parentPath in parentPaths)
{
AbsoluteVobPath = ClearCasePath.Combine(AbsoluteVobPath, parentPath);
}
AbsoluteVobPath = AbsoluteVobPath;
AbsoluteVobPathAtTheVersion = AbsoluteVobPath;
}
/// <summary>
/// Given the output of checkin command, return list of element versions checked in.
/// </summary>
/// <param name="cmdOutput"></param>
/// <returns></returns>
public static List <string> ParseCheckInCommand(string cmdOutput)
{
if (string.IsNullOrEmpty(cmdOutput))
{
return(null);
}
StringReader strReader = new StringReader(cmdOutput);
string line;
List <string> versionList = new List <string>();
while (true)
{
line = strReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
if (line.StartsWith(CheckedInPrefix))
{
string [] split = line.Split(new char[] { '\"' });
if (split.Length < 4)
{
TraceManager.TraceWarning(string.Format("Don't know how to parse checkin command return - {0}", line));
}
else
{
versionList.Add(ClearCasePath.Combine(split[1], split[3]));
}
}
}
return(versionList);
}
private void addDelete(CCBatchedItem item)
{
string removeItem = null;
foreach (KeyValuePair <string, CCBatchedItem> deleteItemInlist in m_unresolvedDeletes)
{
if (ClearCasePath.IsSubItem(item.Target, deleteItemInlist.Value.Target))
{
// Parent delete is already added, just return.
return;
}
else if (ClearCasePath.IsSubItem(deleteItemInlist.Value.Target, item.Target))
{
// A child delete is already added, remove the child delete.
removeItem = deleteItemInlist.Key;
break;
}
}
if (!string.IsNullOrEmpty(removeItem))
{
m_unresolvedDeletes.Remove(removeItem);
}
m_unresolvedDeletes.Add(item.Target, item);
}
/// <summary>
/// Generate a CCHistoryRecord instance from a historyRow string.
/// </summary>
/// <param name="historyRow">A history row string returned from query history command</param>
/// <returns>The CCHistoryRecord created or null if the creation failed.</returns>
public static CCHistoryRecord CreateInstance(string historyRow)
{
if (string.IsNullOrEmpty(historyRow))
{
return(null);
}
if (historyRow.Contains("ClearCase object not found."))
{
TraceManager.TraceInformation("Invalid history record - {0}", historyRow);
return(null);
}
string[] historyColumns =
historyRow.Split(new string[] { ClearCaseCommandSpec.HISTORYRECORD_COLUMNDELIMINATOR }, StringSplitOptions.None);
if (historyColumns.Length < 7)
{
TraceManager.TraceInformation("Wrong numbers of columns in history record - {0}", historyRow);
return(null);
}
string[] strEventId =
historyColumns[0].Split(new string[] {
"event", ":"
},
StringSplitOptions.RemoveEmptyEntries);
long eventId;
if (!long.TryParse(strEventId[0], out eventId))
{
TraceManager.TraceInformation("Invalid event id in history record - {0}", historyRow);
return(null);
}
DateTime versionTime;
if (!DateTime.TryParse(historyColumns[5], out versionTime))
{
TraceManager.TraceInformation("Invalid version time in history record - {0}", historyRow);
return(null);
}
CCHistoryRecord instance = new CCHistoryRecord
{
EventId = eventId,
OperationType = Operation.GetOperationType(historyColumns[2]),
VersionExtendedPath = historyColumns[1],
OperationDescription = historyColumns[3],
VersionTime = versionTime,
Comment = historyColumns[6],
UserComment = historyColumns[7].Trim(new char[] { '(', ')' }),
AbsoluteVobPath = ClearCasePath.GetAbsoluteVobPathFromVersionExtendedPath(historyColumns[1])
};
return(instance);
}
/// <summary>
/// For a list of paths, check whether an element's ancestor is in the list.
/// </summary>
/// <param name="listToBeChecked"></param>
/// <param name="element"></param>
/// <returns></returns>
public static bool IsElementAncestorInList(HashSet <string> listToBeChecked, string element)
{
while (!ClearCasePath.IsVobRoot(element))
{
if (listToBeChecked.Contains(element))
{
return(true);
}
element = ClearCasePath.GetFolderName(element);
}
return(false);
}
//********************************************************************************************
/// <summary>
/// Returns the number of levels of path elements in this spec up to the maximum depth.
/// \ will return 0
/// \foo will return 1
/// \foo\bar will return 2, and so on...
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
//********************************************************************************************
public static int GetFolderDepth(String item)
{
int count = 0;
if (!ClearCasePath.Equals(item, Separator))
{
// Count the slashes
for (int lastIndex = item.IndexOf(Separator); (lastIndex != -1); lastIndex = item.IndexOf(Separator, lastIndex + 1))
{
count++;
}
}
return(count);
}
private ChangeGroup createMigrationAction(CCHistoryRecord historyRecord, Guid actionId)
{
string versionExtendedPath;
if (m_clearCaseServer.UsePrecreatedView)
{
versionExtendedPath = historyRecord.VersionExtendedPath;
}
else
{
versionExtendedPath =
ClearCasePath.removeViewLocationFromVersion(historyRecord.VersionExtendedPath, m_clearCaseServer.ViewRootPath);
}
ChangeGroup oldChangeGroup;
ChangeGroup currentChangeGroup = m_changeGroupService.AddMigrationActionToDeltaTable(historyRecord.EventId.ToString(CultureInfo.InvariantCulture),
historyRecord.Comment,
null,
historyRecord.EventId,
actionId,
new ClearCaseMigrationItem(
m_ccConfiguration.GetViewName("Analysis"),
versionExtendedPath,
historyRecord.IsDirectory),
historyRecord.AbsoluteVobPathFrom,
historyRecord.AbsoluteVobPath,
null,
null,
historyRecord.IsDirectory ? WellKnownContentType.VersionControlledFolder.ReferenceName
: WellKnownContentType.VersionControlledFile.ReferenceName,
null,
historyRecord.VersionTime,
out oldChangeGroup);
m_hwmEventId.Update(historyRecord.EventId);
if ((oldChangeGroup != null) && (oldChangeGroup != currentChangeGroup))
{
oldChangeGroup.Save();
m_changeGroupService.PromoteDeltaToPending();
m_hwmDelta.Update(historyRecord.VersionTime);
}
return(currentChangeGroup);
}
/// <summary>
/// Add a new load rule of the pName into the existing config spec
/// </summary>
/// <param name="existingConfigSpec"></param>
/// <param name="pName"></param>
public static string AddLoadRule(string existingConfigSpec, string pName)
{
StringReader existingConfigSpecReader = new StringReader(existingConfigSpec);
StringWriter newConfigSpecWriter = new StringWriter();
bool needToAddLoadRule = true;
while (true)
{
string line = existingConfigSpecReader.ReadLine();
if (line == null)
{
break;
}
else
{
line = line.Trim();
}
if (line.StartsWith("load", StringComparison.InvariantCultureIgnoreCase))
{
// Todo, it is possible to have multiple pnames in one load rule line.
string loadedPName = line.Substring(5).Trim();
if (ClearCasePath.IsSubItem(pName, loadedPName))
{
// The parent is already loaded.
needToAddLoadRule = false;
}
else if (ClearCasePath.IsSubItem(loadedPName, pName))
{
// There is a child load rule. Add the parent load rule instead and continue;
newConfigSpecWriter.Write(string.Format(CCResources.CCConfigSpecLoadRule, pName) + '\n');
needToAddLoadRule = false;
continue;
}
}
newConfigSpecWriter.Write(line + '\n');
}
if (needToAddLoadRule)
{
newConfigSpecWriter.Write(string.Format(CCResources.CCConfigSpecLoadRule, pName) + '\n');
}
return(newConfigSpecWriter.ToString());
}
/// <summary>
/// Constructor
/// </summary>
public CCHistoryRecord(string historyRow)
{
if (String.IsNullOrEmpty(historyRow))
{
throw new ArgumentNullException("historyRow");
}
string[] historyColumns =
historyRow.Split(new string[] { ClearCaseCommandSpec.HISTORYRECORD_COLUMNDELIMINATOR }, StringSplitOptions.None);
string[] strEventId =
historyColumns[0].Split(new string[] {
"event", ":"
},
StringSplitOptions.RemoveEmptyEntries);
EventId = long.Parse(strEventId[0]);
VersionExtendedPath = historyColumns[1];
OperationType = Operation.GetOperationType(historyColumns[2]);
OperationDescription = historyColumns[3];
VersionTime = DateTime.Parse(historyColumns[5]);
Comment = historyColumns[6];
UserComment = historyColumns[7].Trim(new char[] { '(', ')' });
AbsoluteVobPath = ClearCasePath.GetAbsoluteVobPathFromVersionExtendedPath(VersionExtendedPath);
}
public bool IsSubItemOf(string folderPath)
{
return(ServerPath == null ? false : ClearCasePath.IsSubItem(ServerPath, folderPath));
}
private void detectConflicts()
{
// Add and Rename list
// First, remove all rename for rename|undelete that was changed to rename|add.
List <string> renameToBeRemoved = new List <string>();
foreach (string renameToName in m_unresolvedRenames.Keys)
{
if (m_unresolvedAdds.ContainsKey(renameToName))
{
renameToBeRemoved.Add(renameToName);
}
}
foreach (string renameToName in renameToBeRemoved)
{
m_unresolvedRenames.Remove(renameToName);
}
foreach (CCBatchedItem addItem in m_unresolvedAdds.Values)
{
foreach (CCBatchedItem renameItem in m_unresolvedRenames.Values)
{
if (ClearCasePath.IsSubItem(addItem.Target, renameItem.Target))
{
// Add folder2/1.txt, Rename folder1 to folder2.
scheduleItem(addItem, renameItem);
}
else if (ClearCasePath.IsSubItem(renameItem.Target, addItem.Target))
{
// Rename folder1/1.txt to folder1/2.txt, Add folder1
scheduleItem(renameItem, addItem);
}
else if (ClearCasePath.IsSubItem(addItem.Target, renameItem.Source))
{
// Rename folder1 to folder2, Add folder1/1.txt
scheduleItem(addItem, renameItem);
}
else if (ClearCasePath.Equals(renameItem.Source, addItem.Target) && ClearCasePath.IsSubItem(renameItem.Target, addItem.Target))
{
// ToDo Rename to below itself.
throw new NotImplementedException("Don't know how to handle rename to below itself problem.");
}
else
{
Debug.Assert(!ClearCasePath.IsSubItem(renameItem.Source, addItem.Target), "Rename source cannot be the sub item of an Add");
}
}
m_unresolvedChanges.Add(addItem);
}
// Rename and itself
foreach (CCBatchedItem renameItemOutLoop in m_unresolvedRenames.Values)
{
foreach (CCBatchedItem renameItemInnerLoop in m_unresolvedRenames.Values)
{
if (ClearCasePath.Equals(renameItemInnerLoop.Target, renameItemOutLoop.Target))
{
continue;
}
if (ClearCasePath.IsSubItem(renameItemInnerLoop.Target, renameItemOutLoop.Source))
{
scheduleItem(renameItemInnerLoop, renameItemOutLoop);
}
}
m_unresolvedChanges.Add(renameItemOutLoop);
}
}
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();
}
/// <summary>
/// Downloads the TFS server item to the specified path. If the item is a directory, just create it.
/// </summary>
/// <param name="localPath">The local path to download the TFS server item to.</param>
public void Download(string localPath)
{
if (!IsDirectory)
{
Utils.EnsurePathToFileExists(localPath);
ClearCaseServer clearCaseServer = ClearCaseServer.GetInstance(m_viewName);
string getCmd = string.Format("get -to \"{0}\" \"{1}\"", localPath, ClearCasePath.MakeRelative(m_versionExtendedPath));
try
{
string cmdOutput = clearCaseServer.ExecuteClearToolCommand(getCmd);
}
catch (Exception)
{
throw;
}
}
else
{
Directory.CreateDirectory(localPath);
}
}
/// <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);
}