internal static string GetToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "ReportGenerator",
packageExecutable: "ReportGenerator.exe",
framework: framework));
}
internal static string GetToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "dotnet-sonarscanner|MSBuild.SonarQube.Runner.Tool",
packageExecutable: "SonarScanner.MSBuild.dll|SonarScanner.MSBuild.exe",
framework: framework));
}
public async Task DotnetCliTool_BasicToolRestore()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger = new TestLogger();
var dgFile = new DependencyGraphSpec();
var spec = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, "fake.csproj"),
"a",
VersionRange.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"));
dgFile.AddProject(spec);
dgFile.AddRestore(spec.Name);
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
var path = pathResolver.GetLockFilePath(
"a",
NuGetVersion.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.PackageSource, new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
// Act
var result = await CommandsTestUtility.RunSingleRestore(dgFile, pathContext, logger);
// Assert
Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.True(File.Exists(path));
}
}
static void RegisterMSBuildFromDotNet()
{
var dotnet = ToolPathResolver.TryGetEnvironmentExecutable("DOTNET_EXE") ??
ToolPathResolver.GetPathExecutable("dotnet");
string TryFromBasePath()
{
var output = ProcessTasks.StartProcess(dotnet, "--info", logInvocation: false, logOutput: false).AssertZeroExitCode().Output;
return(output
.Select(x => x.Text.Trim())
.SingleOrDefault(x => x.StartsWith("Base Path:"))
?.TrimStart("Base Path:").Trim());
}
string TryFromSdkList()
{
var output = ProcessTasks.StartProcess(dotnet, "--list-sdks", logInvocation: false, logOutput: false).AssertZeroExitCode().Output;
var latestInstalledSdkParts = output.Last().Text.Split(' ');
return((AbsolutePath)latestInstalledSdkParts.ElementAt(1).Trim('[', ']') / latestInstalledSdkParts.ElementAt(0));
}
var sdkDirectory = (AbsolutePath)(TryFromBasePath() ?? TryFromSdkList());
MSBuildLocator.RegisterMSBuildPath(sdkDirectory);
}
internal static string GetToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "OctoVersion.Tool",
packageExecutable: "OctoVersion.Tool.dll",
framework: framework));
}
internal static string GetProcessToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "OctopusTools|Octopus.DotNet.Cli",
packageExecutable: "Octo.exe|dotnet-octo.dll",
framework: framework));
}
/// <summary>
/// Ensures that GitVersion has a system wide environment variable set. If not it will attempt to locate it and set the environment variable.
/// </summary>
/// <param name="targetEnvironment">Whether to target user or system/machine setting. You must run the app as administrator to use Machine.</param>
/// <returns></returns>
public static bool ValidateGetVersionEnvVariable(EnvironmentVariableTarget targetEnvironment = EnvironmentVariableTarget.Process)
{
string envGitVersion = Environment.GetEnvironmentVariable(ENV_GITVERSION);
if (envGitVersion == null)
{
Logger.Warn("GitVersion environment variable not found. Will attempt to set.");
string cmd = "where";
string cmdArgs = "gitversion.exe";
IProcess process = ProcessTasks.StartProcess(cmd, cmdArgs, logOutput: true);
process.AssertWaitForExit();
ControlFlow.Assert(process.ExitCode == 0, "The " + ENV_GITVERSION + " environment variable is not set and attempt to fix it, failed because it appears GitVersion is not installed on the local machine. Install it and then re-run and/or set the environment variable manually");
// Set the environment variable now that we found it
string value = process.Output.First().Text;
Environment.SetEnvironmentVariable(ENV_GITVERSION, value, targetEnvironment);
envGitVersion = Environment.GetEnvironmentVariable(ENV_GITVERSION);
string val = ToolPathResolver.TryGetEnvironmentExecutable("GITVERSION_EXE");
Console.WriteLine("Toolpathresolver: " + val);
Console.WriteLine();
string msg =
"GitVersion Environment variable has been set! You will need to ensure you close the current console window before continuing to pickup the change.";
Console.WriteWithGradient(msg, Color.Fuchsia, Color.Yellow, 16);
Console.ReplaceAllColorsWithDefaults();
}
return(true);
}
private string GetAssetsFilePath(LockFile lockFile)
{
var projectLockFilePath = _request.LockFilePath;
if (string.IsNullOrEmpty(projectLockFilePath))
{
if (_request.ProjectStyle == ProjectStyle.PackageReference ||
_request.ProjectStyle == ProjectStyle.Standalone)
{
projectLockFilePath = Path.Combine(_request.RestoreOutputPath, LockFileFormat.AssetsFileName);
}
else if (_request.ProjectStyle == ProjectStyle.DotnetCliTool)
{
var toolName = ToolRestoreUtility.GetToolIdOrNullFromSpec(_request.Project);
var lockFileLibrary = ToolRestoreUtility.GetToolTargetLibrary(lockFile, toolName);
if (lockFileLibrary != null)
{
var version = lockFileLibrary.Version;
var toolPathResolver = new ToolPathResolver(_request.PackagesDirectory);
projectLockFilePath = toolPathResolver.GetLockFilePath(
toolName,
version,
lockFile.Targets.First().TargetFramework);
}
}
else
{
projectLockFilePath = Path.Combine(_request.Project.BaseDirectory, LockFileFormat.LockFileName);
}
}
return(Path.GetFullPath(projectLockFilePath));
}
internal static string GetToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "xunit.runner.console",
packageExecutable: EnvironmentInfo.Is64Bit ? "xunit.console.exe" : "xunit.console.x86.exe",
framework));
}
/// <inheritdoc />
public void OnBuildCreated(NukeBuild build, IReadOnlyCollection <ExecutableTarget> executableTargets)
{
if (!NukeBuild.IsLocalBuild)
{
return;
}
// We only care on local machines
if (HookNames.Any(hook => !FileExists(NukeBuild.RootDirectory / $".git/hooks/{hook}")))
{
Logger.Info("Git hooks not found...");
if (FileExists(NukeBuild.RootDirectory / "package.json"))
{
Logger.Info("package.json found running npm install to see if that installs any hooks");
ProcessTasks.StartProcess(ToolPathResolver.GetPathExecutable("npm"), "install").AssertWaitForExit()
.AssertZeroExitCode();
}
}
foreach (var hook in HookNames)
{
if (!FileExists(NukeBuild.RootDirectory / $".git/hooks/{hook}"))
{
Logger.Info($"Was unable to install {hook} hook.");
}
}
}
internal static string GetToolPath(string framework = null)
{
return(ToolPathResolver.GetPackageExecutable(
packageId: "GitVersion.Tool|GitVersion.CommandLine",
packageExecutable: "GitVersion.dll|GitVersion.exe",
framework: framework));
}
public static void ManualToolresolvingMeandering()
{
string TryGetPathExe(string exe)
{
try
{
return(ToolPathResolver.GetPathExecutable(exe));
}
catch
{
}
return(string.Empty);
}
string TryGetPathToolExe(string exe)
{
try
{
return(ToolPathResolver.TryGetEnvironmentExecutable(exe));
}
catch
{
}
return(string.Empty);
}
//ToolResolver.GetPathTool(exe)
//ToolResolver.GetPathTool("appveyor");
//Tool myTool = ToolResolver.GetPathTool(exe)
void TryAndGetPathEXEAndPrint(string exe)
{
Logger.Normal($"Trying to get exe {exe}: '{TryGetPathExe(exe)}'");
}
var executables = new[] { "DOES NOT EXIST", "powershell", "bash" };
//ToolPathResolver.GetPathExecutable - get something on the path
//vs TryGetEnvironmentExecutable //ToolPathResolver.TryGetEnvironmentExecutable -- this will get an exe defined by an enviornment variable
//vs ToolResolver.GetPathTool(exe) - get a tool in the user's path based on
executables.ForEach(TryAndGetPathEXEAndPrint);
Logger.Normal($"Comspec is set up by something on windows systems as a standard exe tool, so here is the path {TryGetPathToolExe("ComSpec")}");
Tool git = ToolResolver.GetPathTool("git");
#pragma warning disable 168
//just showing that ControlFlow.Fail throws an "Exception" object that is not sub-typed
try
{
Tool doesNotExist = ToolResolver.GetPathTool("DOES NOT EXIST");
}catch (Exception e) {}
try
{
ControlFlow.Fail("TEST same as trying to get non existent tool with tool resolver");
}catch (Exception e) {}
#pragma warning restore 168
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="rootPath"></param>
/// <param name="gitVersion"></param>
public GitProcessor(AbsolutePath rootPath)
{
RootDirectory = rootPath;
DotNetPath = ToolPathResolver.GetPathExecutable("dotnet");
IdentifyMainBranch();
Fetch_GitVersion();
PrintGitCommandVersion();
}
public async Task DotnetCliTool_BasicToolRestore_DifferentVersionRanges()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger = new TestLogger();
var dgFile = new DependencyGraphSpec();
var versions = new List <VersionRange>();
var limit = 100;
for (int i = 0; i < limit; i++)
{
var version = VersionRange.Parse($"{i + 1}.0.0");
versions.Add(version);
var spec = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, $"fake{i}.csproj"),
"a",
version,
NuGetFramework.Parse("netcoreapp1.0"));
dgFile.AddProject(spec);
dgFile.AddRestore(spec.Name);
}
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
foreach (var version in versions)
{
await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.PackageSource, new PackageIdentity("a", version.MinVersion));
}
// Act
var results = await CommandsTestUtility.RunRestore(dgFile, pathContext, logger);
// Assert
Assert.Equal(limit, results.Count);
foreach (var result in results)
{
Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
}
foreach (var version in versions)
{
var path = pathResolver.GetLockFilePath(
"a",
version.MinVersion,
NuGetFramework.Parse("netcoreapp1.0"));
Assert.True(File.Exists(path));
}
}
}
private string GetToolPath()
{
// Linux based system are case sensative.
// This class was extended in order to lowercase the .dll/.exe
// filename being resolved.
// TODO: fix in Nuke.Common repo
return(ToolPathResolver.GetPackageExecutable(
"GitVersion.Tool|GitVersion.CommandLine",
"gitversion.dll|gitversion.exe", null, Framework));
}
private static void Initialize(string workingDirectory)
{
var dotnet = ToolPathResolver.TryGetEnvironmentExecutable("DOTNET_EXE") ??
ToolPathResolver.GetPathExecutable("dotnet");
var output = ProcessTasks.StartProcess(dotnet, "--info", workingDirectory, logOutput: false).AssertZeroExitCode().Output;
var basePath = (PathConstruction.AbsolutePath)output
.Select(x => x.Text.Trim())
.Single(x => x.StartsWith("Base Path:"))
.TrimStart("Base Path:").Trim();
EnvironmentInfo.SetVariable("MSBUILD_EXE_PATH", basePath / "MSBuild.dll");
}
private static Process Build(string buildScript, string arguments)
{
return(Process.Start(
new ProcessStartInfo
{
FileName = EnvironmentInfo.IsWin
? ToolPathResolver.GetPathExecutable("powershell")
: ToolPathResolver.GetPathExecutable("bash"),
Arguments = EnvironmentInfo.IsWin
? $"-ExecutionPolicy ByPass -NoProfile -File {buildScript} {arguments}"
: $"{buildScript} {arguments}"
}).NotNull());
}
/// <summary>
/// Constructor
/// </summary>
public PreStage_ConvertToSlugCI(CISession ciSession) : base(BuildStageStatic.PRESTAGE_CONVERT_TO_SLUGCI, ciSession)
{
// Set expected directories.
ExpectedSolutionPath = CISession.SourceDirectory;
DotNetPath = ToolPathResolver.GetPathExecutable("dotnet");
if (ciSession.IsFastStart)
{
// TODO - Need to restore this at some point, but needs to write to a AddOutputStage instead of screen. It interferes with prompting.
// Misc.WriteSubHeader("FastStart: Skipping normal checks and validations");
}
}
public async Task DotnetCliTool_BasicToolRestore_WithDuplicates()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger = new TestLogger();
var dgFile = new DependencyGraphSpec();
for (int i = 0; i < 10; i++)
{
var spec = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, "fake.csproj"),
"a",
VersionRange.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"),
pathContext.UserPackagesFolder,
new List <string>()
{
pathContext.FallbackFolder
},
new List <PackageSource>()
{
new PackageSource(pathContext.PackageSource)
},
projectWideWarningProperties: null);
dgFile.AddProject(spec);
dgFile.AddRestore(spec.Name);
}
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
var path = pathResolver.GetLockFilePath(
"a",
NuGetVersion.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(pathContext.PackageSource, new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
// Act
var results = await CommandsTestUtility.RunRestore(dgFile, pathContext, logger);
// Assert
// This should have been de-duplicated
Assert.Equal(1, results.Count);
var result = results.Single();
Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.True(File.Exists(path));
}
}
private static Process Build(string buildScript, string arguments)
{
var startInfo =
new ProcessStartInfo
{
FileName = EnvironmentInfo.IsWin
? ToolPathResolver.GetPathExecutable("powershell")
: ToolPathResolver.GetPathExecutable("bash"),
Arguments = EnvironmentInfo.IsWin
? $"-ExecutionPolicy ByPass -NoProfile -File {buildScript.DoubleQuoteIfNeeded()} {arguments}"
: $"{buildScript} {arguments}"
};
startInfo.Environment[Constants.GlobalToolVersionEnvironmentKey] = typeof(Program).Assembly.GetVersionText();
startInfo.Environment[Constants.GlobalToolStartTimeEnvironmentKey] = DateTime.Now.ToString("O");
return(Process.Start(startInfo).NotNull());
}
public void ToolPathResolver_BuildsOriginalcaseCacheFileDirectoryPath()
{
// Arrange
var target = new ToolPathResolver("packages", isLowercase: false);
var expected = Path.Combine(
"packages",
".tools",
"packagea",
"3.1.4-BETA",
"netstandard1.3");
// Act
var actual = target.GetToolDirectoryPath("packagea", NuGetVersion.Parse("3.1.4-BETA"), NuGetFramework.Parse("netstandard1.3"));
// Assert
Assert.Equal(expected, actual);
}
/// <summary>
/// This method will resolve the cache/lock file paths for the tool if available in the cache
/// This method will set the CacheFilePath and the LockFilePath in the RestoreMetadat if a matching tool is available
/// </summary>
public static void UpdateRequestBestMatchingToolPathsIfAvailable(RestoreRequest request)
{
if (request.ProjectStyle == ProjectStyle.DotnetCliTool)
{
// Resolve the lock file path if it exists
var toolPathResolver = new ToolPathResolver(request.PackagesDirectory);
var toolDirectory = toolPathResolver.GetBestToolDirectoryPath(
ToolRestoreUtility.GetToolIdOrNullFromSpec(request.Project),
request.Project.TargetFrameworks.First().Dependencies.First().LibraryRange.VersionRange,
request.Project.TargetFrameworks.SingleOrDefault().FrameworkName);
if (toolDirectory != null) // Only set the paths if a good enough match was found.
{
request.Project.RestoreMetadata.CacheFilePath = NoOpRestoreUtilities.GetToolCacheFilePath(toolDirectory, ToolRestoreUtility.GetToolIdOrNullFromSpec(request.Project));
request.LockFilePath = toolPathResolver.GetLockFilePath(toolDirectory);
}
}
}
private void GenerateClient(string language)
{
var generatorPath = SourceDirectory / "Dangl.AVACloudClientGenerator" / "bin" / Configuration / "net5.0" / "Dangl.AVACloudClientGenerator.dll";
var outputPath = OutputDirectory / language;
var arguments = $"\"{generatorPath}\" -l {language} -o \"{outputPath}\"";
if (!string.IsNullOrWhiteSpace(CustomSwaggerDefinitionUrl))
{
Serilog.Log.Information("Using custom Swagger definition url: " + CustomSwaggerDefinitionUrl);
arguments += $" -u {CustomSwaggerDefinitionUrl}";
}
StartProcess(ToolPathResolver.GetPathExecutable("dotnet"), arguments)
.AssertZeroExitCode();
System.IO.Compression.ZipFile.CreateFromDirectory(outputPath, outputPath.ToString().TrimEnd('/').TrimEnd('\\') + ".zip");
}
internal static string GetToolCacheFilePath(RestoreRequest request, LockFile lockFile)
{
if (request.ProjectStyle == ProjectStyle.DotnetCliTool && lockFile != null)
{
var toolName = ToolRestoreUtility.GetToolIdOrNullFromSpec(request.Project);
var lockFileLibrary = ToolRestoreUtility.GetToolTargetLibrary(lockFile, toolName);
if (lockFileLibrary != null)
{
var version = lockFileLibrary.Version;
var toolPathResolver = new ToolPathResolver(request.PackagesDirectory);
return(GetToolCacheFilePath(toolPathResolver.GetToolDirectoryPath(
toolName,
version,
lockFile.Targets.First().TargetFramework), toolName));
}
}
return(null);
}
public OriginalCaseGlobalPackageFolder(RestoreRequest request, Guid parentId)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
_request = request;
_localRepositories = new List <NuGetv3LocalRepository>();
_localRepositories.Add(request.DependencyProviders.GlobalPackages);
_localRepositories.AddRange(request.DependencyProviders.FallbackPackageFolders);
_pathResolver = new VersionFolderPathResolver(
_request.PackagesDirectory,
_request.IsLowercasePackagesDirectory);
_toolPathResolver = new ToolPathResolver(
_request.PackagesDirectory,
_request.IsLowercasePackagesDirectory);
}
public void ToolPathResolver_BuildsOriginalCaseLockFilePath()
{
// Arrange
var target = new ToolPathResolver("packages", isLowercase: false);
var expected = Path.Combine(
"packages",
".tools",
"PackageA",
"3.1.4-BETA",
"netstandard1.3",
"project.assets.json");
// Act
var actual = target.GetLockFilePath(
"PackageA",
NuGetVersion.Parse("3.1.4-BETA"),
FrameworkConstants.CommonFrameworks.NetStandard13);
// Assert
Assert.Equal(expected, actual);
}
internal static string GetToolCacheFilePath(RestoreRequest request, LockFile lockFile)
{
if (request.ProjectStyle != ProjectStyle.DotnetCliTool)
{
var toolName = ToolRestoreUtility.GetToolIdOrNullFromSpec(request.Project);
var lockFileLibrary = ToolRestoreUtility.GetToolTargetLibrary(lockFile, toolName);
if (lockFileLibrary != null)
{
var version = lockFileLibrary.Version;
var toolPathResolver = new ToolPathResolver(request.PackagesDirectory);
var projFileName = Path.GetFileName(request.Project.RestoreMetadata.ProjectPath);
return(PathUtility.GetDirectoryName(toolPathResolver.GetLockFilePath(
toolName,
version,
lockFile.Targets.First().TargetFramework)) + $"{projFileName}.nuget.cache");
}
}
return(null);
}
public void NoOpRestoreUtility_CacheFileToolNameIsLowercase()
{
var package = "PackageA";
// Arrange
var target = new ToolPathResolver("packages", isLowercase: true);
var expected = Path.Combine(
"packages",
".tools",
"packagea",
"3.1.4-beta",
"netstandard1.3",
"packagea.nuget.cache");
// Act
var actual = NoOpRestoreUtilities.GetToolCacheFilePath(
target.GetToolDirectoryPath(
package,
NuGetVersion.Parse("3.1.4-beta"),
FrameworkConstants.CommonFrameworks.NetStandard13), package);
// Assert
Assert.Equal(expected, actual);
}
internal static string GetToolPath()
{
return(ToolPathResolver.GetPackageExecutable(
"JetBrains.dotCover.DotNetCliTool|JetBrains.dotCover.CommandLineTools",
EnvironmentInfo.IsWin ? "dotCover.exe" : "dotCover.sh|dotCover.exe"));
}
internal static string GetToolPath()
{
return(ToolPathResolver.GetPackageExecutable(
"machine.specifications.runner.console",
EnvironmentInfo.Is64Bit ? "mspec-clr4.exe" : "mspec-x86-clr4.exe"));
}
