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")); }