public WebProxy GetUserConfiguredProxy()
{
// Try reading from the settings. The values are stored as 3 config values http_proxy, http_proxy_user, http_proxy_password
var host = _settings.GetValue(SettingsUtility.ConfigSection, ConfigurationConstants.HostKey);
if (!string.IsNullOrEmpty(host))
{
// The host is the minimal value we need to assume a user configured proxy.
var webProxy = new WebProxy(host);
#if !IS_CORECLR
var userName = _settings.GetValue(SettingsUtility.ConfigSection, ConfigurationConstants.UserKey);
var password = SettingsUtility.GetDecryptedValue(_settings, SettingsUtility.ConfigSection, ConfigurationConstants.PasswordKey);
if (!string.IsNullOrEmpty(userName) &&
!string.IsNullOrEmpty(password))
{
webProxy.Credentials = new NetworkCredential(userName, password);
}
#endif
var noProxy = _settings.GetValue(SettingsUtility.ConfigSection, ConfigurationConstants.NoProxy);
if (!string.IsNullOrEmpty(noProxy))
{
// split comma-separated list of domains
webProxy.BypassList = noProxy.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
return(webProxy);
}
// Next try reading from the environment variable http_proxy. This would be specified as http://<username>:<password>@proxy.com
host = _environment.GetEnvironmentVariable(ConfigurationConstants.HostKey);
Uri uri;
if (!string.IsNullOrEmpty(host) &&
Uri.TryCreate(host, UriKind.Absolute, out uri))
{
var webProxy = new WebProxy(uri.GetComponents(
UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped));
if (!string.IsNullOrEmpty(uri.UserInfo))
{
var credentials = uri.UserInfo.Split(':');
if (credentials.Length > 1)
{
webProxy.Credentials = new NetworkCredential(
userName: credentials[0], password: credentials[1]);
}
}
var noProxy = _environment.GetEnvironmentVariable(ConfigurationConstants.NoProxy);
if (!string.IsNullOrEmpty(noProxy))
{
// split comma-separated list of domains
webProxy.BypassList = noProxy.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
return(webProxy);
}
return(null);
}
internal NuGetFileLogger(IEnvironmentVariableReader environmentVariableReader)
{
if (environmentVariableReader == null)
{
throw new ArgumentNullException(nameof(environmentVariableReader));
}
_logDirectoryPath = environmentVariableReader.GetEnvironmentVariable("NUGET_VS_RESTORE_LOGGING_PATH");
if (!string.IsNullOrWhiteSpace(_logDirectoryPath))
{
IsEnabled = true;
}
var formatWithTime = environmentVariableReader.GetEnvironmentVariable("NUGET_VS_RESTORE_FORMAT_WITH_TIME");
if (!string.IsNullOrWhiteSpace(formatWithTime))
{
_ = bool.TryParse(formatWithTime, out bool formatWithTimeOverride);
ShouldFormatWithTime = formatWithTimeOverride;
}
_startTime = DateTimeOffset.UtcNow;
_stopwatch = Stopwatch.StartNew();
// Created outside of the lambda below to capture the current time.
var message = $"The stopwatch frequency is {Stopwatch.Frequency}";
_streamWriter = new Lazy <StreamWriter>(() => CreateStreamWriter(message));
_streamWriterLock = new object();
}
internal PluginLogger(IEnvironmentVariableReader environmentVariableReader)
{
if (environmentVariableReader == null)
{
throw new ArgumentNullException(nameof(environmentVariableReader));
}
var value = environmentVariableReader.GetEnvironmentVariable(EnvironmentVariableConstants.EnableLog);
IsEnabled = bool.TryParse(value, out var enable) && enable;
if (IsEnabled)
{
_logDirectoryPath = environmentVariableReader.GetEnvironmentVariable(EnvironmentVariableConstants.LogDirectoryPath);
if (string.IsNullOrWhiteSpace(_logDirectoryPath))
{
_logDirectoryPath = Environment.CurrentDirectory;
}
}
_startTime = DateTimeOffset.UtcNow;
_stopwatch = Stopwatch.StartNew();
// Created outside of the lambda below to capture the current time.
var message = new StopwatchLogMessage(Now, Stopwatch.Frequency);
_streamWriter = new Lazy <StreamWriter>(() => CreateStreamWriter(message));
_streamWriterLock = new object();
}
private void Initialize(IEnvironmentVariableReader reader,
Lazy <IPluginDiscoverer> pluginDiscoverer,
Func <TimeSpan, IPluginFactory> pluginFactoryCreator,
Lazy <string> pluginsCacheDirectoryPath)
{
EnvironmentVariableReader = reader ?? throw new ArgumentNullException(nameof(reader));
_discoverer = pluginDiscoverer ?? throw new ArgumentNullException(nameof(pluginDiscoverer));
_pluginsCacheDirectoryPath = pluginsCacheDirectoryPath ?? throw new ArgumentNullException(nameof(pluginsCacheDirectoryPath));
if (pluginFactoryCreator == null)
{
throw new ArgumentNullException(nameof(pluginFactoryCreator));
}
#if IS_DESKTOP
_rawPluginPaths = reader.GetEnvironmentVariable(EnvironmentVariableConstants.DesktopPluginPaths);
#else
_rawPluginPaths = reader.GetEnvironmentVariable(EnvironmentVariableConstants.CorePluginPaths);
#endif
if (string.IsNullOrEmpty(_rawPluginPaths))
{
_rawPluginPaths = reader.GetEnvironmentVariable(EnvironmentVariableConstants.PluginPaths);
}
_connectionOptions = ConnectionOptions.CreateDefault(reader);
var idleTimeoutInSeconds = EnvironmentVariableReader.GetEnvironmentVariable(EnvironmentVariableConstants.IdleTimeout);
var idleTimeout = TimeoutUtilities.GetTimeout(idleTimeoutInSeconds, PluginConstants.IdleTimeout);
_pluginFactory = pluginFactoryCreator(idleTimeout);
_pluginOperationClaims = new ConcurrentDictionary <PluginRequestKey, Lazy <Task <IReadOnlyList <OperationClaim> > > >();
_pluginUtilities = new ConcurrentDictionary <string, Lazy <IPluginMulticlientUtilities> >(
StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Reinitializes static state.
/// </summary>
/// <remarks>This is non-private only to facilitate unit testing.
/// This should not be called by product code.</remarks>
/// <param name="reader">An environment variable reader.</param>
/// <param name="pluginDiscoverer">A lazy plugin discoverer.</param>
/// <param name="pluginFactory">A plugin factory.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginDiscoverer" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginFactory" />
/// is <c>null</c>.</exception>
public void Reinitialize(IEnvironmentVariableReader reader,
Lazy<IPluginDiscoverer> pluginDiscoverer,
IPluginFactory pluginFactory)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (pluginDiscoverer == null)
{
throw new ArgumentNullException(nameof(pluginDiscoverer));
}
if (pluginFactory == null)
{
throw new ArgumentNullException(nameof(pluginFactory));
}
EnvironmentVariableReader = reader;
_rawPluginPaths = reader.GetEnvironmentVariable(_pluginPathsEnvironmentVariable);
var requestTimeoutInSeconds = reader.GetEnvironmentVariable(_pluginRequestTimeoutEnvironmentVariable);
_requestTimeout = GetRequestTimeout(requestTimeoutInSeconds);
_discoverer = pluginDiscoverer;
_pluginFactory = pluginFactory;
_pluginOperationClaims = new ConcurrentDictionary<PluginPackageSourceKey, Lazy<Task<IReadOnlyList<OperationClaim>>>>();
_pluginUtilities = new ConcurrentDictionary<string, Lazy<IPluginMulticlientUtilities>>(
StringComparer.OrdinalIgnoreCase);
}
// This is non-private only to facilitate testing.
internal static IX509ChainBuildPolicy CreateWithoutCaching(IEnvironmentVariableReader reader)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
if (RuntimeEnvironmentHelper.IsWindows)
{
string value = reader.GetEnvironmentVariable(EnvironmentVariableName);
if (string.IsNullOrWhiteSpace(value))
{
return(DefaultX509ChainBuildPolicy.Instance);
}
string[] parts = value.Split(ValueDelimiter);
if (parts.Length == 2 &&
int.TryParse(parts[0], out int retryCount) &&
retryCount > 0 &&
int.TryParse(parts[1], out int sleepIntervalInMilliseconds) &&
sleepIntervalInMilliseconds >= 0)
{
TimeSpan sleepInterval = TimeSpan.FromMilliseconds(sleepIntervalInMilliseconds);
return(new RetriableX509ChainBuildPolicy(DefaultX509ChainBuildPolicy.Instance, retryCount, sleepInterval));
}
}
return(DefaultX509ChainBuildPolicy.Instance);
}
/// <summary>
/// Reinitializes static state.
/// </summary>
/// <remarks>This is non-private only to facilitate unit testing.
/// This should not be called by product code.</remarks>
/// <param name="reader">An environment variable reader.</param>
/// <param name="pluginDiscoverer">A lazy plugin discoverer.</param>
/// <param name="pluginFactoryCreator">A plugin factory creator.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reader" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginDiscoverer" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="pluginFactoryCreator" />
/// is <c>null</c>.</exception>
public void Reinitialize(IEnvironmentVariableReader reader,
Lazy <IPluginDiscoverer> pluginDiscoverer,
Func <TimeSpan, IPluginFactory> pluginFactoryCreator)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (pluginDiscoverer == null)
{
throw new ArgumentNullException(nameof(pluginDiscoverer));
}
if (pluginFactoryCreator == null)
{
throw new ArgumentNullException(nameof(pluginFactoryCreator));
}
EnvironmentVariableReader = reader;
_rawPluginPaths = reader.GetEnvironmentVariable(_pluginPathsEnvironmentVariable);
_connectionOptions = ConnectionOptions.CreateDefault(reader);
var idleTimeoutInSeconds = EnvironmentVariableReader.GetEnvironmentVariable(_idleTimeoutEnvironmentVariable);
var idleTimeout = TimeoutUtilities.GetTimeout(idleTimeoutInSeconds, PluginConstants.IdleTimeout);
_discoverer = pluginDiscoverer;
_pluginFactory = pluginFactoryCreator(idleTimeout);
_pluginOperationClaims = new ConcurrentDictionary <PluginPackageSourceKey, Lazy <Task <IReadOnlyList <OperationClaim> > > >();
_pluginUtilities = new ConcurrentDictionary <string, Lazy <IPluginMulticlientUtilities> >(
StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Gets the (first) path of MSBuild to appear in environment variable PATH.
/// </summary>
/// <returns>The path of MSBuild in PATH environment variable. Returns null if MSBuild location does not exist
/// in the variable string.</returns>
private static string GetMsBuildPathInPathVar(IEnvironmentVariableReader reader)
{
var path = reader.GetEnvironmentVariable("PATH");
var paths = path?.Split(new char[] { ';' });
return(paths?.Select(p =>
{
// Strip leading/trailing quotes
if (p.Length > 0 && p[0] == '\"')
{
p = p.Substring(1);
}
if (p.Length > 0 && p[p.Length - 1] == '\"')
{
p = p.Substring(0, p.Length - 1);
}
return p;
}).FirstOrDefault(p =>
{
try
{
return File.Exists(Path.Combine(p, "msbuild.exe"));
}
catch
{
return false;
}
}));
}
internal static string GetMSBuild(IEnvironmentVariableReader reader)
{
var exeNames = new[] { "msbuild.exe" };
if (RuntimeEnvironmentHelper.IsMono)
{
exeNames = new[] { "msbuild", "xbuild" };
}
// Try to find msbuild or xbuild in $Path.
var pathDirs = reader.GetEnvironmentVariable("PATH")?.Split(new[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries);
if (pathDirs?.Length > 0)
{
foreach (var exeName in exeNames)
{
var exePath = pathDirs.Select(dir => Path.Combine(dir.Trim('\"'), exeName)).FirstOrDefault(File.Exists);
if (exePath != null)
{
return(exePath);
}
}
}
return(null);
}
public bool IsExperimentEnabled(ExperimentationConstants experimentation)
{
var isEnvVarEnabled = !string.IsNullOrEmpty(experimentation.FlightEnvironmentVariable) &&
_environmentVariableReader.GetEnvironmentVariable(experimentation.FlightEnvironmentVariable) == "1";
return(isEnvVarEnabled || _experimentationService.IsCachedFlightEnabled(experimentation.FlightFlag));
}
/// <summary>
/// Instantiates a <see cref="ConnectionOptions" /> class with default values.
/// </summary>
/// <param name="reader">An environment variable reader.</param>
/// <returns>A <see cref="ConnectionOptions" />.</returns>
public static ConnectionOptions CreateDefault(IEnvironmentVariableReader reader = null)
{
reader = reader ?? new EnvironmentVariableWrapper();
var handshakeTimeoutInSeconds = reader.GetEnvironmentVariable(EnvironmentVariableConstants.HandshakeTimeout);
var requestTimeoutInSeconds = reader.GetEnvironmentVariable(EnvironmentVariableConstants.RequestTimeout);
var handshakeTimeout = TimeoutUtilities.GetTimeout(handshakeTimeoutInSeconds, ProtocolConstants.HandshakeTimeout);
var requestTimeout = TimeoutUtilities.GetTimeout(requestTimeoutInSeconds, ProtocolConstants.RequestTimeout);
return(new ConnectionOptions(
protocolVersion: ProtocolConstants.CurrentVersion,
minimumProtocolVersion: ProtocolConstants.Version100,
handshakeTimeout: handshakeTimeout,
requestTimeout: requestTimeout));
}
public async Task Run()
{
_client.BaseUrl = new Uri(_envReader.GetEnvironmentVariable("PING_URL"));
_client.Timeout = _timeout;
var request = new RestRequest(Method.GET);
try
{
var response = await _client.ExecuteGetTaskAsync(request);
if (response.StatusCode == HttpStatusCode.OK)
{
await _secretHandler.PutParameter("LAST_SUCCESSFUL_CONNECTION_TIME",
DateTime.UtcNow.ToString(CultureInfo.InvariantCulture), false);
return;
}
}
catch (Exception e)
{
Console.WriteLine(e);
await SendMessage();
}
await SendMessage();
}
internal Testable(IEnvironmentVariableReader environmentVariableReader)
{
_isMMapEnabled = environmentVariableReader.GetEnvironmentVariable(MMAP_VARIABLE_NAME) switch
{
"0" => false,
"1" => true,
_ => RuntimeEnvironmentHelper.IsWindows
};
}
internal Testable(IEnvironmentVariableReader environmentVariableReader)
{
_updateFileTimeFromEntryMaxRetries = 9;
string value = environmentVariableReader.GetEnvironmentVariable("NUGET_UPDATEFILETIME_MAXRETRIES");
if (int.TryParse(value, out int maxRetries) && maxRetries > 0)
{
_updateFileTimeFromEntryMaxRetries = maxRetries;
}
}
private static int?Read(IEnvironmentVariableReader reader, string variableName)
{
var variableValue = reader.GetEnvironmentVariable(variableName);
if (int.TryParse(variableValue, out var value))
{
return(value);
}
return(null);
}
private static bool ShouldShowStack(IEnvironmentVariableReader reader)
{
var rawShowStack = reader.GetEnvironmentVariable("NUGET_SHOW_STACK");
if (rawShowStack == null)
{
return(false);
}
return(string.Equals(rawShowStack.Trim(), "true", StringComparison.OrdinalIgnoreCase));
}
private void GetEnvironmentVariablesForFeature(NuGetFeatureFlagConstants featureFlag, out bool isFeatureForcedEnabled, out bool isFeatureForcedDisabled)
{
isFeatureForcedEnabled = false;
isFeatureForcedDisabled = false;
if (!string.IsNullOrEmpty(featureFlag.EnvironmentVariable))
{
string envVarOverride = _environmentVariableReader.GetEnvironmentVariable(featureFlag.EnvironmentVariable);
isFeatureForcedDisabled = envVarOverride == "0";
isFeatureForcedEnabled = envVarOverride == "1";
}
}
/// <summary>
/// Gets a <see cref="bool" /> value from the specified environment variable.
/// </summary>
/// <param name="variableName">The name of the environment variable to get the value.</param>
/// <param name="defaultValue">The default value to return if the environment variable is not defined or is not a valid <see cref="bool" />.</param>
/// <param name="environmentVariableReader">An <see cref="IEnvironmentVariableReader" /> to use when reading the environment variable.</param>
/// <returns>The value of the specified as a <see cref="bool" /> if the specified environment variable is defined and is a valid value for <see cref="bool" />.</returns>
private static bool GetBoolFromEnvironmentVariable(string variableName, bool defaultValue, IEnvironmentVariableReader environmentVariableReader)
{
try
{
if (bool.TryParse(environmentVariableReader.GetEnvironmentVariable(variableName), out bool parsedValue))
{
return(parsedValue);
}
}
catch (Exception) { }
return(defaultValue);
}
/// <summary>
/// Gets an <see cref="int" /> value from the specified environment variable.
/// </summary>
/// <param name="variableName">The name of the environment variable to get the value.</param>
/// <param name="defaultValue">The default value to return if the environment variable is not defined or is not a valid <see cref="int" />.</param>
/// <param name="environmentVariableReader">An <see cref="IEnvironmentVariableReader" /> to use when reading the environment variable.</param>
/// <returns>The value of the specified as a <see cref="int" /> if the specified environment variable is defined and is a valid value for <see cref="int" />.</returns>
private static int GetIntFromEnvironmentVariable(string variableName, int defaultValue, IEnvironmentVariableReader environmentVariableReader)
{
try
{
if (int.TryParse(environmentVariableReader.GetEnvironmentVariable(variableName), out int parsedValue))
{
return(parsedValue);
}
}
catch (Exception) { }
return(defaultValue);
}
public bool IsExperimentEnabled(ExperimentationConstants experiment)
{
var isExpForcedEnabled = false;
var isExpForcedDisabled = false;
if (!string.IsNullOrEmpty(experiment.FlightEnvironmentVariable))
{
string envVarOverride = _environmentVariableReader.GetEnvironmentVariable(experiment.FlightEnvironmentVariable);
isExpForcedDisabled = envVarOverride == "0";
isExpForcedEnabled = envVarOverride == "1";
}
return(!isExpForcedDisabled && (isExpForcedEnabled || _experimentationService.IsCachedFlightEnabled(experiment.FlightFlag)));
}
private static int GetIntFromEnvironmentVariable(string variableName, int defaultValue, IEnvironmentVariableReader environmentVariableReader)
{
int retrievedValue = defaultValue;
try
{
var variableValue = environmentVariableReader.GetEnvironmentVariable(variableName);
if (!string.IsNullOrEmpty(variableValue))
{
if (int.TryParse(variableValue, out int parsed))
{
retrievedValue = parsed;
}
}
}
catch (Exception) { }
return(retrievedValue);
}
private static bool GetBooleanFromEnvironmentVariable(string variableName, bool defaultValue, IEnvironmentVariableReader environmentVariableReader)
{
bool retrievedValue = defaultValue;
try
{
var variableValue = environmentVariableReader.GetEnvironmentVariable(variableName);
if (!string.IsNullOrEmpty(variableValue))
{
if (bool.TryParse(variableValue, out bool parsed))
{
retrievedValue = parsed;
}
}
}
catch (Exception) { }
return(retrievedValue);
}
internal PackageSpecReferenceDependencyProvider(
IEnumerable <ExternalProjectReference> externalProjects,
ILogger logger,
IEnvironmentVariableReader environmentVariableReader)
{
if (externalProjects == null)
{
throw new ArgumentNullException(nameof(externalProjects));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
foreach (var project in externalProjects)
{
Debug.Assert(
!_externalProjectsByPath.ContainsKey(project.UniqueName),
$"Duplicate project {project.UniqueName}");
if (!_externalProjectsByPath.ContainsKey(project.UniqueName))
{
_externalProjectsByPath.Add(project.UniqueName, project);
}
Debug.Assert(
!_externalProjectsByUniqueName.ContainsKey(project.ProjectName),
$"Duplicate project {project.ProjectName}");
if (!_externalProjectsByUniqueName.ContainsKey(project.ProjectName))
{
_externalProjectsByUniqueName.Add(project.ProjectName, project);
}
if (!_externalProjectsByUniqueName.ContainsKey(project.UniqueName))
{
_externalProjectsByUniqueName.Add(project.UniqueName, project);
}
}
_useLegacyAssetTargetFallbackBehavior = MSBuildStringUtility.IsTrue(environmentVariableReader.GetEnvironmentVariable("NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION"));
}
internal SourceRepositoryDependencyProvider(
SourceRepository sourceRepository,
ILogger logger,
SourceCacheContext cacheContext,
bool ignoreFailedSources,
bool ignoreWarning,
LocalPackageFileCache fileCache,
bool isFallbackFolderSource,
IEnvironmentVariableReader environmentVariableReader)
{
_sourceRepository = sourceRepository ?? throw new ArgumentNullException(nameof(sourceRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_cacheContext = cacheContext ?? throw new ArgumentNullException(nameof(cacheContext));
_ignoreFailedSources = ignoreFailedSources;
_ignoreWarning = ignoreWarning;
_packageFileCache = fileCache;
_isFallbackFolderSource = isFallbackFolderSource;
_useLegacyAssetTargetFallbackBehavior = MSBuildStringUtility.IsTrue(environmentVariableReader.GetEnvironmentVariable("NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION"));
}
internal WebProxy GetUserConfiguredProxy()
{
// Try reading from the settings. The values are stored as 3 config values http_proxy, http_proxy_user, http_proxy_password
var host = _settings.GetConfigValue(HostKey);
if (!String.IsNullOrEmpty(host))
{
// The host is the minimal value we need to assume a user configured proxy.
var webProxy = new WebProxy(host);
string userName = _settings.GetConfigValue(UserKey);
string password = _settings.GetConfigValue(PasswordKey, decrypt: true);
if (!String.IsNullOrEmpty(userName) && !String.IsNullOrEmpty(password))
{
webProxy.Credentials = new NetworkCredential(userName, password);
}
return(webProxy);
}
// Next try reading from the environment variable http_proxy. This would be specified as http://<username>:<password>@proxy.com
host = _environment.GetEnvironmentVariable(HostKey);
Uri uri;
if (!String.IsNullOrEmpty(host) && Uri.TryCreate(host, UriKind.Absolute, out uri))
{
var webProxy = new WebProxy(uri.GetComponents(UriComponents.HttpRequestUrl, UriFormat.SafeUnescaped));
if (!String.IsNullOrEmpty(uri.UserInfo))
{
var credentials = uri.UserInfo.Split(':');
if (credentials.Length > 1)
{
webProxy.Credentials = new NetworkCredential(userName: credentials[0], password: credentials[1]);
}
}
return(webProxy);
}
return(null);
}
internal NuGetFileLogger(IEnvironmentVariableReader environmentVariableReader)
{
if (environmentVariableReader == null)
{
throw new ArgumentNullException(nameof(environmentVariableReader));
}
_logDirectoryPath = environmentVariableReader.GetEnvironmentVariable("NUGET_SOLUTION_LOAD_LOGGING_PATH");
if (!string.IsNullOrWhiteSpace(_logDirectoryPath))
{
IsEnabled = true;
}
_startTime = DateTimeOffset.UtcNow;
_stopwatch = Stopwatch.StartNew();
// Created outside of the lambda below to capture the current time.
var message = $"The stopwatch frequency is {Stopwatch.Frequency}";
_streamWriter = new Lazy <StreamWriter>(() => CreateStreamWriter(message));
_streamWriterLock = new object();
}
public static string GetMSBuildArguments(
string entryPointTargetPath,
string inputTargetPath,
string nugetExePath,
string solutionDirectory,
string solutionName,
string restoreConfigFile,
string[] sources,
string packagesDirectory,
MsBuildToolset toolset,
RestoreLockProperties restoreLockProperties,
IEnvironmentVariableReader reader)
{
// args for MSBuild.exe
var args = new List <string>()
{
EscapeQuoted(inputTargetPath),
"/t:GenerateRestoreGraphFile",
"/nologo",
"/nr:false"
};
// Set the msbuild verbosity level if specified
var msbuildVerbosity = reader.GetEnvironmentVariable("NUGET_RESTORE_MSBUILD_VERBOSITY");
if (string.IsNullOrEmpty(msbuildVerbosity))
{
args.Add("/v:q");
}
else
{
args.Add($"/v:{msbuildVerbosity} ");
}
// Override the target under ImportsAfter with the current NuGet.targets version.
AddProperty(args, "NuGetRestoreTargets", entryPointTargetPath);
AddProperty(args, "RestoreUseCustomAfterTargets", bool.TrueString);
// Set path to nuget.exe or the build task
AddProperty(args, "RestoreTaskAssemblyFile", nugetExePath);
// Settings
AddRestoreSources(args, sources);
AddPropertyIfHasValue(args, "RestoreSolutionDirectory", solutionDirectory);
AddPropertyIfHasValue(args, "RestoreConfigFile", restoreConfigFile);
AddPropertyIfHasValue(args, "RestorePackagesPath", packagesDirectory);
AddPropertyIfHasValue(args, "SolutionDir", solutionDirectory);
AddPropertyIfHasValue(args, "SolutionName", solutionName);
// If the MSBuild version used does not support SkipNonextentTargets and BuildInParallel
// use the performance optimization
// When BuildInParallel is used with ContinueOnError it does not continue in some scenarios
if (toolset.ParsedVersion.CompareTo(new Version(15, 5)) < 0)
{
AddProperty(args, "RestoreBuildInParallel", bool.FalseString);
AddProperty(args, "RestoreUseSkipNonexistentTargets", bool.FalseString);
}
// Add additional args to msbuild if needed
var msbuildAdditionalArgs = reader.GetEnvironmentVariable("NUGET_RESTORE_MSBUILD_ARGS");
if (!string.IsNullOrEmpty(msbuildAdditionalArgs))
{
args.Add(msbuildAdditionalArgs);
}
AddPropertyIfHasValue(args, "RestorePackagesWithLockFile", restoreLockProperties.RestorePackagesWithLockFile);
AddPropertyIfHasValue(args, "NuGetLockFilePath", restoreLockProperties.NuGetLockFilePath);
if (restoreLockProperties.RestoreLockedMode)
{
AddProperty(args, "RestoreLockedMode", bool.TrueString);
}
return(string.Join(" ", args));
}
