private ICommand GetTargetCommand()
{
var globalProperties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
// This property disables default item globbing to improve performance
// This should be safe because we are not evaluating items, only properties
{ Constants.EnableDefaultItems, "false" },
{ Constants.MSBuildExtensionsPath, AppContext.BaseDirectory }
};
if (!string.IsNullOrWhiteSpace(Configuration))
{
globalProperties.Add("Configuration", Configuration);
}
if (!string.IsNullOrWhiteSpace(Framework))
{
globalProperties.Add("TargetFramework", Framework);
}
if (!string.IsNullOrWhiteSpace(Runtime))
{
globalProperties.Add("RuntimeIdentifier", Runtime);
}
var project = new ProjectInstance(Project, globalProperties, null);
string runProgram = project.GetPropertyValue("RunCommand");
if (string.IsNullOrEmpty(runProgram))
{
ThrowUnableToRunError(project);
}
string runArguments = project.GetPropertyValue("RunArguments");
string runWorkingDirectory = project.GetPropertyValue("RunWorkingDirectory");
if (Args.Any())
{
runArguments += " " + ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(Args);
}
CommandSpec commandSpec = new CommandSpec(runProgram, runArguments);
var command = CommandFactoryUsingResolver.Create(commandSpec)
.WorkingDirectory(runWorkingDirectory);
var rootVariableName = Environment.Is64BitProcess ? "DOTNET_ROOT" : "DOTNET_ROOT(x86)";
if (Environment.GetEnvironmentVariable(rootVariableName) == null)
{
command.EnvironmentVariable(rootVariableName, Path.GetDirectoryName(new Muxer().MuxerPath));
}
return(command);
}
public void WhenItCannotResolveCommandButCommandIsInListOfKnownToolsItThrowsWithGuideToUseToolWithNormalizedCasing()
{
Action a = () => { CommandFactoryUsingResolver.Create(new ResolveNothingCommandResolverPolicy(), "dotnet-EF", Array.Empty <string>()); };
a.ShouldThrow <CommandAvailableAsDotNetToolException>()
.And.Message.Should()
.Contain(string.Format(LocalizableStrings.CannotFindCommandAvailableAsTool,
"EF",
"dotnet-ef"));
}
/// <summary>
/// EscapeAndEvaluateArgumentString returns a representation of string[] args
/// when rawEvaluatedArgument is passed as an argument to a process using
/// Command.Create(). Ideally this should escape the argument such that
/// the output is == rawEvaluatedArgument.
/// </summary>
/// <param name="rawEvaluatedArgument">A string[] representing string[] args as already evaluated by a process</param>
/// <returns></returns>
private string[] EscapeAndEvaluateArgumentStringCmd(string[] rawEvaluatedArgument)
{
var cmd = CommandFactoryUsingResolver.Create(s_reflectorCmdName, rawEvaluatedArgument);
var commandResult = cmd
.CaptureStdErr()
.CaptureStdOut()
.Execute();
Console.WriteLine(commandResult.StdOut);
Console.WriteLine(commandResult.StdErr);
commandResult.ExitCode.Should().Be(0);
return(ParseReflectorCmdOutput(commandResult.StdOut));
}
/// <summary>
/// EscapeAndEvaluateArgumentString returns a representation of string[] args
/// when rawEvaluatedArgument is passed as an argument to a process using
/// CommandUsingResolver.Create(). Ideally this should escape the argument such that
/// the output is == rawEvaluatedArgument.
/// </summary>
/// <param name="rawEvaluatedArgument">A string[] representing string[] args as already evaluated by a process</param>
/// <returns></returns>
private string[] EscapeAndEvaluateArgumentString(string[] rawEvaluatedArgument)
{
var commandResult = CommandFactoryUsingResolver.Create("dotnet", new[] { ReflectorPath }.Concat(rawEvaluatedArgument))
.CaptureStdErr()
.CaptureStdOut()
.Execute();
Console.WriteLine($"STDOUT: {commandResult.StdOut}");
Console.WriteLine($"STDERR: {commandResult.StdErr}");
commandResult.ExitCode.Should().Be(0);
return(ParseReflectorOutput(commandResult.StdOut));
}
public ICommand Create(
string commandName,
IEnumerable <string> args,
NuGetFramework framework = null,
string configuration = Constants.DefaultConfiguration)
{
if (!_alwaysRunOutOfProc && TryGetBuiltInCommand(commandName, out var builtInCommand))
{
Debug.Assert(framework == null, "BuiltInCommand doesn't support the 'framework' argument.");
Debug.Assert(configuration == Constants.DefaultConfiguration, "BuiltInCommand doesn't support the 'configuration' argument.");
return(new BuiltInCommand(commandName, args, builtInCommand));
}
return(CommandFactoryUsingResolver.CreateDotNet(commandName, args, framework, configuration));
}
public override int Execute()
{
CommandSpec commandspec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
{
// since LocalToolsCommandResolver is a resolver, and all resolver input have dotnet-
CommandName = $"dotnet-{_toolCommandName}",
CommandArguments = _forwardArgument
});
if (commandspec == null)
{
throw new GracefulException(
new string[] { string.Format(LocalizableStrings.CannotFindCommandName, _toolCommandName) },
isUserError: false);
}
var result = CommandFactoryUsingResolver.Create(commandspec).Execute();
return(result.ExitCode);
}
private static string GetSameProductionCommandArguments(List <string> argsToPassToRestore)
{
return(CommandFactoryUsingResolver.Create("dotnet",
new[] { "restore" }.Concat(argsToPassToRestore)).CommandArgs);
}
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;
TopLevelCommandParserResult topLevelCommandParserResult = TopLevelCommandParserResult.Empty;
using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel =
new FirstTimeUseNoticeSentinel())
{
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel;
IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel();
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";
}
var environmentProvider = new EnvironmentProvider();
bool generateAspNetCertificate =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", true);
bool skipFirstRunExperience =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", false);
bool telemetryOptout =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_CLI_TELEMETRY_OPTOUT", false);
ReportDotnetHomeUsage(environmentProvider);
topLevelCommandParserResult = new TopLevelCommandParserResult(command);
var hasSuperUserAccess = false;
if (IsDotnetBeingInvokedFromNativeInstaller(topLevelCommandParserResult))
{
aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel();
firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel();
toolPathSentinel = new NoOpFileSentinel(exists: false);
hasSuperUserAccess = true;
// When running through a native installer, we want the cache expansion to happen, so
// we need to override this.
skipFirstRunExperience = false;
}
var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration(
generateAspNetCertificate: generateAspNetCertificate,
skipFirstRunExperience: skipFirstRunExperience,
telemetryOptout: telemetryOptout);
ConfigureDotNetForFirstTimeUse(
firstTimeUseNoticeSentinel,
aspNetCertificateSentinel,
toolPathSentinel,
hasSuperUserAccess,
dotnetFirstRunConfiguration,
environmentProvider);
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 = CommandFactoryUsingResolver.Create(
"dotnet-" + topLevelCommandParserResult.Command,
appArgs,
FrameworkConstants.CommonFrameworks.NetStandardApp15)
.Execute();
exitCode = result.ExitCode;
}
return(exitCode);
}
internal static int ProcessArgs(string[] args, TimeSpan startupTime, ITelemetry telemetryClient = null)
{
Dictionary <string, double> performanceData = new Dictionary <string, double>();
PerformanceLogEventSource.Log.BuiltInCommandParserStart();
Stopwatch parseStartTime = Stopwatch.StartNew();
var parseResult = Parser.Instance.Parse(args);
// Avoid create temp directory with root permission and later prevent access in non sudo
// This method need to be run very early before temp folder get created
// https://github.com/dotnet/sdk/issues/20195
SudoEnvironmentDirectoryOverride.OverrideEnvironmentVariableToTmp(parseResult);
performanceData.Add("Parse Time", parseStartTime.Elapsed.TotalMilliseconds);
PerformanceLogEventSource.Log.BuiltInCommandParserStop();
using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel =
new FirstTimeUseNoticeSentinel())
{
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel;
IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel();
IFileSentinel toolPathSentinel = new FileSentinel(
new FilePath(
Path.Combine(
CliFolderPathCalculator.DotnetUserProfileFolderPath,
ToolPathSentinelFileName)));
if (parseResult.GetValueForOption(Parser.DiagOption) && parseResult.IsDotnetBuiltInCommand())
{
Environment.SetEnvironmentVariable(CommandContext.Variables.Verbose, bool.TrueString);
CommandContext.SetVerbose(true);
Reporter.Reset();
}
if (parseResult.HasOption(Parser.VersionOption) && parseResult.IsTopLevelDotnetCommand())
{
CommandLineInfo.PrintVersion();
return(0);
}
else if (parseResult.HasOption(Parser.InfoOption) && parseResult.IsTopLevelDotnetCommand())
{
CommandLineInfo.PrintInfo();
return(0);
}
else
{
PerformanceLogEventSource.Log.FirstTimeConfigurationStart();
var environmentProvider = new EnvironmentProvider();
bool generateAspNetCertificate =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", defaultValue: true);
bool telemetryOptout =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_CLI_TELEMETRY_OPTOUT", defaultValue: false);
bool addGlobalToolsToPath =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_ADD_GLOBAL_TOOLS_TO_PATH", defaultValue: true);
bool nologo =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_NOLOGO", defaultValue: false);
ReportDotnetHomeUsage(environmentProvider);
var isDotnetBeingInvokedFromNativeInstaller = false;
if (parseResult.CommandResult.Command.Name.Equals(Parser.InstallSuccessCommand.Name))
{
aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel();
firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel();
toolPathSentinel = new NoOpFileSentinel(exists: false);
isDotnetBeingInvokedFromNativeInstaller = true;
}
var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration(
generateAspNetCertificate: generateAspNetCertificate,
telemetryOptout: telemetryOptout,
addGlobalToolsToPath: addGlobalToolsToPath,
nologo: nologo);
ConfigureDotNetForFirstTimeUse(
firstTimeUseNoticeSentinel,
aspNetCertificateSentinel,
toolPathSentinel,
isDotnetBeingInvokedFromNativeInstaller,
dotnetFirstRunConfiguration,
environmentProvider,
performanceData);
PerformanceLogEventSource.Log.FirstTimeConfigurationStop();
}
PerformanceLogEventSource.Log.TelemetryRegistrationStart();
if (telemetryClient == null)
{
telemetryClient = new Telemetry.Telemetry(firstTimeUseNoticeSentinel);
}
TelemetryEventEntry.Subscribe(telemetryClient.TrackEvent);
TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
PerformanceLogEventSource.Log.TelemetryRegistrationStop();
}
if (CommandContext.IsVerbose())
{
Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}");
}
PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStart();
performanceData.Add("Startup Time", startupTime.TotalMilliseconds);
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, performanceData));
PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStop();
int exitCode;
if (parseResult.CanBeInvoked())
{
PerformanceLogEventSource.Log.BuiltInCommandStart();
exitCode = parseResult.Invoke();
PerformanceLogEventSource.Log.BuiltInCommandStop();
}
else
{
PerformanceLogEventSource.Log.ExtensibleCommandResolverStart();
var resolvedCommand = CommandFactoryUsingResolver.Create(
"dotnet-" + parseResult.GetValueForArgument(Parser.DotnetSubCommand),
args.GetSubArguments(),
FrameworkConstants.CommonFrameworks.NetStandardApp15);
PerformanceLogEventSource.Log.ExtensibleCommandResolverStop();
PerformanceLogEventSource.Log.ExtensibleCommandStart();
var result = resolvedCommand.Execute();
PerformanceLogEventSource.Log.ExtensibleCommandStop();
exitCode = result.ExitCode;
}
PerformanceLogEventSource.Log.TelemetryClientFlushStart();
telemetryClient.Flush();
PerformanceLogEventSource.Log.TelemetryClientFlushStop();
return(exitCode);
}
internal static int ProcessArgs(string[] args, TimeSpan startupTime, ITelemetry telemetryClient = null)
{
Dictionary <string, double> performanceData = new Dictionary <string, double>();
PerformanceLogEventSource.Log.BuiltInCommandParserStart();
Stopwatch parseStartTime = Stopwatch.StartNew();
var parseResult = Parser.Instance.Parse(args);
performanceData.Add("Parse Time", parseStartTime.Elapsed.TotalMilliseconds);
PerformanceLogEventSource.Log.BuiltInCommandParserStop();
using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel =
new FirstTimeUseNoticeSentinel())
{
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel;
IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel();
IFileSentinel toolPathSentinel = new FileSentinel(
new FilePath(
Path.Combine(
CliFolderPathCalculator.DotnetUserProfileFolderPath,
ToolPathSentinelFileName)));
if (parseResult.ValueForOption <bool>(Parser.DiagOption) && parseResult.IsDotnetBuiltInCommand())
{
Environment.SetEnvironmentVariable(CommandContext.Variables.Verbose, bool.TrueString);
CommandContext.SetVerbose(true);
Reporter.Reset();
}
if (parseResult.HasOption(Parser.VersionOption) && parseResult.IsTopLevelDotnetCommand())
{
CommandLineInfo.PrintVersion();
return(0);
}
else if (parseResult.HasOption(Parser.InfoOption) && parseResult.IsTopLevelDotnetCommand())
{
CommandLineInfo.PrintInfo();
return(0);
}
else if (parseResult.HasOption("-h") && parseResult.IsTopLevelDotnetCommand())
{
HelpCommand.PrintHelp();
return(0);
}
else if (parseResult.Directives.Count() > 0)
{
return(parseResult.Invoke());
}
else
{
PerformanceLogEventSource.Log.FirstTimeConfigurationStart();
var environmentProvider = new EnvironmentProvider();
bool generateAspNetCertificate =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", defaultValue: true);
bool telemetryOptout =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_CLI_TELEMETRY_OPTOUT", defaultValue: false);
bool addGlobalToolsToPath =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_ADD_GLOBAL_TOOLS_TO_PATH", defaultValue: true);
bool nologo =
environmentProvider.GetEnvironmentVariableAsBool("DOTNET_NOLOGO", defaultValue: false);
ReportDotnetHomeUsage(environmentProvider);
var isDotnetBeingInvokedFromNativeInstaller = false;
if (parseResult.CommandResult.Command.Name.Equals(Parser.InstallSuccessCommand.Name))
{
aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel();
firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel();
toolPathSentinel = new NoOpFileSentinel(exists: false);
isDotnetBeingInvokedFromNativeInstaller = true;
}
var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration(
generateAspNetCertificate: generateAspNetCertificate,
telemetryOptout: telemetryOptout,
addGlobalToolsToPath: addGlobalToolsToPath,
nologo: nologo);
ConfigureDotNetForFirstTimeUse(
firstTimeUseNoticeSentinel,
aspNetCertificateSentinel,
toolPathSentinel,
isDotnetBeingInvokedFromNativeInstaller,
dotnetFirstRunConfiguration,
environmentProvider,
performanceData);
PerformanceLogEventSource.Log.FirstTimeConfigurationStop();
}
PerformanceLogEventSource.Log.TelemetryRegistrationStart();
if (telemetryClient == null)
{
telemetryClient = new Telemetry.Telemetry(firstTimeUseNoticeSentinel);
}
TelemetryEventEntry.Subscribe(telemetryClient.TrackEvent);
TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
PerformanceLogEventSource.Log.TelemetryRegistrationStop();
}
if (CommandContext.IsVerbose())
{
Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}");
}
PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStart();
performanceData.Add("Startup Time", startupTime.TotalMilliseconds);
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, performanceData));
PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStop();
var topLevelCommands = new string[] { "dotnet", parseResult.RootSubCommandResult() }.Concat(Parser.DiagOption.Aliases);
int exitCode;
if (parseResult.CommandResult.Command.Name.Equals("dotnet") && string.IsNullOrEmpty(parseResult.ValueForArgument <string>(Parser.DotnetSubCommand)))
{
exitCode = 0;
}
else if (BuiltInCommandsCatalog.Commands.TryGetValue(parseResult.RootSubCommandResult(), out var builtIn))
{
PerformanceLogEventSource.Log.BuiltInCommandStart();
exitCode = builtIn.Command(args.Where(t => !topLevelCommands.Contains(t)).ToArray());
PerformanceLogEventSource.Log.BuiltInCommandStop();
}
else
{
PerformanceLogEventSource.Log.ExtensibleCommandResolverStart();
var resolvedCommand = CommandFactoryUsingResolver.Create(
"dotnet-" + parseResult.ValueForArgument <string>(Parser.DotnetSubCommand),
args.Where(t => !topLevelCommands.Contains(t)).ToArray(),
FrameworkConstants.CommonFrameworks.NetStandardApp15);
PerformanceLogEventSource.Log.ExtensibleCommandResolverStop();
PerformanceLogEventSource.Log.ExtensibleCommandStart();
var result = resolvedCommand.Execute();
PerformanceLogEventSource.Log.ExtensibleCommandStop();
exitCode = result.ExitCode;
}
PerformanceLogEventSource.Log.TelemetryClientFlushStart();
telemetryClient.Flush();
PerformanceLogEventSource.Log.TelemetryClientFlushStop();
return(exitCode);
}
public void WhenItCannotResolveCommandButCommandIsInListOfKnownToolsItThrows()
{
Action a = () => { CommandFactoryUsingResolver.Create(new ResolveNothingCommandResolverPolicy(), "non-exist-command", Array.Empty <string>()); };
a.ShouldThrow <CommandUnknownException>();
}
