internal static string FindVcsRootPath()
{
try
{
Assembly ncrunchAssembly = AppDomain.CurrentDomain.Load("NCrunch.Framework");
Type ncrunchType =
ncrunchAssembly.GetTypes()
.FirstOrDefault(
type => type.Name.Equals("NCrunchEnvironment", StringComparison.InvariantCultureIgnoreCase));
MethodInfo method = ncrunchType?.GetMethod("GetOriginalSolutionPath");
string originalSolutionPath = method?.Invoke(null, null) as string;
if (!string.IsNullOrWhiteSpace(originalSolutionPath))
{
DirectoryInfo parent = new DirectoryInfo(originalSolutionPath).Parent;
return(VcsPathHelper.FindVcsRootPath(parent.FullName));
}
}
catch (Exception)
{
// ignored
}
return(VcsPathHelper.FindVcsRootPath());
}
private async Task <string> GetBaseDirectoryAsync(BootstrapStartOptions startOptions)
{
string baseDir;
if (!string.IsNullOrWhiteSpace(startOptions.BaseDir) && Directory.Exists(startOptions.BaseDir))
{
_logger.Write($"Using base directory '{startOptions.BaseDir}' from start options", _Prefix);
baseDir = startOptions.BaseDir;
}
else
{
if (IsBetterRunOnLocalTempStorage() && await IsCurrentDirectoryClonableAsync())
{
string clonedDirectory = await CloneDirectoryAsync();
baseDir = clonedDirectory;
}
else
{
baseDir = VcsPathHelper.FindVcsRootPath();
}
}
return(baseDir);
}
private async Task <ExitCode> ExecuteAsync(ImmutableArray <string> args)
{
bool whatIf = args.Any(arg => arg.Equals(ConfigurationKeys.WhatIf, StringComparison.OrdinalIgnoreCase));
bool deleteEmptyDirectories = args.Any(arg => arg.Equals(
ConfigurationKeys.DeleteEmptyDirectories,
StringComparison.OrdinalIgnoreCase));
ImmutableArray <string> exclusions = new[] { ".git", ".vs" }.ToImmutableArray();
ImmutableArray <string> targets = new[] { "obj", "bin", "temp", "tmp", "artifacts", "arbor.x" }
.ToImmutableArray();
string baseDirectory = args.FirstOrDefault(arg => !arg.StartsWith(
"-",
StringComparison.OrdinalIgnoreCase)) ??
VcsPathHelper.FindVcsRootPath(Directory.GetCurrentDirectory());
ImmutableArray <string> fileExtensionsToDelete = new[] { ".tmp", ".cache", ".orig" }.ToImmutableArray();
var options = new Options(
baseDirectory,
exclusions,
targets,
fileExtensionsToDelete,
whatIf,
deleteEmptyDirectories);
return(await ExecuteAsync(options));
}
private async Task <BootstrapStartOptions> StartWithDebuggerAsync([NotNull] string[] args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
string baseDir = VcsPathHelper.FindVcsRootPath(AppDomain.CurrentDomain.BaseDirectory);
var tempDirectory = new DirectoryInfo(Path.Combine(
Path.GetTempPath(),
$"{DefaultPaths.TempPathPrefix}_Boot_Debug",
DateTime.Now.ToString("yyyyMMddHHmmssfff")));
tempDirectory.EnsureExists();
WriteDebug($"Using temp directory '{tempDirectory}'");
await DirectoryCopy.CopyAsync(baseDir, tempDirectory.FullName);
Environment.SetEnvironmentVariable(WellKnownVariables.BranchNameVersionOverrideEnabled, "true");
Environment.SetEnvironmentVariable(WellKnownVariables.VariableOverrideEnabled, "true");
var bootstrapStartOptions = new BootstrapStartOptions(
tempDirectory.FullName,
true,
"refs/heads/develop/12.34.56");
WriteDebug("Starting with debugger attached");
return(bootstrapStartOptions);
}
public static string FindVcsRootPath()
{
try
{
Assembly ncrunchAssembly = AppDomain.CurrentDomain.Load("NCrunch.Framework");
Type ncrunchType =
ncrunchAssembly.GetTypes()
.FirstOrDefault(
type => type.Name.Equals("NCrunchEnvironment",
StringComparison.InvariantCultureIgnoreCase));
MethodInfo method = ncrunchType?.GetMethod("GetOriginalSolutionPath");
string originalSolutionPath = method?.Invoke(null, null) as string;
if (!string.IsNullOrWhiteSpace(originalSolutionPath))
{
DirectoryInfo parent = new DirectoryInfo(originalSolutionPath).Parent;
if (parent != null)
{
return(VcsPathHelper.FindVcsRootPath(parent.FullName));
}
}
}
catch (Exception ex)
{
#if DEBUG
Console.WriteLine("Could not find NCrunch original solution path, {0}", ex);
#endif
}
return(VcsPathHelper.FindVcsRootPath());
}
private async Task <bool> IsCurrentDirectoryClonableAsync()
{
if (!_directoryCloneEnabled)
{
_logger.WriteVerbose("Directory clone is disabled");
return(false);
}
_logger.WriteVerbose("Directory clone is enabled");
string sourceRoot = VcsPathHelper.TryFindVcsRootPath();
if (string.IsNullOrWhiteSpace(sourceRoot))
{
_logger.WriteWarning("Could not find source root", _Prefix);
return(false);
}
bool isClonable = false;
string gitExePath = GitHelper.GetGitExePath(_logger);
if (!string.IsNullOrWhiteSpace(gitExePath))
{
string gitDir = Path.Combine(sourceRoot, ".git");
var statusAllArguments = new[]
{
$"--git-dir={gitDir}",
$"--work-tree={sourceRoot}",
"status"
};
var argumentVariants = new List <string[]> {
new[] { "status" }, statusAllArguments
};
foreach (string[] argumentVariant in argumentVariants)
{
ExitCode statusExitCode = await ProcessRunner.ExecuteAsync(
gitExePath,
arguments : argumentVariant,
standardOutLog : _logger.WriteVerbose,
standardErrorAction : _logger.WriteVerbose,
toolAction : _logger.Write,
verboseAction : _logger.WriteVerbose);
if (statusExitCode.IsSuccess)
{
isClonable = true;
break;
}
}
}
_logger.WriteVerbose($"Is directory clonable: {isClonable}");
return(isClonable);
}
public static string?TryFindVcsRootPath(Action <string>?logger = null)
{
if (NCrunchEnvironment.NCrunchIsResident())
{
var originalSolutionFileInfo = new FileInfo(NCrunchEnvironment.GetOriginalSolutionPath());
return(VcsPathHelper.TryFindVcsRootPath(originalSolutionFileInfo.Directory?.FullName, logger));
}
return(VcsPathHelper.TryFindVcsRootPath(logger: logger));
}
public static string FindVcsRootPath()
{
if (NCrunchEnvironment.NCrunchIsResident())
{
var directory = new FileInfo(NCrunchEnvironment.GetOriginalSolutionPath()).Directory;
return(VcsPathHelper.FindVcsRootPath(directory?.FullName));
}
return(VcsPathHelper.FindVcsRootPath());
}
public static string FindVcsRootPath(string baseDir = null)
{
if (NCrunchEnvironment.NCrunchIsResident())
{
var fileInfo = new FileInfo(NCrunchEnvironment.GetOriginalSolutionPath());
return(VcsPathHelper.FindVcsRootPath(fileInfo.Directory?.FullName));
}
return(VcsPathHelper.FindVcsRootPath(baseDir));
}
public Task <IEnumerable <IVariable> > GetEnvironmentVariablesAsync(
ILogger logger,
IReadOnlyCollection <IVariable> buildVariables,
CancellationToken cancellationToken)
{
string existingSourceRoot =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.SourceRoot, string.Empty);
string existingToolsDirectory =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.ExternalTools, string.Empty);
string sourceRoot;
if (!string.IsNullOrWhiteSpace(existingSourceRoot))
{
if (!Directory.Exists(existingSourceRoot))
{
throw new InvalidOperationException(
$"The defined variable {WellKnownVariables.SourceRoot} has value set to '{existingSourceRoot}' but the directory does not exist");
}
sourceRoot = existingSourceRoot;
}
else
{
sourceRoot = VcsPathHelper.FindVcsRootPath();
}
DirectoryInfo tempPath = new DirectoryInfo(Path.Combine(sourceRoot, "temp")).EnsureExists();
var variables = new List <IVariable>
{
new EnvironmentVariable(
WellKnownVariables.TempDirectory,
tempPath.FullName)
};
if (string.IsNullOrWhiteSpace(existingSourceRoot))
{
variables.Add(new EnvironmentVariable(WellKnownVariables.SourceRoot, sourceRoot));
}
if (string.IsNullOrWhiteSpace(existingToolsDirectory))
{
DirectoryInfo externalTools =
new DirectoryInfo(Path.Combine(sourceRoot, "build", "Arbor.X", "tools", "external")).EnsureExists();
variables.Add(new EnvironmentVariable(
WellKnownVariables.ExternalTools,
externalTools.FullName));
}
return(Task.FromResult <IEnumerable <IVariable> >(variables));
}
public static string GetRootDirectory(string?basePath = null)
{
string originalSolutionPath = NCrunchEnvironment.GetOriginalSolutionPath();
if (!string.IsNullOrWhiteSpace(originalSolutionPath))
{
var fileInfo = new FileInfo(originalSolutionPath);
return(VcsPathHelper.FindVcsRootPath(fileInfo.Directory?.FullName ?? Directory.GetCurrentDirectory()));
}
return(VcsPathHelper.FindVcsRootPath(basePath ?? new FileInfo(typeof(VcsTestPathHelper).Assembly.Location).DirectoryName ?? Directory.GetCurrentDirectory()));
}
public static string GetRootDirectory()
{
string originalSolutionPath = NCrunch.Framework.NCrunchEnvironment.GetOriginalSolutionPath();
if (!string.IsNullOrWhiteSpace(originalSolutionPath))
{
var fileInfo = new FileInfo(originalSolutionPath);
return(VcsPathHelper.FindVcsRootPath(fileInfo.Directory?.FullName ?? Directory.GetCurrentDirectory()));
}
return(VcsPathHelper.FindVcsRootPath(Directory.GetCurrentDirectory()));
}
private async Task <string> CloneDirectoryAsync()
{
string targetDirectoryPath = Path.Combine(
Path.GetTempPath(),
DefaultPaths.TempPathPrefix,
"R",
Guid.NewGuid().ToString().Substring(0, 8));
var targetDirectory = new DirectoryInfo(targetDirectoryPath);
targetDirectory.EnsureExists();
string gitExePath = GitHelper.GetGitExePath(_logger);
string sourceRoot = VcsPathHelper.TryFindVcsRootPath();
IEnumerable <string> cloneArguments = new List <string>
{
"clone",
sourceRoot,
targetDirectory.FullName
};
_logger.WriteVerbose($"Using temp storage to clone: '{targetDirectory.FullName}'", _Prefix);
ExitCode cloneExitCode = await ProcessHelper.ExecuteAsync(
gitExePath,
cloneArguments,
_logger,
addProcessNameAsLogCategory : true,
addProcessRunnerCategory : true,
parentPrefix : _Prefix);
if (!cloneExitCode.IsSuccess)
{
throw new InvalidOperationException(
$"Could not clone directory '{sourceRoot}' to '{targetDirectory.FullName}'");
}
return(targetDirectory.FullName);
}
public static ExitCode SetEnvironmentVariablesFromFile([NotNull] ILogger logger, string fileName)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
string currentDirectory = VcsPathHelper.FindVcsRootPath();
if (currentDirectory == null)
{
logger.WriteError("Could not find source root");
return(ExitCode.Failure);
}
var fileInfo = new FileInfo(Path.Combine(currentDirectory, fileName));
if (!fileInfo.Exists)
{
logger.WriteWarning(
$"The environment variable file '{fileInfo}' does not exist, skipping setting environment variables from file '{fileName}'");
return(ExitCode.Success);
}
ConfigurationItems configurationItems;
try
{
configurationItems = new KVConfiguration.JsonConfiguration.JsonFileReader(fileInfo.FullName)
.GetConfigurationItems();
}
catch (Exception ex) when(!ex.IsFatal())
{
logger.WriteError($"Could not parse key value pairs in file '{fileInfo.FullName}', {ex}");
return(ExitCode.Failure);
}
if (configurationItems == null)
{
logger.WriteError($"Could not parse key value pairs in file '{fileInfo.FullName}'");
return(ExitCode.Failure);
}
foreach (KeyValue keyValuePair in configurationItems.Keys)
{
try
{
Environment.SetEnvironmentVariable(keyValuePair.Key, keyValuePair.Value);
logger.WriteDebug(
$"Set environment variable with key '{keyValuePair.Key}' and value '{keyValuePair.Value}' from file '{fileName}'");
}
catch (Exception ex) when(!ex.IsFatal())
{
logger.WriteError(
$"Could not set environment variable with key '{keyValuePair.Key}' and value '{keyValuePair.Value}' from file '{fileName}'");
return(ExitCode.Failure);
}
}
logger.Write($"Used configuration values from file '{fileName}'");
return(ExitCode.Success);
}
