private static void ConfigureDotNetForFirstTimeUse( INuGetCacheSentinel nugetCacheSentinel, IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel, IAspNetCertificateSentinel aspNetCertificateSentinel, CliFolderPathCalculator cliFolderPathCalculator, bool hasSuperUserAccess) { var environmentProvider = new EnvironmentProvider(); using (PerfTrace.Current.CaptureTiming()) { var nugetPackagesArchiver = new NuGetPackagesArchiver(); var environmentPath = EnvironmentPathFactory.CreateEnvironmentPath(cliFolderPathCalculator, hasSuperUserAccess, environmentProvider); var commandFactory = new DotNetCommandFactory(alwaysRunOutOfProc: true); var nugetCachePrimer = new NuGetCachePrimer( nugetPackagesArchiver, nugetCacheSentinel, cliFolderPathCalculator); var aspnetCertificateGenerator = new AspNetCoreCertificateGenerator(); var dotnetConfigurer = new DotnetFirstTimeUseConfigurer( nugetCachePrimer, nugetCacheSentinel, firstTimeUseNoticeSentinel, aspNetCertificateSentinel, aspnetCertificateGenerator, environmentProvider, Reporter.Output, cliFolderPathCalculator.CliFallbackFolderPath, environmentPath); dotnetConfigurer.Configure(); } }
public ToolInstallCommand( AppliedOption appliedCommand, ParseResult parseResult, CreateToolPackageStoreAndInstaller createToolPackageStoreAndInstaller = null, CreateShellShimRepository createShellShimRepository = null, IEnvironmentPathInstruction environmentPathInstruction = null, IReporter reporter = null) : base(parseResult) { if (appliedCommand == null) { throw new ArgumentNullException(nameof(appliedCommand)); } _packageId = new PackageId(appliedCommand.Arguments.Single()); _packageVersion = appliedCommand.ValueOrDefault <string>("version"); _configFilePath = appliedCommand.ValueOrDefault <string>("configfile"); _framework = appliedCommand.ValueOrDefault <string>("framework"); _source = appliedCommand.ValueOrDefault <string[]>("source-feed"); _global = appliedCommand.ValueOrDefault <bool>("global"); _verbosity = appliedCommand.SingleArgumentOrDefault("verbosity"); _toolPath = appliedCommand.SingleArgumentOrDefault("tool-path"); var cliFolderPathCalculator = new CliFolderPathCalculator(); _createToolPackageStoreAndInstaller = createToolPackageStoreAndInstaller ?? ToolPackageFactory.CreateToolPackageStoreAndInstaller; _environmentPathInstruction = environmentPathInstruction ?? EnvironmentPathFactory.CreateEnvironmentPathInstruction(); _createShellShimRepository = createShellShimRepository ?? ShellShimRepositoryFactory.CreateShellShimRepository; _reporter = (reporter ?? Reporter.Output); _errorReporter = (reporter ?? Reporter.Error); }
public override int Execute() { if (!_global) { throw new GracefulException(LocalizableStrings.InstallToolCommandOnlySupportGlobal); } var cliFolderPathCalculator = new CliFolderPathCalculator(); var executablePackagePath = new DirectoryPath(cliFolderPathCalculator.ExecutablePackagesPath); var offlineFeedPath = new DirectoryPath(cliFolderPathCalculator.CliFallbackFolderPath); var toolConfigurationAndExecutablePath = ObtainPackage(executablePackagePath, offlineFeedPath); var shellShimMaker = new ShellShimMaker(executablePackagePath.Value); var commandName = toolConfigurationAndExecutablePath.Configuration.CommandName; shellShimMaker.EnsureCommandNameUniqueness(commandName); shellShimMaker.CreateShim( toolConfigurationAndExecutablePath.Executable.Value, commandName); EnvironmentPathFactory .CreateEnvironmentPathInstruction() .PrintAddPathInstructionIfPathDoesNotExist(); Reporter.Output.WriteLine( string.Format(LocalizableStrings.InstallationSucceeded, commandName)); return(0); }
public void It_does_not_return_same_path_for_tools_package_and_tool_shim() { // shim name will conflict with the folder that is PackageId, if commandName and packageId are the same. var cliFolderPathCalculator = new CliFolderPathCalculator(); cliFolderPathCalculator.ToolsPackagePath.Should().NotBe(cliFolderPathCalculator.ToolsShimPath); cliFolderPathCalculator.ToolsPackagePath.Should().NotBe(cliFolderPathCalculator.ToolsShimPathInUnix.Path); }
public UninstallToolCommand( AppliedOption options, ParseResult result, CreateToolPackageStore createToolPackageStoreAndInstaller = null, CreateShellShimRepository createShellShimRepository = null, IReporter reporter = null) : base(result) { var pathCalculator = new CliFolderPathCalculator(); _options = options ?? throw new ArgumentNullException(nameof(options)); _reporter = reporter ?? Reporter.Output; _errorReporter = reporter ?? Reporter.Error; _createShellShimRepository = createShellShimRepository ?? ShellShimRepositoryFactory.CreateShellShimRepository; _createToolPackageStoreAndInstaller = createToolPackageStoreAndInstaller ?? ToolPackageFactory.CreateToolPackageStore; }
public UninstallToolCommand( AppliedOption options, ParseResult result, IToolPackageStore toolPackageStore = null, IShellShimRepository shellShimRepository = null, IReporter reporter = null) : base(result) { var pathCalculator = new CliFolderPathCalculator(); _options = options ?? throw new ArgumentNullException(nameof(options)); _toolPackageStore = toolPackageStore ?? new ToolPackageStore( new DirectoryPath(pathCalculator.ToolsPackagePath)); _shellShimRepository = shellShimRepository ?? new ShellShimRepository( new DirectoryPath(pathCalculator.ToolsShimPath)); _reporter = reporter ?? Reporter.Output; _errorReporter = reporter ?? Reporter.Error; }
public InstallToolCommand( AppliedOption appliedCommand, ParseResult parseResult, IToolPackageObtainer toolPackageObtainer = null, IShellShimMaker shellShimMaker = null, IEnvironmentPathInstruction environmentPathInstruction = null, IReporter reporter = null) : base(parseResult) { if (appliedCommand == null) { throw new ArgumentNullException(nameof(appliedCommand)); } _packageId = appliedCommand.Arguments.Single(); _packageVersion = appliedCommand.ValueOrDefault <string>("version"); _configFilePath = appliedCommand.ValueOrDefault <string>("configfile"); _framework = appliedCommand.ValueOrDefault <string>("framework"); _source = appliedCommand.ValueOrDefault <string>("source"); _global = appliedCommand.ValueOrDefault <bool>("global"); _verbosity = appliedCommand.SingleArgumentOrDefault("verbosity"); var cliFolderPathCalculator = new CliFolderPathCalculator(); var offlineFeedPath = new DirectoryPath(cliFolderPathCalculator.CliFallbackFolderPath); _toolPackageObtainer = toolPackageObtainer ?? new ToolPackageObtainer( new DirectoryPath(cliFolderPathCalculator.ToolsPackagePath), offlineFeedPath, () => new DirectoryPath(Path.GetTempPath()) .WithSubDirectories(Path.GetRandomFileName()) .WithFile(Path.GetRandomFileName() + ".csproj"), new Lazy <string>(BundledTargetFramework.GetTargetFrameworkMoniker), new ProjectRestorer(reporter)); _environmentPathInstruction = environmentPathInstruction ?? EnvironmentPathFactory .CreateEnvironmentPathInstruction(); _shellShimMaker = shellShimMaker ?? new ShellShimMaker(cliFolderPathCalculator.ToolsShimPath); _reporter = (reporter ?? Reporter.Output); _errorReporter = (reporter ?? Reporter.Error); }
public static IEnvironmentPath CreateEnvironmentPath( CliFolderPathCalculator cliFolderPathCalculator = null, bool hasSuperUserAccess = false, IEnvironmentProvider environmentProvider = null) { if (cliFolderPathCalculator == null) { cliFolderPathCalculator = new CliFolderPathCalculator(); } if (environmentProvider == null) { environmentProvider = new EnvironmentProvider(); } IEnvironmentPath environmentPath = new DoNothingEnvironmentPath(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { environmentPath = new WindowsEnvironmentPath( cliFolderPathCalculator.ToolsShimPath, Reporter.Output, environmentProvider); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && hasSuperUserAccess) { environmentPath = new LinuxEnvironmentPath( cliFolderPathCalculator.ToolsShimPathInUnix, Reporter.Output, environmentProvider, new FileWrapper()); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && hasSuperUserAccess) { environmentPath = new OSXEnvironmentPath( executablePath: cliFolderPathCalculator.ToolsShimPathInUnix, reporter: Reporter.Output, environmentProvider: environmentProvider, fileSystem: new FileWrapper()); } return(environmentPath); }
public InstallToolCommand( AppliedOption appliedCommand, ParseResult parseResult, IToolPackageStore toolPackageStore = null, IToolPackageInstaller toolPackageInstaller = null, IShellShimRepository shellShimRepository = null, IEnvironmentPathInstruction environmentPathInstruction = null, IReporter reporter = null) : base(parseResult) { if (appliedCommand == null) { throw new ArgumentNullException(nameof(appliedCommand)); } _packageId = new PackageId(appliedCommand.Arguments.Single()); _packageVersion = appliedCommand.ValueOrDefault <string>("version"); _configFilePath = appliedCommand.ValueOrDefault <string>("configfile"); _framework = appliedCommand.ValueOrDefault <string>("framework"); _source = appliedCommand.ValueOrDefault <string>("source"); _global = appliedCommand.ValueOrDefault <bool>("global"); _verbosity = appliedCommand.SingleArgumentOrDefault("verbosity"); var cliFolderPathCalculator = new CliFolderPathCalculator(); _toolPackageStore = toolPackageStore ?? new ToolPackageStore(new DirectoryPath(cliFolderPathCalculator.ToolsPackagePath)); _toolPackageInstaller = toolPackageInstaller ?? new ToolPackageInstaller( _toolPackageStore, new ProjectRestorer(_reporter)); _environmentPathInstruction = environmentPathInstruction ?? EnvironmentPathFactory.CreateEnvironmentPathInstruction(); _shellShimRepository = shellShimRepository ?? new ShellShimRepository(new DirectoryPath(cliFolderPathCalculator.ToolsShimPath)); _reporter = (reporter ?? Reporter.Output); _errorReporter = (reporter ?? Reporter.Error); }
public GivenANuGetCachePrimer() { var fileSystemMockBuilder = FileSystemMockBuilder.Create(); fileSystemMockBuilder.TemporaryFolder = TEMPORARY_FOLDER_PATH; fileSystemMockBuilder.AddFile(COMPRESSED_ARCHIVE_PATH); _fileSystemMock = fileSystemMockBuilder.Build(); _nugetPackagesArchiverMock = new Mock <INuGetPackagesArchiver>(); _nugetPackagesArchiverMock.Setup(n => n.NuGetPackagesArchive).Returns(COMPRESSED_ARCHIVE_PATH); _nugetCacheSentinel = new Mock <INuGetCacheSentinel>(); _cliFolderPathCalculator = new CliFolderPathCalculator(); var nugetCachePrimer = new NuGetCachePrimer( _nugetPackagesArchiverMock.Object, _nugetCacheSentinel.Object, _cliFolderPathCalculator, _fileSystemMock.File); nugetCachePrimer.PrimeCache(); }
public static IEnvironmentPathInstruction CreateEnvironmentPathInstruction( CliFolderPathCalculator cliFolderPathCalculator = null, IEnvironmentProvider environmentProvider = null) { return(CreateEnvironmentPath(cliFolderPathCalculator, true, environmentProvider)); }
internal static int ProcessArgs(string[] args, ITelemetry telemetryClient = null) { // CommandLineApplication is a bit restrictive, so we parse things ourselves here. Individual apps should use CLA. var success = true; var command = string.Empty; var lastArg = 0; var cliFallbackFolderPathCalculator = new CliFolderPathCalculator(); TopLevelCommandParserResult topLevelCommandParserResult = TopLevelCommandParserResult.Empty; using (INuGetCacheSentinel nugetCacheSentinel = new NuGetCacheSentinel(cliFallbackFolderPathCalculator)) using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel = new FirstTimeUseNoticeSentinel(cliFallbackFolderPathCalculator)) { IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel; IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel(cliFallbackFolderPathCalculator); IFileSentinel toolPathSentinel = new FileSentinel( new FilePath( Path.Combine( CliFolderPathCalculator.DotnetUserProfileFolderPath, ToolPathSentinelFileName))); for (; lastArg < args.Length; lastArg++) { if (IsArg(args[lastArg], "d", "diagnostics")) { Environment.SetEnvironmentVariable(CommandContext.Variables.Verbose, bool.TrueString); CommandContext.SetVerbose(true); } else if (IsArg(args[lastArg], "version")) { PrintVersion(); return(0); } else if (IsArg(args[lastArg], "info")) { PrintInfo(); return(0); } else if (IsArg(args[lastArg], "h", "help") || args[lastArg] == "-?" || args[lastArg] == "/?") { HelpCommand.PrintHelp(); return(0); } else if (args[lastArg].StartsWith("-", StringComparison.OrdinalIgnoreCase)) { Reporter.Error.WriteLine($"Unknown option: {args[lastArg]}"); success = false; } else { // It's the command, and we're done! command = args[lastArg]; if (string.IsNullOrEmpty(command)) { command = "help"; } topLevelCommandParserResult = new TopLevelCommandParserResult(command); var hasSuperUserAccess = false; if (IsDotnetBeingInvokedFromNativeInstaller(topLevelCommandParserResult)) { aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel(); firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel(); toolPathSentinel = new NoOpFileSentinel(exists: false); hasSuperUserAccess = true; } ConfigureDotNetForFirstTimeUse( nugetCacheSentinel, firstTimeUseNoticeSentinel, aspNetCertificateSentinel, toolPathSentinel, cliFallbackFolderPathCalculator, hasSuperUserAccess); break; } } if (!success) { HelpCommand.PrintHelp(); return(1); } if (telemetryClient == null) { telemetryClient = new Telemetry.Telemetry(firstTimeUseNoticeSentinel); } TelemetryEventEntry.Subscribe(telemetryClient.TrackEvent); TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing); } IEnumerable <string> appArgs = (lastArg + 1) >= args.Length ? Enumerable.Empty <string>() : args.Skip(lastArg + 1).ToArray(); if (CommandContext.IsVerbose()) { Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}"); } TelemetryEventEntry.SendFiltered(topLevelCommandParserResult); int exitCode; if (BuiltInCommandsCatalog.Commands.TryGetValue(topLevelCommandParserResult.Command, out var builtIn)) { var parseResult = Parser.Instance.ParseFrom($"dotnet {topLevelCommandParserResult.Command}", appArgs.ToArray()); if (!parseResult.Errors.Any()) { TelemetryEventEntry.SendFiltered(parseResult); } exitCode = builtIn.Command(appArgs.ToArray()); } else { CommandResult result = Command.Create( "dotnet-" + topLevelCommandParserResult.Command, appArgs, FrameworkConstants.CommonFrameworks.NetStandardApp15) .Execute(); exitCode = result.ExitCode; } return(exitCode); }
private static DirectoryPath GetShimLocation() { var cliFolderPathCalculator = new CliFolderPathCalculator(); return(new DirectoryPath(cliFolderPathCalculator.ToolsShimPath)); }