/// <summary>
/// Determines whether a version control folder exists having a specific version
/// </summary>
/// <param name="name">The name of the component</param>
/// <param name="version">The name of the component (branch folder)</param>
/// <returns>true if the branch folder exists at the version; false otherwise</returns>
public bool ComponentExists(IComponentName name, IComponentVersion version)
{
ValidateComponentName(name);
ValidateComponentVersion(version);
// Check if folder exists in source control
if (!VersionControlServer.ServerItemExists(name.ToString(), version.TfsVersionSpec, DeletedState.NonDeleted, ItemType.Folder))
{
Logger.Instance().Log(TraceLevel.Warning, "{0}: Component {1}#{2} was not found in source control", ResolverType, name, version);
return(false);
}
// Check if component.targets exists inside folder
var folderItems = VersionControlServer.GetItems(VersionControlPath.Combine(name.ToString(), "*"), version.TfsVersionSpec, RecursionType.OneLevel);
foreach (Item item in folderItems.Items)
{
var itemName = VersionControlPath.GetFileName(item.ServerItem);
foreach (var dependencyDefinitionFileName in ValidDependencyDefinitionFileNames)
{
if (string.Equals(itemName, dependencyDefinitionFileName, StringComparison.OrdinalIgnoreCase))
{
Logger.Instance().Log(TraceLevel.Info, "{0}: Component {1}#{2} was found in source control", ResolverType, name, version);
return(true);
}
}
}
Logger.Instance().Log(TraceLevel.Warning, "{0}: Component {1}#{2} was not found in source control", ResolverType, name, version);
return(false);
}
public static string GetName(Item item)
{
Contract.Requires(item != null);
string name = VersionControlPath.GetFileName(item.ServerItem);
return(name);
}
/// <summary>
/// Checks if source control folder contains a dependency definition file.
/// </summary>
/// <param name="sourceControlPath">The source control path to check.</param>
/// <param name="dependencyDefinitonFilenameList">The list of valid dependency definition file names.</param>
/// <returns>True if it contains a dependency definition file. False otherwise.</returns>
public bool IsDependencyDefinitionFilePresentInFolder(string sourceControlPath, string dependencyDefinitonFilenameList)
{
if (null == _tpc)
{
throw new InvalidOperationException("The connection is currently closed");
}
var vss = _tpc.GetService <VersionControlServer>();
if (null == vss)
{
throw new InvalidOperationException("The connection to the version control server could not be established");
}
var items = vss.GetItems(VersionControlPath.Combine(sourceControlPath, "*"), VersionSpec.Latest, RecursionType.OneLevel);
var dependencyDefinitionFilenames = dependencyDefinitonFilenameList.Split(';');
foreach (var item in items.Items)
{
if (dependencyDefinitionFilenames.Any(x => x.Equals(VersionControlPath.GetFileName(item.ServerItem), StringComparison.OrdinalIgnoreCase)))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determines whether a version control folder exists having a specific version
/// </summary>
/// <param name="name">The name of the component</param>
/// <param name="version">The version for the component</param>
/// <returns>True if a version folder exists at the version; false otherwise</returns>
public bool ComponentExists(IComponentName name, IComponentVersion version)
{
ValidateComponentName(name);
ValidateComponentVersion(version);
if (VersionControlServer.ServerItemExists(VersionControlPath.Combine(PathPrefix, name.ToString()), VersionSpec.Latest, DeletedState.NonDeleted, ItemType.Folder))
{
var path = VersionControlPath.Combine(VersionControlPath.Combine(PathPrefix, name.ToString()), version.ToString());
if (VersionControlServer.ServerItemExists(path, VersionSpec.Latest, DeletedState.NonDeleted, ItemType.Folder))
{
// Check if component.targets exists inside folder
var folderItems = VersionControlServer.GetItems(VersionControlPath.Combine(path, "*"));
foreach (var item in folderItems.Items)
{
var itemName = VersionControlPath.GetFileName(item.ServerItem);
foreach (var dependencyDefinitionFileName in ValidDependencyDefinitionFileNames)
{
if (string.Equals(itemName, dependencyDefinitionFileName, StringComparison.OrdinalIgnoreCase))
{
Logger.Instance().Log(TraceLevel.Info, "{0}: Component {1}#{2} was found in binary repository", ResolverType, name, version);
return(true);
}
Logger.Instance().Log(TraceLevel.Verbose, "{0}: Dependency definition file {1} for component {2}#{3} was not found in binary repository", ResolverType, dependencyDefinitionFileName, name, version);
}
}
}
}
Logger.Instance().Log(TraceLevel.Warning, "{0}: Component {1}#{2} was not found in binary repository", ResolverType, name, version);
return(false);
}
/// <summary>
/// Returns all components found in the repository.
/// </summary>
/// <returns>List with components</returns>
public IEnumerable <IComponentName> GetAvailableComponentNames()
{
var availableComponents = new List <IComponentName>();
Logger.Instance().Log(TraceLevel.Info, "{0}: Querying available components...", ResolverType);
var items = VersionControlServer.GetItems(VersionControlPath.Combine(PathPrefix, "*"));
foreach (var item in items.Items)
{
if (item.ItemType.Equals(ItemType.Folder))
{
var componentName = VersionControlPath.GetFileName(item.ServerItem);
if (!string.Equals(componentName, "BuildProcessTemplates", StringComparison.OrdinalIgnoreCase))
{
availableComponents.Add(new ComponentName(componentName));
Logger.Instance().Log(TraceLevel.Info, "{0}: Found component {1}", ResolverType, componentName);
}
}
}
Logger.Instance().Log(TraceLevel.Info, "{0}: Querying components finished successfully", ResolverType);
return(availableComponents);
}
internal static string GetItemName(PendingChange pendingChange, bool useServerPath)
{
if (useServerPath || string.IsNullOrEmpty(pendingChange.LocalItem))
{
return(VersionControlPath.GetFileName(pendingChange.ServerItem));
}
return(FileSpec.GetFileName(pendingChange.LocalItem));
}
public static string GetName(Item item)
{
Assert.IsTrue(item != null);
var name = VersionControlPath.GetFileName(item.ServerItem);
return(name);
}
public static string GetName(Item item)
{
FoundationContract.Requires <ArgumentException>(item != null);
var name = VersionControlPath.GetFileName(item.ServerItem);
return(name);
}
public static void BranchToFolder(Workspace workspace, IEnumerable <string> items, string folder, VersionSpec versionSpec)
{
foreach (var item in items)
{
string fileName = VersionControlPath.GetFileName(item);
string folderPath = VersionControlPath.Combine(folder, fileName);
workspace.PendBranch(item, folderPath, versionSpec);
}
}
private void Open_Click(object sender, EventArgs e)
{
var name = VersionControlPath.GetFileName(item.ServerItem);
var localFileName = Path.GetTempPath();
localFileName = Path.Combine(localFileName, name);
item.DownloadFile(localFileName);
var startInfo = new ProcessStartInfo(localFileName);
Process.Start(startInfo);
}
/// <summary>
/// Returns all versions for a component found in the repository.
/// </summary>
/// <param name="name">The component name.</param>
/// <returns>The list of versions</returns>
public IEnumerable <IComponentVersion> GetAvailableVersions(IComponentName name)
{
ValidateComponentName(name);
Logger.Instance().Log(TraceLevel.Info, "{0}: Querying available component versions...", ResolverType);
var availableVersions = new List <IComponentVersion>();
if (VersionControlServer.ServerItemExists(VersionControlPath.Combine(PathPrefix, name.ToString()), VersionSpec.Latest, DeletedState.NonDeleted, ItemType.Folder))
{
var versionItems = VersionControlServer.GetItems(VersionControlPath.Combine(VersionControlPath.Combine(PathPrefix, name.ToString()), "*"));
foreach (var version in versionItems.Items)
{
if (version.ItemType.Equals(ItemType.Folder))
{
// Check if component.targets exists inside folder
var folderItems = VersionControlServer.GetItems(VersionControlPath.Combine(VersionControlPath.Combine(VersionControlPath.Combine(PathPrefix, name.ToString()), VersionControlPath.GetFileName(version.ServerItem)), "*"));
var dependencyDefinitionFileFound = false;
foreach (var item in folderItems.Items)
{
var itemName = VersionControlPath.GetFileName(item.ServerItem);
foreach (var dependencyDefinitionFileName in ValidDependencyDefinitionFileNames)
{
if (string.Equals(itemName, dependencyDefinitionFileName, StringComparison.OrdinalIgnoreCase))
{
Logger.Instance().Log(TraceLevel.Info, "{0}: Found version {1}", ResolverType, VersionControlPath.GetFileName(version.ServerItem));
availableVersions.Add(new ComponentVersion(VersionControlPath.GetFileName(version.ServerItem)));
dependencyDefinitionFileFound = true;
}
}
}
if (!dependencyDefinitionFileFound)
{
Logger.Instance().Log(TraceLevel.Warning, "{0}: Skipping version {1} (Dependency definition file is not present)", ResolverType, VersionControlPath.GetFileName(version.ServerItem));
}
}
}
}
else
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Directory {1} for component {2} does not exist", ResolverType, VersionControlPath.Combine(PathPrefix, name.ToString()), name);
throw new InvalidComponentException(string.Format("Could not find component {0} in binary repository", name));
}
Logger.Instance().Log(TraceLevel.Info, "{0}: Querying component versions finished successfully", ResolverType);
return(availableVersions);
}
private string adjustSourceForParentRenameIfNeeded(string sourceName, string targetName, bool adjustToTarget)
{
string adjustedSource;
BatchedItem parentRenameItem;
if (!m_implicitRenamesWithParentItems.TryGetValue(targetName, out parentRenameItem))
{
adjustedSource = sourceName;
}
else
{
string parentPathToUse = adjustToTarget ? parentRenameItem.Target : parentRenameItem.Source;
adjustedSource = VersionControlPath.Combine(parentPathToUse, VersionControlPath.GetFileName(sourceName));
}
return(adjustedSource);
}
private void View_Click(object sender, EventArgs e)
{
var name = VersionControlPath.GetFileName(_item.ServerItem);
var localFileName = Path.GetTempPath();
localFileName = Path.Combine(localFileName, name);
_item.DownloadFile(localFileName);
var node = Settings.CurrentType;
var attributes = node.Attributes;
var contains = attributes.TryGetAttributeValue("FileName", out string fileName);
var arguments = '"' + localFileName + '"';
var startInfo = new ProcessStartInfo(fileName, arguments);
Process.Start(startInfo);
}
public static void MoveToFolder(Workspace workspace, IEnumerable <string> items, string folder)
{
try
{
foreach (var item in items)
{
string fileName = VersionControlPath.GetFileName(item);
string folderPath = VersionControlPath.Combine(folder, fileName);
workspace.PendRename(item, folderPath);
}
}
catch (System.ComponentModel.Win32Exception ex)
{
//Access is denied
//This file is currently not available for use on this computer
TrackWarning(ex.Message);
}
}
private void PopulateFolders(TreeNode ownerNode, string queryPath)
{
ownerNode.Nodes.Clear();
ItemSet folders = Context.ControlServer.GetItems(queryPath, VersionSpec.Latest, RecursionType.OneLevel,
DeletedState.NonDeleted,
ItemType.Folder);
foreach (Item folderItem in folders.Items)
{
if (folderItem.ServerItem == queryPath)
{
continue;
}
int icon = VersionControlPath.GetFolderDepth(folderItem.ServerItem) == 1 ? 1 : 2;
TreeNode newNode = AddNode(ownerNode.Nodes, VersionControlPath.GetFileName(folderItem.ServerItem), icon);
newNode.Tag = folderItem.ServerItem;
var dummyNode = new TreeNode(queryPath + "/dummy");
newNode.Nodes.Add(dummyNode);
}
}
internal static string GetOriginalName(PendingChange pendingChange, bool useServerPath)
{
string x = null;
var itemName = GetItemName(pendingChange, useServerPath);
if (!string.IsNullOrEmpty(pendingChange.SourceLocalItem) && !string.IsNullOrEmpty(pendingChange.LocalItem))
{
x = FileSpec.GetFileName(pendingChange.SourceLocalItem);
if (
!FileSpec.Equals(FileSpec.GetDirectoryName(pendingChange.SourceLocalItem),
FileSpec.GetDirectoryName(pendingChange.LocalItem)))
{
x = pendingChange.SourceLocalItem;
}
if (string.Equals(x, itemName, StringComparison.Ordinal))
{
x = null;
}
}
if (x == null && !string.IsNullOrEmpty(pendingChange.SourceServerItem) &&
!string.IsNullOrEmpty(pendingChange.ServerItem))
{
x = VersionControlPath.GetFileName(pendingChange.SourceServerItem);
if (
!VersionControlPath.Equals(VersionControlPath.GetFolderName(pendingChange.SourceServerItem),
VersionControlPath.GetFolderName(pendingChange.ServerItem)))
{
x = pendingChange.SourceServerItem;
}
if (string.Equals(x, itemName, StringComparison.Ordinal))
{
x = null;
}
}
return(x);
}
public override bool Read()
{
bool read;
if (_command.Cancelled)
{
read = false;
}
else
{
if (_first)
{
_first = false;
var serverPath = (string)_command.Parameters["serverPath"].Value;
_item = _command.Connection.VersionControlServer.GetItem(serverPath);
_localPath = ValueReader.GetValueOrDefault <string>(_command.Parameters["localPath"].Value);
if (_localPath == null)
{
_localPath = Path.GetTempPath();
_localPath = Path.Combine(_localPath, DateTime.Now.ToString("yyyyMMdd HHmmss.fff"));
switch (_item.ItemType)
{
case ItemType.File:
case ItemType.Folder:
var name = VersionControlPath.GetFileName(_item.ServerItem);
_localPath = Path.Combine(_localPath, name);
break;
default:
throw new NotImplementedException();
}
}
var queryForm = (QueryForm)DataCommanderApplication.Instance.MainForm.ActiveMdiChild;
queryForm.AddInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Information, null, $"localPath: {_localPath}"));
if (!VersionControlPath.IsValidPath(serverPath))
{
throw new ArgumentException($"The parameter serverPath '{serverPath}' is invalid.");
}
_queue.Enqueue(_item);
}
if (_queue.Count > 0)
{
var current = _queue.Dequeue();
var values = new object[4];
values[0] = current.ServerItem;
values[1] = current.ItemType;
values[2] = current.CheckinDate;
values[3] = current.ContentLength;
Values = values;
var name = VersionControlPath.GetFileName(current.ServerItem);
string path;
if (_item.ServerItem.Length + 1 <= current.ServerItem.Length)
{
var secondPath = current.ServerItem.Substring(_item.ServerItem.Length + 1);
secondPath = secondPath.Replace(VersionControlPath.Separator, Path.DirectorySeparatorChar);
path = Path.Combine(_localPath, secondPath);
}
else
{
path = _localPath;
}
switch (current.ItemType)
{
case ItemType.File:
Log.Write(LogLevel.Trace, "Downloading {0}...", current.ServerItem);
current.DownloadFile(path);
var checkingDate = current.CheckinDate;
var fileInfo = new FileInfo(path);
fileInfo.LastWriteTime = checkingDate;
fileInfo.Attributes = FileAttributes.ReadOnly;
break;
case ItemType.Folder:
if (!Directory.Exists(path))
{
var directoryInfo = Directory.CreateDirectory(path);
if (!directoryInfo.Exists)
{
throw new ArgumentException($"The directory '{path}' does not exist.");
}
}
var itemSet = current.VersionControlServer.GetItems(current.ServerItem, RecursionType.OneLevel);
foreach (var childItem in itemSet.Items.Skip(1))
{
_queue.Enqueue(childItem);
}
break;
default:
throw new NotImplementedException();
}
read = true;
}
else
{
read = false;
}
}
return(read);
}
//private static int Count( IEnumerable enumerable )
//{
// Assert.IsNotNull( enumerable, "enumerable" );
// IEnumerator enumerator = enumerable.GetEnumerator();
// int count = 0;
// while (enumerator.MoveNext())
// {
// count++;
// }
// return count;
//}
public override bool Read()
{
bool read;
if (_first)
{
_first = false;
var parameters = _command.Parameters;
_path = (string)parameters["path"].Value;
var version = VersionSpec.Latest;
var deletionId = 0;
var recursion = RecursionType.None;
var user = ValueReader.GetValueOrDefault <string>(parameters["user"].Value);
VersionSpec versionFrom = null;
VersionSpec versionTo = null;
var parameter = parameters["maxCount"];
var maxCount = ValueReader.GetValueOrDefault <int>(parameter.Value);
if (maxCount == 0)
{
maxCount = (int)parameter.DefaultValue;
}
const bool includeChanges = true;
var slotMode = ValueReader.GetValueOrDefault <bool>(parameters["slotMode"].Value);
_localPath = ValueReader.GetValueOrDefault <string>(parameters["localPath"].Value);
if (string.IsNullOrEmpty(_localPath))
{
_localPath = Path.GetTempPath();
_localPath += Path.DirectorySeparatorChar;
_localPath += $"getversions [{DateTime.Now.ToString("yyyy-MM-dd HH.mm.ss.fff")}]";
Directory.CreateDirectory(_localPath);
}
var changesets = _command.Connection.VersionControlServer.QueryHistory(_path, version, deletionId, recursion, user, versionFrom, versionTo, maxCount, includeChanges, slotMode);
_enumerator = AsEnumerable(changesets).GetEnumerator();
}
var moveNext = _enumerator.MoveNext();
if (moveNext)
{
var pair = _enumerator.Current;
var changeset = pair.Item1;
var values = new object[]
{
changeset.ChangesetId,
changeset.Committer,
changeset.CreationDate,
changeset.Comment,
null,
null
};
var changeIndex = pair.Item2;
if (changeIndex >= 0)
{
var change = changeset.Changes[changeIndex];
values[4] = change.ChangeType;
values[5] = change.Item.ServerItem;
}
Values = values;
var changesetId = changeset.ChangesetId;
var changeType = string.Empty;
for (var i = 0; i < changeset.Changes.Length; i++)
{
var change = changeset.Changes[i];
Trace.WriteLine(change.ChangeType);
Trace.WriteLine(change.Item.ServerItem);
_path = change.Item.ServerItem;
if (i > 0)
{
changeType += ',';
}
changeType += change.ChangeType;
}
var creationDate = changeset.CreationDate;
var deletionId = 0;
var versionSpec = new ChangesetVersionSpec(changesetId);
var fileName = VersionControlPath.GetFileName(_path);
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
var extension = VersionControlPath.GetExtension(_path);
var localFileName = _localPath + Path.DirectorySeparatorChar + changesetId.ToString().PadLeft(5, '0') + ';' + changeType + ';' + changeset.Committer.Replace('\\', ' ') + extension;
_command.Connection.VersionControlServer.DownloadFile(_path, deletionId, versionSpec, localFileName);
File.SetLastWriteTime(localFileName, creationDate);
File.SetAttributes(localFileName, FileAttributes.ReadOnly);
read = true;
}
else
{
read = false;
}
return(read);
}
private TreeNodeServerItem AttachTreeNode(TreeNode parent, ExtendedItem item)
{
TreeNodeServerItem node;
if (item == null)
{
//the root
node = new TreeNodeServerItem(item, m_sourceControl.TeamProjectCollection.Name, 6, 6);
node.Nodes.Add(new TreeNodeWorking());
}
else
{
string fileName = VersionControlPath.GetFileName(item.TargetServerItem);
if (item.IsBranch)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 2, 2);
}
else
{
node = new TreeNodeServerItem(item, fileName, 1, 1);
}
node.Nodes.Add(new TreeNodeWorking());
}
else if (item.ItemType == ItemType.Folder)
{
if (VersionControlPath.GetFolderDepth(item.TargetServerItem) == 1)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 7, 7);
}
}
else
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 4, 5);
}
}
node.Nodes.Add(new TreeNodeWorking());
}
else if (item.ItemType == ItemType.File)
{
if (item.DeletionId != 0)
{
node = new TreeNodeServerItem(item, fileName, 3, 3);
}
else
{
node = new TreeNodeServerItem(item, fileName, 12, 12);
}
}
else
{
return(null);
}
}
if (parent != null)
{
parent.Nodes.Add(node);
}
else
{
treeView.Nodes.Add(node);
}
if (m_selectedItems.ContainsKey(node.ServerItem))
{
node.ColorSelected();
m_selectedItems[node.ServerItem] = node;
}
return(node);
}
internal static void OpenSolutionWithWorkspace(Workspace workspace, string serverItem, VersionSpec spec)
{
serverItem = VersionControlPath.GetFullPath(serverItem);
WorkingFolder folderForServerItem1;
try
{
folderForServerItem1 = workspace.TryGetWorkingFolderForServerItem(serverItem);
}
catch (Exception ex)
{
Output.Exception(ex);
return;
}
if (folderForServerItem1 != null)
{
if (folderForServerItem1.IsCloaked)
{
int num1 = (int)Error(UIHost.DefaultParentWindow, GuiResources.Format("SolutionIsCloaked", (object)VersionControlPath.GetFileName(serverItem)), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
else
{
try
{
VssProvider.OpenFromSCC(serverItem, FileSpec.GetDirectoryName(folderForServerItem1.LocalItem), spec.DisplayString, VersionControlOpenFromSccOverwrite.openscc_open_local_version);
}
catch (Exception ex)
{
Output.Exception(ex);
}
}
}
else
{
string folderName = VersionControlPath.GetFolderName(serverItem);
using (var dialogSetLocalFolder = (Form)TeamControlFactory.CreateDialogSetLocalFolder(workspace, folderName))
{
if (UIHost.ShowModalDialog((Form)dialogSetLocalFolder) != DialogResult.OK)
{
return;
}
}
try
{
WorkingFolder folderForServerItem2 = workspace.GetWorkingFolderForServerItem(serverItem);
VssProvider.OpenFromSCC(serverItem, FileSpec.GetDirectoryName(folderForServerItem2.LocalItem), spec.DisplayString, VersionControlOpenFromSccOverwrite.openscc_open_local_version);
}
catch (Exception ex)
{
Output.Exception(ex);
}
}
}
/// <summary>
/// Determines the source, target location and worker settings and initializes download workers according to their type.
/// </summary>
/// <param name="dws">The downloader wartermark service.</param>
/// <param name="component">The component node in graph to start download from.</param>
/// <param name="recursive">Indicates if the dependencies should be fetched recursively or not.</param>
/// <param name="force">If set to <c>true</c> it indicates that the get operation is forced and all files have to be overwritten. Otherwise false.</param>
private void DownloadComponent(DownloadWatermarkService dws, IComponent component, bool recursive, bool force)
{
var df = new DownloaderFactory();
var componentAlreadyDownloaded = false;
var settings = new Settings <DownloaderValidSettings>();
IDependencyDownloader worker;
string destLocation;
string targetLocation;
bool removeTempFiles = false;
Logger.Instance().Log(TraceLevel.Info, "{0}: Downloading component {1}#{2} ...", CommandType, component.Name, component.Version);
// Create worker and settings according to type
if (component.Type.Equals(ComponentType.FileShare))
{
var fileShareRootPath = component.GetFieldValue(DependencyProviderValidSettingName.FileShareRootPath);
destLocation = Path.Combine(fileShareRootPath, component.Name.Path, component.Version.Version);
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
relativeTargetPath == null
? Path.GetFullPath(Path.Combine(_defaultDownloadFolder, _defaultRelativeOutputPath))
: Path.GetFullPath(Path.Combine(_defaultDownloadFolder, relativeTargetPath));
LoadFilterSettings(component, settings);
}
else if (component.Type.Equals(ComponentType.VNextBuildResult))
{
var url = component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl);
if (!Uri.IsWellFormedUriString(url, UriKind.Absolute))
{
Logger.Instance().Log(
TraceLevel.Error,
"{0}: Invalid BuildTeamProjectCollectionUrl setting '{1}' was found for component {2}#{3}",
CommandType,
url,
component.Name,
component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for build result control component {0} (BuildTeamProjectCollectionUrl setting)",
component.Name.GetName()));
}
// Connect to tfs server
var tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(url));
tpc.EnsureAuthenticated();
// Connect to version control service
var versionControl = tpc.GetService <VersionControlServer>();
if (versionControl == null)
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Connection to version control server failed for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Could not connect to TFS version control server for team project collection {0}", component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl)));
}
var tpcUrl = new Uri(url);
var connection = new VssConnection(tpcUrl, new VssClientCredentials(true));
var client = connection.GetClient <BuildHttpClient>();
var builds = client.GetBuildsAsync(project: component.Name.TeamProject, type: DefinitionType.Build).Result;
var buildResult = builds.FirstOrDefault(r => r.BuildNumber == component.Version.BuildNumber);
if (buildResult == null)
{
Logger.Instance().Log(TraceLevel.Error, "{0}: No vnext build result could not be determined for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Could not determine build result component {0}", component.Name.GetName()));
}
var artifacts = client.GetArtifactsAsync(component.Name.TeamProject, buildResult.Id).Result;
destLocation = Path.Combine(Path.GetTempPath(), "VNextDM_" + Guid.NewGuid());
Directory.CreateDirectory(destLocation);
removeTempFiles = true;
foreach (var artifact in artifacts)
{
if (artifact.Resource.Type == "FilePath")
{
var sourceDirName = $"{artifact.Resource.Data}/{artifact.Name}";
DirectoryCopy(sourceDirName, destLocation, true);
}
else
{
var content = client.GetArtifactContentZipAsync(component.Name.TeamProject, buildResult.Id, artifact.Name);
using (var zipArchive = new ZipArchive(content.Result))
{
zipArchive.ExtractToDirectory(destLocation);
}
}
}
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
relativeTargetPath == null
? Path.GetFullPath(Path.Combine(_defaultDownloadFolder, _defaultRelativeOutputPath))
: Path.GetFullPath(Path.Combine(_defaultDownloadFolder, relativeTargetPath));
LoadFilterSettings(component, settings);
}
else if (component.Type.Equals(ComponentType.BuildResult))
{
if (!Uri.IsWellFormedUriString(component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl), UriKind.Absolute))
{
Logger.Instance().Log(
TraceLevel.Error,
"{0}: Invalid BuildTeamProjectCollectionUrl setting '{1}' was found for component {2}#{3}",
CommandType,
component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl),
component.Name,
component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for build result control component {0} (BuildTeamProjectCollectionUrl setting)",
component.Name.GetName()));
}
// Connect to tfs server
var tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl)));
tpc.EnsureAuthenticated();
// Connect to version control service
var versionControl = tpc.GetService <VersionControlServer>();
if (versionControl == null)
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Connection to version control server failed for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Could not connect to TFS version control server for team project collection {0}", component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl)));
}
// Connect to build server
var buildServer = tpc.GetService <IBuildServer>();
if (buildServer == null)
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Connection to build server failed for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Could not connect to TFS build server for team project collection {0}", component.GetFieldValue(DependencyProviderValidSettingName.BuildTeamProjectCollectionUrl)));
}
var buildDef = buildServer.GetBuildDefinition(component.Name.TeamProject, component.Name.BuildDefinition);
var buildDetailSpec = buildServer.CreateBuildDetailSpec(buildDef);
buildDetailSpec.BuildNumber = component.Version.BuildNumber;
buildDetailSpec.InformationTypes = new string[] { };
var buildResult = buildServer.QueryBuilds(buildDetailSpec);
if (buildResult == null || buildResult.Builds == null || buildResult.Builds.Length == 0)
{
Logger.Instance().Log(TraceLevel.Error, "{0}: No build result could not be determined for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Could not determine drop location for build result component {0}", component.Name.GetName()));
}
// Determine source location
var dropLocation = buildResult.Builds[0].DropLocation; // TODO dga: Is this a bug? it returns localhost for the computer name while we are not running this code on the server (I guess)?
if (string.IsNullOrEmpty(dropLocation))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Drop location could not be determined for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format("! Could not determine drop location for build result component {0}", component.Name.GetName()));
}
destLocation = dropLocation;
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
relativeTargetPath == null
? Path.GetFullPath(Path.Combine(_defaultDownloadFolder, _defaultRelativeOutputPath))
: Path.GetFullPath(Path.Combine(_defaultDownloadFolder, relativeTargetPath));
LoadFilterSettings(component, settings);
}
else if (component.Type.Equals(ComponentType.SourceControl))
{
if (!Uri.IsWellFormedUriString(component.GetFieldValue(DependencyProviderValidSettingName.WorkspaceTeamProjectCollectionUrl), UriKind.Absolute))
{
Logger.Instance().Log(
TraceLevel.Error,
"{0}: Invalid WorkspaceTeamProjectCollectionUrl setting '{1}' was found for component {2}#{3}",
CommandType,
component.GetFieldValue(DependencyProviderValidSettingName.WorkspaceTeamProjectCollectionUrl),
component.Name,
component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for source control component {0} (WorkspaceTeamProjectCollectionUrl setting)",
component.Name.GetName()));
}
var workspaceName = component.GetFieldValue(DependencyProviderValidSettingName.WorkspaceName);
if (string.IsNullOrEmpty(workspaceName))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: WorkspaceName setting was not specified for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for source control component {0} (WorkspaceName setting)",
component.Name.GetName()));
}
var workspaceOwner = component.GetFieldValue(DependencyProviderValidSettingName.WorkspaceOwner);
if (string.IsNullOrEmpty(workspaceOwner))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: WorkspaceOwner setting was not specified for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for source control component {0} (WorkspaceOwner setting)",
component.Name.GetName()));
}
destLocation = component.Name.ToString();
settings.AddSetting(new KeyValuePair <DownloaderValidSettings, string>(DownloaderValidSettings.VersionString, component.Version.ToString()));
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
Path.GetFullPath(
relativeTargetPath == null
? Path.Combine(_defaultDownloadFolder, "..", VersionControlPath.GetFileName(component.Name.ToString()))
: Path.Combine(_defaultDownloadFolder, relativeTargetPath));
}
else if (component.Type.Equals(ComponentType.SourceControlCopy))
{
destLocation = component.Name.ToString();
settings.AddSetting(new KeyValuePair <DownloaderValidSettings, string>(DownloaderValidSettings.VersionString, component.Version.ToString()));
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
Path.GetFullPath(
relativeTargetPath == null
? Path.Combine(_defaultDownloadFolder, "..", VersionControlPath.GetFileName(component.Name.ToString()))
: Path.Combine(_defaultDownloadFolder, relativeTargetPath));
LoadFilterSettings(component, settings);
}
else if (component.Type.Equals(ComponentType.BinaryRepository))
{
var repositoryTeamProject = component.GetFieldValue(DependencyProviderValidSettingName.BinaryRepositoryTeamProject);
if (string.IsNullOrEmpty(repositoryTeamProject))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: BinaryRepositoryTeamProject setting was not specified for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(
string.Format(
" ! Invalid download information was found for binary repository component {0} (BinaryRepositoryTeamProject setting)",
component.Name.GetName()));
}
destLocation = VersionControlPath.Combine(VersionControlPath.Combine(VersionControlPath.Combine(VersionControlPath.RootFolder, repositoryTeamProject), component.Name.GetName()), component.Version.GetVersion());
settings.AddSetting(new KeyValuePair <DownloaderValidSettings, string>(DownloaderValidSettings.VersionString, VersionSpec.Latest.DisplayString));
var relativeOutputPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation = Path.GetFullPath(
relativeOutputPath == null
? Path.Combine(_defaultDownloadFolder, _defaultRelativeOutputPath)
: Path.Combine(_defaultDownloadFolder, relativeOutputPath));
LoadFilterSettings(component, settings);
}
else if (component.Type.Equals(ComponentType.Subversion))
{
destLocation = string.Format("{0}", component.Name);
settings.AddSetting(new KeyValuePair <DownloaderValidSettings, string>(DownloaderValidSettings.VersionString, component.Version.ToString()));
var relativeTargetPath = component.GetFieldValue(DependencyProviderValidSettingName.RelativeOutputPath);
targetLocation =
relativeTargetPath == null
? Path.GetFullPath(Path.Combine(_defaultDownloadFolder, _defaultRelativeOutputPath))
: Path.GetFullPath(Path.Combine(_defaultDownloadFolder, relativeTargetPath));
LoadFilterSettings(component, settings);
}
else
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Unknown dependency type '{1}' was found in dependency graph", CommandType, component.Type.GetType());
throw new DependencyServiceException(" ! Invalid dependency node found in graph!");
}
//Determine Multi-Site path for BuildResult and FileShare-Provider
if (component.Type.Equals(ComponentType.FileShare) || (component.Type.Equals(ComponentType.BuildResult)))
{
destLocation = DetermineMultiSiteSourceLocation(destLocation);
}
if (string.IsNullOrEmpty(destLocation))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Source location was not set for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Error occured while preparing to download component {0} (Source location was not set)", component.Name.GetName()));
}
if (string.IsNullOrEmpty(targetLocation))
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Target location was not set for component {1}#{2}", CommandType, component.Name, component.Version);
throw new DependencyServiceException(string.Format(" ! Error occured while preparing to download component {0} (Destination location was not set)", component.Name.GetName()));
}
// Download files
try
{
IDependencyDownloaderWatermark wm = null;
try
{
worker = df.GetDownloader(component);
wm = dws.Load(component.Name.GetName(), component.Version.GetVersion()) ?? new DownloaderWatermark(worker);
worker.Download(destLocation, targetLocation, wm, force, settings);
}
finally
{
if (null != wm)
{
dws.Save(wm, component.Name.GetName(), component.Version.GetVersion());
}
if (removeTempFiles)
{
Directory.Delete(destLocation, true);
}
}
}
catch (Exception e)
{
if (e is DependencyServiceException)
{
throw;
}
// ReSharper disable RedundantIfElseBlock
else if (e is ComponentAlreadyDownloadedException)
// ReSharper restore RedundantIfElseBlock
{
componentAlreadyDownloaded = true;
}
else
{
Logger.Instance().Log(TraceLevel.Error, "{0}: Exception {1} occured while downloading files: {2}", CommandType, e, e.Message);
throw new DependencyServiceException(string.Format(" ! Download of component {0} failed ({1})", component.Name.GetName(), e.Message));
}
}
// Log download
if (!_silentMode)
{
_logger.LogMsg(
!componentAlreadyDownloaded
? string.Format(
" * Component {0} (Version:{1}) downloaded to target directory {2}",
component.Name.GetName(),
component.Version.GetVersion(),
targetLocation)
: string.Format(
" * Skipped component {0} (Version:{1}). Already present in target directory {2}",
component.Name.GetName(),
component.Version.GetVersion(),
targetLocation));
}
Logger.Instance().Log(
TraceLevel.Info,
!componentAlreadyDownloaded
? "{0}: Component {1}#{2} successfully downloaded to target directory {3}"
: "{0}: Component {1}#{2} download was skipped. Already present in target directory {3}",
CommandType,
component.Name,
component.Version,
targetLocation);
}
private TreeNode SelectFolder(TreeNodeCollection nodes, List <string> folderParts)
{
TreeNode result = null;
var nodesToRecurse = new List <TreeNode>();
string folderToFound = folderParts[0];
foreach (TreeNode node in nodes)
{
//AfterExpand(node);
Application.DoEvents();
if (stopQuerying)
{
break;
}
var serverPath = node.Tag as string;
string serverItemName = VersionControlPath.GetFileName(serverPath);
bool equal = VersionControlPath.Equals(folderToFound, serverItemName);
if (equal)
{
result = node;
SetSingleSelectedNode(node, true);
folderParts.RemoveAt(0);
nodesToRecurse.Clear();
}
else
{
//AfterExpand(node);
}
if (folderParts.Count > 0 && node.Nodes.Count > 0)
{
nodesToRecurse.Add(node);
}
if (equal)
{
break;
}
}
if (nodesToRecurse.Count > 0 && folderParts.Count > 0)
{
foreach (TreeNode node in nodesToRecurse)
{
AfterExpand(node);
result = SelectFolder(node.Nodes, folderParts);
if (result != null)
{
break;
}
}
}
if (result != null)
{
AfterExpand(result);
// disableExpandAutoLoad = true;
// try
// {
// TreeNode parent = result.Parent;
// while (parent != null)
// {
// parent.Expand();
// parent = parent.Parent;
// }
// }
// finally
// {
// disableExpandAutoLoad = false;
// }
}
return(result);
}
