public NugetPackage(ILogger logger)
{
_logger = logger;
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException ex)
{
// create default settings using a non-existent config file
settings = new Settings(nameof(Script.ScriptRunner));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance,
nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
}
catch (Exception e)
{
_logger?.LogError(e.Message + e.StackTrace);
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
/// <summary>
/// Configure NuGet's credential providers (i.e. support for authenticated package feeds).
/// </summary>
static void ConfigureNuGetCredentialProviders()
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(
logger: NuGetNullLogger.Instance,
nonInteractive: true
);
}
public async Task Run(SettingsContainer settings, bool write)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
DefaultCredentialServiceUtility.SetupDefaultCredentialService(_nugetLogger, true);
var folder = TargetFolder(settings.UserSettings);
var sources = _nuGetSourcesReader.Read(folder, settings.UserSettings.NuGetSources);
var sortedUpdates = await GetSortedUpdates(
folder,
sources,
settings.UserSettings.AllowedChange,
settings.UserSettings.UsePrerelease,
settings.PackageFilters?.Includes,
settings.PackageFilters?.Excludes);
Report(settings.UserSettings, sortedUpdates);
if (write)
{
await _updater.ApplyUpdates(sortedUpdates, folder, sources, settings);
}
}
public NuGetPackageDownloader(DirectoryPath packageInstallDir,
IFilePermissionSetter filePermissionSetter = null,
IFirstPartyNuGetPackageSigningVerifier firstPartyNuGetPackageSigningVerifier = null,
ILogger verboseLogger = null,
IReporter reporter = null,
RestoreActionConfig restoreActionConfig = null,
Func <IEnumerable <Task> > timer = null)
{
_packageInstallDir = packageInstallDir;
_reporter = reporter ?? Reporter.Output;
_verboseLogger = verboseLogger ?? new NuGetConsoleLogger();
_firstPartyNuGetPackageSigningVerifier = firstPartyNuGetPackageSigningVerifier ??
new FirstPartyNuGetPackageSigningVerifier(
tempDirectory: packageInstallDir, logger: _verboseLogger);
_filePermissionSetter = filePermissionSetter ?? new FilePermissionSetter();
_restoreActionConfig = restoreActionConfig ?? new RestoreActionConfig();
_retryTimer = timer;
_sourceRepositories = new Dictionary <PackageSource, SourceRepository>();
_cacheSettings = new SourceCacheContext
{
NoCache = _restoreActionConfig.NoCache,
DirectDownload = true,
IgnoreFailedSources = _restoreActionConfig.IgnoreFailedSources,
};
DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGetConsoleLogger(),
!_restoreActionConfig.Interactive);
}
public async Task <string> DownloadPackageAsync(PackageId packageId,
NuGetVersion packageVersion = null,
PackageSourceLocation packageSourceLocation = null,
bool includePreview = false,
DirectoryPath?downloadFolder = null)
{
CancellationToken cancellationToken = CancellationToken.None;
if (_restoreActionConfig.Interactive)
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(_verboseLogger,
_restoreActionConfig.Interactive);
}
(var source, var resolvedPackageVersion) = await GetPackageSourceAndVerion(packageId, packageVersion,
packageSourceLocation, includePreview);
FindPackageByIdResource resource = null;
SourceRepository repository = Repository.Factory.GetCoreV3(source);
resource = await repository.GetResourceAsync <FindPackageByIdResource>(cancellationToken)
.ConfigureAwait(false);
if (resource == null)
{
throw new NuGetPackageNotFoundException(
string.Format(LocalizableStrings.FailedToLoadNuGetSource, source.Source));
}
string nupkgPath = downloadFolder == null || !downloadFolder.HasValue
? Path.Combine(_packageInstallDir.Value, packageId.ToString(),
resolvedPackageVersion.ToNormalizedString(),
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg")
: Path.Combine(downloadFolder.Value.Value,
$"{packageId}.{resolvedPackageVersion.ToNormalizedString()}.nupkg");
Directory.CreateDirectory(Path.GetDirectoryName(nupkgPath));
using FileStream destinationStream = File.Create(nupkgPath);
bool success = await resource.CopyNupkgToStreamAsync(
packageId.ToString(),
resolvedPackageVersion,
destinationStream,
_cacheSettings,
_verboseLogger,
cancellationToken);
destinationStream.Close();
if (!success)
{
throw new NuGetPackageInstallerException(
string.Format("Downloading {0} version {1} failed", packageId,
packageVersion.ToNormalizedString()));
}
VerifySigning(nupkgPath);
return(nupkgPath);
}
public override bool Execute()
{
#if DEBUG
var debugRestoreTask = Environment.GetEnvironmentVariable("DEBUG_RESTORE_TASK");
if (!string.IsNullOrEmpty(debugRestoreTask) && debugRestoreTask.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
#if IS_CORECLR
Console.WriteLine("Waiting for debugger to attach.");
Console.WriteLine($"Process ID: {Process.GetCurrentProcess().Id}");
while (!Debugger.IsAttached)
{
System.Threading.Thread.Sleep(100);
}
Debugger.Break();
#else
Debugger.Launch();
#endif
}
#endif
var log = new MSBuildLogger(Log);
// Log inputs
log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'");
log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'");
log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'");
log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'");
log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'");
log.LogDebug($"(in) RestoreForce '{RestoreForce}'");
log.LogDebug($"(in) HideWarningsAndErrors '{HideWarningsAndErrors}'");
log.LogDebug($"(in) RestoreForceEvaluate '{RestoreForceEvaluate}'");
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive);
return(ExecuteAsync(log).Result);
}
catch (AggregateException ex) when(_cts.Token.IsCancellationRequested && ex.InnerException is TaskCanceledException)
{
// Canceled by user
log.LogError(Strings.RestoreCanceled);
return(false);
}
catch (Exception e)
{
ExceptionUtilities.LogException(e, log);
return(false);
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
// We need to update the delegating logger with a null instance
// because the tear downs of the plugins and similar rely on idleness and process exit.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
private static void InitializeNuGetCredentialService(INewCommandInput commandInput)
{
_ = commandInput ?? throw new ArgumentNullException(nameof(commandInput));
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(new CliNuGetLogger(), !commandInput.IsInteractiveFlagSpecified);
}
catch (Exception ex)
{
Reporter.Verbose.WriteLine(
string.Format(
LocalizableStrings.TemplatePackageCoordinator_Verbose_NuGetCredentialServiceError,
ex.ToString()));
}
}
public NuGetViewModel([Import(AllowDefault = true)] IExceptionManager?exceptionManager, IApplicationSettings appSettings)
{
try
{
var settings = LoadSettings();
ConfigPath = settings.GetConfigFilePaths().First();
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e)
{
_initializationException = ExceptionDispatchInfo.Capture(e);
ConfigPath = string.Empty;
GlobalPackageFolder = string.Empty;
}
Settings LoadSettings()
{
Settings?settings = null;
const int retries = 3;
for (var i = 1; i <= retries; i++)
{
try
{
settings = new Settings(appSettings.GetDefaultDocumentPath(), "RoslynPad.nuget.config");
}
catch (NuGetConfigurationException ex)
{
if (i == retries)
{
exceptionManager?.ReportError(ex);
throw;
}
}
}
return(settings !);
}
}
private static async Task <RestoreResultPair> PreviewAddPackageReferenceAsync(PackageReferenceArgs packageReferenceArgs,
DependencyGraphSpec dgSpec)
{
// Set user agent and connection settings.
XPlatUtility.ConfigureProtocol();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = false;
cacheContext.IgnoreFailedSources = false;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>
{
new DependencyGraphSpecRequestProvider(providerCache, dgSpec)
};
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
Log = packageReferenceArgs.Logger,
MachineWideSettings = new XPlatMachineWideSetting(),
GlobalPackagesFolder = packageReferenceArgs.PackageDirectory,
PreLoadedRequestProviders = providers,
Sources = packageReferenceArgs.Sources?.ToList()
};
// Generate Restore Requests. There will always be 1 request here since we are restoring for 1 project.
var restoreRequests = await RestoreRunner.GetRequests(restoreContext);
//Setup the Credential Service
DefaultCredentialServiceUtility.SetupDefaultCredentialService(restoreContext.Log, !packageReferenceArgs.Interactive);
// Run restore without commit. This will always return 1 Result pair since we are restoring for 1 request.
var restoreResult = await RestoreRunner.RunWithoutCommit(restoreRequests, restoreContext);
return(restoreResult.Single());
}
}
#pragma warning disable CS8618 // Non-nullable field is uninitialized.
public NuGetViewModel()
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
{
try {
var settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = settings.GetConfigFilePaths();
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e) {
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public NugetPackage(ILogger logger, NugetManager manager)
{
_manager = manager;
_logger = logger;
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException)
{
// create default settings using a non-existent config file
settings = new Settings(nameof(NugetPackage));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings);
var sources = SettingsUtility.GetEnabledSources(settings);
_packageSources = _manager.AdditionalSources.Select(p => new PackageSource(p.source, p.name)).Concat(sources).ToList();
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance,
nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3());
_sourceRepositories = _packageSources.Select(s => new SourceRepository(s, providers)).ToList();
}
catch (Exception e)
{
_logger?.LogError(e.Message + e.StackTrace);
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_RemovePkgRemovingReference,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
//Setup the Credential Service - This allows the msbuild sdk resolver to auth if needed.
DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive);
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageId,
versionRange: VersionRange.All,
typeConstraint: LibraryDependencyTarget.Package)
};
// Remove reference from the project
var result = msBuild.RemovePackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(Task.FromResult(result));
}
public async Task Run(SettingsContainer settings, bool write)
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGet.Common.NullLogger(), true);
var folder = TargetFolder(settings.UserSettings);
var sources = _nuGetSourcesReader.Read(folder, settings.UserSettings.NuGetSources);
var sortedUpdates = await GetSortedUpdates(
folder,
sources,
settings.UserSettings.AllowedChange,
settings.UserSettings.UsePrerelease,
settings.PackageFilters?.Includes,
settings.PackageFilters?.Excludes);
Report(settings.UserSettings, sortedUpdates);
if (write)
{
await _updater.ApplyUpdates(sortedUpdates, folder, sources, settings);
}
}
public NuGetViewModel(ITelemetryProvider telemetryProvider)
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
{
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException ex)
{
telemetryProvider.ReportError(ex);
// create default settings using a non-existent config file
settings = new Settings(nameof(RoslynPad));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e)
{
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
private async Task <bool> ExecuteAsync(Common.ILogger log)
{
if (RestoreGraphItems.Length < 1)
{
log.LogWarning(Strings.NoProjectsProvidedToTask);
return(true);
}
// Set user agent and connection settings.
ConfigureProtocol();
// Convert to the internal wrapper
var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem);
//var graphLines = RestoreGraphItems;
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = RestoreNoCache;
cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems);
if (dgFile.Restore.Count < 1)
{
// Restore will fail if given no inputs, but here we should skip it and provide a friendly message.
log.LogMinimal(Strings.NoProjectsToRestore);
return(true);
}
// Add all child projects
if (RestoreRecursive)
{
BuildTasksUtility.AddAllProjectsForRestore(dgFile);
}
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
DisableParallel = RestoreDisableParallel,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
AllowNoOp = !RestoreForce,
HideWarningsAndErrors = HideWarningsAndErrors,
RestoreForceEvaluate = RestoreForceEvaluate
};
// 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742)
// The workaround is to pass the '--disable-parallel' option.
// We apply the workaround by default when the system has 1 cpu.
// This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned.
if (Environment.ProcessorCount == 1)
{
restoreContext.DisableParallel = true;
}
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive);
_cts.Token.ThrowIfCancellationRequested();
var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token);
// Summary
RestoreSummary.Log(log, restoreSummaries);
return(restoreSummaries.All(x => x.Success));
}
}
private async Task <bool> DownloadAndExtractAsync(bool global, string id, string version, CancellationToken cancellationToken)
{
var logger = NullLogger.Instance;
DefaultCredentialServiceUtility.SetupDefaultCredentialService(logger, nonInteractive: false);
var settings = Settings.LoadDefaultSettings(root: Environment.CurrentDirectory);
var sources = PackageSourceProvider.LoadPackageSources(settings).Where(s => s.IsEnabled);
using (var cache = new SourceCacheContext())
{
PackageSource versionSource = null;
var nugetVersion = String.IsNullOrEmpty(version) ? null : new NuGetVersion(version);
if (nugetVersion is null)
{
foreach (var source in sources)
{
var repository = Repository.Factory.GetCoreV3(source.Source);
var resource = await repository.GetResourceAsync <FindPackageByIdResource>();
var availableVersions = await resource.GetAllVersionsAsync(id, cache, logger, cancellationToken);
foreach (var availableVersion in availableVersions)
{
if (nugetVersion is null || nugetVersion < availableVersion)
{
nugetVersion = availableVersion;
versionSource = source;
}
}
}
if (nugetVersion is null)
{
return(false);
}
}
var searchSources = versionSource is null ? sources : new[] { versionSource };
var extensionFolder = Path.Combine(this.CacheFolder(global), id, nugetVersion.ToString());
foreach (var source in searchSources)
{
var repository = Repository.Factory.GetCoreV3(source.Source);
var resource = await repository.GetResourceAsync <FindPackageByIdResource>();
using (var stream = new MemoryStream())
{
var downloaded = await resource.CopyNupkgToStreamAsync(id, nugetVersion, stream, cache, logger, cancellationToken);
if (downloaded)
{
stream.Position = 0;
using (var archive = new PackageArchiveReader(stream))
{
var files = PackagingConstants.Folders.Known.SelectMany(folder => archive.GetFiles(folder)).Distinct(StringComparer.OrdinalIgnoreCase);
await archive.CopyFilesAsync(extensionFolder, files, this.ExtractProgress, logger, cancellationToken);
}
return(true);
}
}
}
}
return(false);
}
private async Task <bool> ExecuteAsync(Common.ILogger log)
{
if (RestoreGraphItems.Length < 1)
{
log.LogWarning(Strings.NoProjectsProvidedToTask);
return(true);
}
// Set user agent and connection settings.
ConfigureProtocol();
// Convert to the internal wrapper
var wrappedItems = RestoreGraphItems.Select(MSBuildUtility.WrapMSBuildItem);
//var graphLines = RestoreGraphItems;
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = RestoreNoCache;
cacheContext.IgnoreFailedSources = RestoreIgnoreFailedSources;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
var dgFile = MSBuildRestoreUtility.GetDependencySpec(wrappedItems);
if (dgFile.Restore.Count < 1)
{
// Restore will fail if given no inputs, but here we should skip it and provide a friendly message.
log.LogMinimal(Strings.NoProjectsToRestore);
return(true);
}
// Add all child projects
if (RestoreRecursive)
{
BuildTasksUtility.AddAllProjectsForRestore(dgFile);
}
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dgFile));
var defaultSettings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceProvider = new CachingSourceProvider(new PackageSourceProvider(defaultSettings));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
DisableParallel = RestoreDisableParallel,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
CachingSourceProvider = sourceProvider,
AllowNoOp = !RestoreForce,
HideWarningsAndErrors = HideWarningsAndErrors,
RestoreForceEvaluate = RestoreForceEvaluate
};
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive);
_cts.Token.ThrowIfCancellationRequested();
var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token);
// Summary
RestoreSummary.Log(log, restoreSummaries);
return(restoreSummaries.All(x => x.Success));
}
}
public Task <bool> StartupAsync(CancellationToken token)
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(new NuGetLogger(_logger), !_userInput.IsInteractive);
return(Task.FromResult(true));
}
public static void Register(CommandLineApplication app, Func <ILogger> getLogger)
{
app.Command("delete", delete =>
{
delete.Description = Strings.Delete_Description;
delete.HelpOption(XPlatUtility.HelpOption);
delete.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var source = delete.Option(
"-s|--source <source>",
Strings.Source_Description,
CommandOptionType.SingleValue);
var nonInteractive = delete.Option(
"--non-interactive",
Strings.NonInteractive_Description,
CommandOptionType.NoValue);
var apikey = delete.Option(
"-k|--api-key <apiKey>",
Strings.ApiKey_Description,
CommandOptionType.SingleValue);
var arguments = delete.Argument(
"[root]",
Strings.Delete_PackageIdAndVersion_Description,
multipleValues: true);
var noServiceEndpointDescription = delete.Option(
"--no-service-endpoint",
Strings.NoServiceEndpoint_Description,
CommandOptionType.NoValue);
var interactive = delete.Option(
"--interactive",
Strings.PushDeleteCommand_Interactive,
CommandOptionType.SingleValue);
delete.OnExecute(async() =>
{
if (arguments.Values.Count < 2)
{
throw new ArgumentException(Strings.Delete_MissingArguments);
}
string packageId = arguments.Values[0];
string packageVersion = arguments.Values[1];
string sourcePath = source.Value();
string apiKeyValue = apikey.Value();
bool nonInteractiveValue = nonInteractive.HasValue();
bool noServiceEndpoint = noServiceEndpointDescription.HasValue();
DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue());
PackageSourceProvider sourceProvider = new PackageSourceProvider(XPlatUtility.CreateDefaultSettings());
await DeleteRunner.Run(
sourceProvider.Settings,
sourceProvider,
packageId,
packageVersion,
sourcePath,
apiKeyValue,
nonInteractiveValue,
noServiceEndpoint,
Confirm,
getLogger());
return(0);
});
});
}
public static void Register(CommandLineApplication app, Func <ILogger> getLogger,
Func <IListPackageCommandRunner> getCommandRunner)
{
app.Command("list", listpkg =>
{
listpkg.Description = Strings.ListPkg_Description;
listpkg.HelpOption(XPlatUtility.HelpOption);
listpkg.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var path = listpkg.Argument(
"<PROJECT | SOLUTION>",
Strings.ListPkg_PathDescription,
multipleValues: false);
var framework = listpkg.Option(
"--framework",
Strings.ListPkg_FrameworkDescription,
CommandOptionType.MultipleValue);
var includeOutdated = listpkg.Option(
"--outdated",
Strings.ListPkg_OutdatedDescription,
CommandOptionType.NoValue);
var includeDeprecated = listpkg.Option(
"--deprecated",
Strings.ListPkg_DeprecatedDescription,
CommandOptionType.NoValue);
var includeTransitive = listpkg.Option(
"--include-transitive",
Strings.ListPkg_TransitiveDescription,
CommandOptionType.NoValue);
var prerelease = listpkg.Option(
"--include-prerelease",
Strings.ListPkg_PrereleaseDescription,
CommandOptionType.NoValue);
var highestPatch = listpkg.Option(
"--highest-patch",
Strings.ListPkg_HighestPatchDescription,
CommandOptionType.NoValue);
var highestMinor = listpkg.Option(
"--highest-minor",
Strings.ListPkg_HighestMinorDescription,
CommandOptionType.NoValue);
var source = listpkg.Option(
"--source",
Strings.ListPkg_SourceDescription,
CommandOptionType.MultipleValue);
var config = listpkg.Option(
"--config",
Strings.ListPkg_ConfigDescription,
CommandOptionType.SingleValue);
var interactive = listpkg.Option(
"--interactive",
Strings.NuGetXplatCommand_Interactive,
CommandOptionType.NoValue);
listpkg.OnExecute(async() =>
{
var logger = getLogger();
var settings = ProcessConfigFile(config.Value(), path.Value);
var sources = source.Values;
var packageSources = GetPackageSources(settings, sources, config);
VerifyValidFrameworks(framework);
var packageRefArgs = new ListPackageArgs(
path.Value,
packageSources,
framework.Values,
includeOutdated.HasValue(),
includeDeprecated.HasValue(),
includeTransitive.HasValue(),
prerelease.HasValue(),
highestPatch.HasValue(),
highestMinor.HasValue(),
logger,
CancellationToken.None);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue());
var listPackageCommandRunner = getCommandRunner();
await listPackageCommandRunner.ExecuteCommandAsync(packageRefArgs);
return(0);
});
});
}
public static async Task <bool> RestoreAsync(
DependencyGraphSpec dependencyGraphSpec,
bool interactive,
bool recursive,
bool noCache,
bool ignoreFailedSources,
bool disableParallel,
bool force,
bool forceEvaluate,
bool hideWarningsAndErrors,
bool restorePC,
bool cleanupAssetsForUnsupportedProjects,
Common.ILogger log,
CancellationToken cancellationToken)
{
if (dependencyGraphSpec == null)
{
throw new ArgumentNullException(nameof(dependencyGraphSpec));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive);
// Set connection limit
NetworkProtocolUtility.SetConnectionLimit();
// Set user agent string used for network calls
#if IS_CORECLR
UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet .NET Core MSBuild Task")
.WithOSDescription(RuntimeInformation.OSDescription));
#else
// OS description is set by default on Desktop
UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet Desktop MSBuild Task"));
#endif
X509TrustStore.InitializeForDotNetSdk(log);
var restoreSummaries = new List <RestoreSummary>();
var providerCache = new RestoreCommandProvidersCache();
#if IS_DESKTOP
if (restorePC && dependencyGraphSpec.Projects.Any(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig))
{
var v2RestoreResult = await PerformNuGetV2RestoreAsync(log, dependencyGraphSpec, noCache, disableParallel, interactive);
restoreSummaries.Add(v2RestoreResult);
if (restoreSummaries.Count < 1)
{
var message = string.Format(
Strings.InstallCommandNothingToInstall,
"packages.config"
);
log.LogMinimal(message);
}
if (!v2RestoreResult.Success)
{
v2RestoreResult
.Errors
.Where(l => l.Level == LogLevel.Warning)
.ForEach(message =>
{
log.LogWarning(message.Message);
});
}
}
#endif
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = noCache;
cacheContext.IgnoreFailedSources = ignoreFailedSources;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
if (dependencyGraphSpec.Restore.Count > 0)
{
// Add all child projects
if (recursive)
{
AddAllProjectsForRestore(dependencyGraphSpec);
}
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dependencyGraphSpec));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
// 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742)
// The workaround is to pass the '--disable-parallel' option.
// We apply the workaround by default when the system has 1 cpu.
// This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned.
DisableParallel = Environment.ProcessorCount == 1 ? true : disableParallel,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
AllowNoOp = !force,
HideWarningsAndErrors = hideWarningsAndErrors,
RestoreForceEvaluate = forceEvaluate
};
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
cancellationToken.ThrowIfCancellationRequested();
restoreSummaries.AddRange(await RestoreRunner.RunAsync(restoreContext, cancellationToken));
}
if (cleanupAssetsForUnsupportedProjects)
{
// Restore assets are normally left on disk between restores for all projects. This can cause a condition where a project that supports PackageReference was restored
// but then a user changes a branch or some other condition and now the project does not use PackageReference. Since the restore assets are left on disk, the build
// consumes them which can cause build errors. The code below cleans up all of the files that we write so that they are not used during build
Parallel.ForEach(dependencyGraphSpec.Projects.Where(i => !DoesProjectSupportRestore(i)), project =>
{
if (project.RestoreMetadata == null || string.IsNullOrWhiteSpace(project.RestoreMetadata.OutputPath) || string.IsNullOrWhiteSpace(project.RestoreMetadata.ProjectPath))
{
return;
}
// project.assets.json
FileUtility.Delete(Path.Combine(project.RestoreMetadata.OutputPath, LockFileFormat.AssetsFileName));
// project.csproj.nuget.cache
FileUtility.Delete(project.RestoreMetadata.CacheFilePath);
// project.csproj.nuget.g.props
FileUtility.Delete(BuildAssetsUtils.GetMSBuildFilePathForPackageReferenceStyleProject(project, BuildAssetsUtils.PropsExtension));
// project..csproj.nuget.g.targets
FileUtility.Delete(BuildAssetsUtils.GetMSBuildFilePathForPackageReferenceStyleProject(project, BuildAssetsUtils.TargetsExtension));
// project.csproj.nuget.dgspec.json
FileUtility.Delete(Path.Combine(project.RestoreMetadata.OutputPath, DependencyGraphSpec.GetDGSpecFileName(Path.GetFileName(project.RestoreMetadata.ProjectPath))));
});
}
}
if (restoreSummaries.Count < 1)
{
log.LogMinimal(Strings.NoProjectsToRestore);
}
else
{
RestoreSummary.Log(log, restoreSummaries);
}
return(restoreSummaries.All(x => x.Success));
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
// We need to update the delegating logger with a null instance
// because the tear downs of the plugins and similar rely on idleness and process exit.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
public async Task <int> Run(RepositorySettings repository,
GitUsernamePasswordCredentials credentials,
SettingsContainer settings, User user)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (credentials == null)
{
throw new ArgumentNullException(nameof(credentials));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
DefaultCredentialServiceUtility.SetupDefaultCredentialService(_nugetLogger, true);
try
{
var repositoryData = await BuildGitRepositorySpec(repository, credentials.Username);
if (repositoryData == null)
{
return(0);
}
// should perform the remote check for "is this a .NET repo"
// (and also not a github fork)
// only when we have multiple remote repos
// otherwise it's ok to work locally, and check there
if (!(settings.SourceControlServerSettings.Scope == ServerScope.Repository || repository.IsLocalRepo))
{
var remoteRepoContainsDotNet = await _repositoryFilter.ContainsDotNetProjects(repository);
if (!remoteRepoContainsDotNet)
{
return(0);
}
}
IFolder folder;
if (repository.IsLocalRepo)
{
folder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.LocalRepositoryUri.AbsolutePath)));
settings.WorkingFolder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.WorkingFolder.AbsolutePath)));
repositoryData.IsLocalRepo = repository.IsLocalRepo;
if (!repositoryData.IsFork) //check if we are on a fork. If not on a fork we set the remote to the locally found remote
{
repositoryData.Remote = repository.RemoteInfo.RemoteName;
}
}
else
{
folder = !string.IsNullOrWhiteSpace(settings?.UserSettings?.Directory)
? _folderFactory.FolderFromPath(settings.UserSettings.Directory)
: _folderFactory.UniqueTemporaryFolder();
settings.WorkingFolder = folder;
}
if (!string.IsNullOrEmpty(repository.RemoteInfo?.BranchName))
{
repositoryData.DefaultBranch = repository.RemoteInfo.BranchName;
}
repositoryData.IsLocalRepo = repository.IsLocalRepo;
IGitDriver git = string.IsNullOrWhiteSpace(settings?.UserSettings?.GitPath) ?
new LibGit2SharpDriver(_logger, folder, credentials, user) as IGitDriver :
new GitCmdDriver(settings.UserSettings.GitPath, _logger, folder, credentials) as IGitDriver;
var updatesDone = await _repositoryUpdater.Run(git, repositoryData, settings);
if (!repository.IsLocalRepo)
{
folder.TryDelete();
}
return(updatesDone);
}
#pragma warning disable CA1031
catch (Exception ex)
#pragma warning restore CA1031
{
_logger.Error($"Failed on repo {repository.RepositoryName}", ex);
return(1);
}
}
public static async Task <bool> RestoreAsync(
DependencyGraphSpec dependencyGraphSpec,
bool interactive,
bool recursive,
bool noCache,
bool ignoreFailedSources,
bool disableParallel,
bool force,
bool forceEvaluate,
bool hideWarningsAndErrors,
bool restorePC,
Common.ILogger log,
CancellationToken cancellationToken)
{
if (dependencyGraphSpec == null)
{
throw new ArgumentNullException(nameof(dependencyGraphSpec));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive);
// Set connection limit
NetworkProtocolUtility.SetConnectionLimit();
// Set user agent string used for network calls
#if IS_CORECLR
UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet .NET Core MSBuild Task")
.WithOSDescription(RuntimeInformation.OSDescription));
#else
// OS description is set by default on Desktop
UserAgent.SetUserAgentString(new UserAgentStringBuilder("NuGet Desktop MSBuild Task"));
#endif
// This method has no effect on .NET Core.
NetworkProtocolUtility.ConfigureSupportedSslProtocols();
var restoreSummaries = new List <RestoreSummary>();
var providerCache = new RestoreCommandProvidersCache();
#if IS_DESKTOP
if (restorePC && dependencyGraphSpec.Projects.Any(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig))
{
var v2RestoreResult = await PerformNuGetV2RestoreAsync(log, dependencyGraphSpec, noCache, disableParallel, interactive);
restoreSummaries.Add(v2RestoreResult);
if (restoreSummaries.Count < 1)
{
var message = string.Format(
Strings.InstallCommandNothingToInstall,
"packages.config"
);
log.LogMinimal(message);
}
if (!v2RestoreResult.Success)
{
v2RestoreResult
.Errors
.Where(l => l.Level == LogLevel.Warning)
.ForEach(message =>
{
log.LogWarning(message.Message);
});
}
}
#endif
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = noCache;
cacheContext.IgnoreFailedSources = ignoreFailedSources;
// Pre-loaded request provider containing the graph file
var providers = new List <IPreLoadedRestoreRequestProvider>();
if (dependencyGraphSpec.Restore.Count > 0)
{
// Add all child projects
if (recursive)
{
AddAllProjectsForRestore(dependencyGraphSpec);
}
providers.Add(new DependencyGraphSpecRequestProvider(providerCache, dependencyGraphSpec));
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
LockFileVersion = LockFileFormat.Version,
// 'dotnet restore' fails on slow machines (https://github.com/NuGet/Home/issues/6742)
// The workaround is to pass the '--disable-parallel' option.
// We apply the workaround by default when the system has 1 cpu.
// This will fix restore failures on VMs with 1 CPU and containers with less or equal to 1 CPU assigned.
DisableParallel = Environment.ProcessorCount == 1 ? true : disableParallel,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
AllowNoOp = !force,
HideWarningsAndErrors = hideWarningsAndErrors,
RestoreForceEvaluate = forceEvaluate
};
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
cancellationToken.ThrowIfCancellationRequested();
restoreSummaries.AddRange(await RestoreRunner.RunAsync(restoreContext, cancellationToken));
}
}
if (restoreSummaries.Count < 1)
{
log.LogMinimal(Strings.NoProjectsToRestore);
}
else
{
RestoreSummary.Log(log, restoreSummaries);
}
return(restoreSummaries.All(x => x.Success));
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
// We need to update the delegating logger with a null instance
// because the tear downs of the plugins and similar rely on idleness and process exit.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
public static void Register(CommandLineApplication app, Func <ILogger> getLogger)
{
app.Command("push", push =>
{
push.Description = Strings.Push_Description;
push.HelpOption(XPlatUtility.HelpOption);
push.Option(
CommandConstants.ForceEnglishOutputOption,
Strings.ForceEnglishOutput_Description,
CommandOptionType.NoValue);
var source = push.Option(
"-s|--source <source>",
Strings.Source_Description,
CommandOptionType.SingleValue);
var symbolSource = push.Option(
"-ss|--symbol-source <source>",
Strings.SymbolSource_Description,
CommandOptionType.SingleValue);
var timeout = push.Option(
"-t|--timeout <timeout>",
Strings.Push_Timeout_Description,
CommandOptionType.SingleValue);
var apikey = push.Option(
"-k|--api-key <apiKey>",
Strings.ApiKey_Description,
CommandOptionType.SingleValue);
var symbolApiKey = push.Option(
"-sk|--symbol-api-key <apiKey>",
Strings.SymbolApiKey_Description,
CommandOptionType.SingleValue);
var disableBuffering = push.Option(
"-d|--disable-buffering",
Strings.DisableBuffering_Description,
CommandOptionType.SingleValue);
var noSymbols = push.Option(
"-n|--no-symbols",
Strings.NoSymbols_Description,
CommandOptionType.SingleValue);
var arguments = push.Argument(
"[root]",
Strings.Push_Package_ApiKey_Description,
multipleValues: true);
var noServiceEndpointDescription = push.Option(
"--no-service-endpoint",
Strings.NoServiceEndpoint_Description,
CommandOptionType.NoValue);
var interactive = push.Option(
"--interactive",
Strings.NuGetXplatCommand_Interactive,
CommandOptionType.NoValue);
push.OnExecute(async() =>
{
if (arguments.Values.Count < 1)
{
throw new ArgumentException(Strings.Push_MissingArguments);
}
string packagePath = arguments.Values[0];
string sourcePath = source.Value();
string apiKeyValue = apikey.Value();
string symbolSourcePath = symbolSource.Value();
string symbolApiKeyValue = symbolApiKey.Value();
bool disableBufferingValue = disableBuffering.HasValue();
bool noSymbolsValue = noSymbols.HasValue();
bool noServiceEndpoint = noServiceEndpointDescription.HasValue();
int timeoutSeconds = 0;
if (timeout.HasValue() && !int.TryParse(timeout.Value(), out timeoutSeconds))
{
throw new ArgumentException(Strings.Push_InvalidTimeout);
}
var sourceProvider = new PackageSourceProvider(XPlatUtility.CreateDefaultSettings());
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue());
await PushRunner.Run(
sourceProvider.Settings,
sourceProvider,
packagePath,
sourcePath,
apiKeyValue,
symbolSourcePath,
symbolApiKeyValue,
timeoutSeconds,
disableBufferingValue,
noSymbolsValue,
noServiceEndpoint,
getLogger());
}
catch (TaskCanceledException ex)
{
throw new AggregateException(ex, new Exception(Strings.Push_Timeout_Error));
}
return(0);
});
});
}
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory)
{
// Cast the NuGet version since the caller does not want to consume NuGet classes directly
var parsedSdkVersion = (NuGetVersion)nuGetVersion;
// Stores errors and warnings for the result
ICollection <string> errors = new List <string>();
ICollection <string> warnings = new List <string>();
// Load NuGet settings and a path resolver
var settings = Settings.LoadDefaultSettings(context.ProjectFilePath);
var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
var libraryIdentity = new LibraryIdentity(sdk.Name, parsedSdkVersion, LibraryType.Package);
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, libraryIdentity, out var installedPath, out var installedVersion))
{
try
{
var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: context.IsNonInteractive());
// Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files
// This must be run in its own task because legacy project system evaluates projects on the UI thread which can cause RunWithoutCommit() to deadlock
// https://developercommunity.visualstudio.com/content/problem/311379/solution-load-never-completes-when-project-contain.html
var restoreTask = Task.Run(() => RestoreRunnerEx.RunWithoutCommit(
libraryIdentity,
settings,
nugetSDKLogger));
var results = restoreTask.Result;
fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Look for a successful result, any errors are logged by NuGet
foreach (var result in results.Select(i => i.Result).Where(i => i.Success))
{
// Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0)
var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i == libraryIdentity);
if (installedPackage != null)
{
if (TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage, out installedPath, out installedVersion))
{
break;
}
// This should never happen because we were told the package was successfully installed.
// If we can't find it, we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk));
}
else
{
// This should never happen because we were told the restore succeeded.
// If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name));
}
}
}
catch (Exception e)
{
errors.Add(e.Message);
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
if (errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings));
}
return(factory.IndicateFailure(errors, warnings));
}
public async Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgAddingReference,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
if (packageReferenceArgs.NoRestore)
{
packageReferenceArgs.Logger.LogWarning(string.Format(CultureInfo.CurrentCulture,
Strings.Warn_AddPkgWithoutRestore));
VersionRange versionRange = default;
if (packageReferenceArgs.NoVersion)
{
versionRange = packageReferenceArgs.Prerelease ?
VersionRange.Parse("*-*") :
VersionRange.Parse("*");
}
else
{
versionRange = VersionRange.Parse(packageReferenceArgs.PackageVersion);
}
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageId,
versionRange: versionRange,
typeConstraint: LibraryDependencyTarget.Package)
};
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(0);
}
// 1. Get project dg file
packageReferenceArgs.Logger.LogDebug("Reading project Dependency Graph");
var dgSpec = ReadProjectDependencyGraph(packageReferenceArgs);
if (dgSpec == null)
{
// Logging non localized error on debug stream.
packageReferenceArgs.Logger.LogDebug(Strings.Error_NoDgSpec);
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoDgSpec));
}
packageReferenceArgs.Logger.LogDebug("Project Dependency Graph Read");
var projectFullPath = Path.GetFullPath(packageReferenceArgs.ProjectPath);
var matchingPackageSpecs = dgSpec
.Projects
.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference &&
PathUtility.GetStringComparerBasedOnOS().Equals(Path.GetFullPath(p.RestoreMetadata.ProjectPath), projectFullPath))
.ToArray();
// This ensures that the DG specs generated in previous steps contain exactly 1 project with the same path as the project requesting add package.
// Throw otherwise since we cannot proceed further.
if (matchingPackageSpecs.Length != 1)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
Strings.Error_UnsupportedProject,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
}
// Parse the user specified frameworks once to avoid re-do's
var userSpecifiedFrameworks = Enumerable.Empty <NuGetFramework>();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
userSpecifiedFrameworks = packageReferenceArgs
.Frameworks
.Select(f => NuGetFramework.Parse(f));
}
var originalPackageSpec = matchingPackageSpecs.FirstOrDefault();
// 2. Determine the version
// Setup the Credential Service before making any potential http calls.
DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive);
if (packageReferenceArgs.Sources?.Any() == true)
{
// Convert relative path to absolute path if there is any
List <string> sources = new List <string>();
foreach (string source in packageReferenceArgs.Sources)
{
sources.Add(UriUtility.GetAbsolutePath(Environment.CurrentDirectory, source));
}
originalPackageSpec.RestoreMetadata.Sources =
sources.Where(ns => !string.IsNullOrEmpty(ns))
.Select(ns => new PackageSource(ns))
.ToList();
}
PackageDependency packageDependency = default;
if (packageReferenceArgs.NoVersion)
{
var latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, packageReferenceArgs.Prerelease);
if (latestVersion == null)
{
if (!packageReferenceArgs.Prerelease)
{
latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, !packageReferenceArgs.Prerelease);
if (latestVersion != null)
{
throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.PrereleaseVersionsAvailable, latestVersion));
}
}
throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoVersionsAvailable, packageReferenceArgs.PackageId));
}
packageDependency = new PackageDependency(packageReferenceArgs.PackageId, new VersionRange(minVersion: latestVersion, includeMinVersion: true));
}
else
{
packageDependency = new PackageDependency(packageReferenceArgs.PackageId, VersionRange.Parse(packageReferenceArgs.PackageVersion));
}
// Create a copy to avoid modifying the original spec which may be shared.
var updatedPackageSpec = originalPackageSpec.Clone();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If user specified frameworks then just use them to add the dependency
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec,
packageDependency,
userSpecifiedFrameworks);
}
else
{
// If the user has not specified a framework, then just add it to all frameworks
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageDependency, updatedPackageSpec.TargetFrameworks.Select(e => e.FrameworkName));
}
var updatedDgSpec = dgSpec.WithReplacedSpec(updatedPackageSpec).WithoutRestores();
updatedDgSpec.AddRestore(updatedPackageSpec.RestoreMetadata.ProjectUniqueName);
// 3. Run Restore Preview
packageReferenceArgs.Logger.LogDebug("Running Restore preview");
var restorePreviewResult = await PreviewAddPackageReferenceAsync(packageReferenceArgs,
updatedDgSpec);
packageReferenceArgs.Logger.LogDebug("Restore Review completed");
// 4. Process Restore Result
var compatibleFrameworks = new HashSet <NuGetFramework>(
restorePreviewResult
.Result
.CompatibilityCheckResults
.Where(t => t.Success)
.Select(t => t.Graph.Framework), new NuGetFrameworkFullComparer());
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user has specified frameworks then we intersect that with the compatible frameworks.
var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>(
userSpecifiedFrameworks,
new NuGetFrameworkFullComparer());
compatibleFrameworks.IntersectWith(userSpecifiedFrameworkSet);
}
// 5. Write to Project
if (compatibleFrameworks.Count == 0)
{
// Package is compatible with none of the project TFMs
// Do not add a package reference, throw appropriate error
packageReferenceArgs.Logger.LogError(string.Format(CultureInfo.CurrentCulture,
Strings.Error_AddPkgIncompatibleWithAllFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.Frameworks?.Any() == true ? Strings.AddPkg_UserSpecified : Strings.AddPkg_All,
packageReferenceArgs.ProjectPath));
return(1);
}
// Ignore the graphs with RID
else if (compatibleFrameworks.Count ==
restorePreviewResult.Result.CompatibilityCheckResults.Where(r => string.IsNullOrEmpty(r.Graph.RuntimeIdentifier)).Count())
{
// Package is compatible with all the project TFMs
// Add an unconditional package reference to the project
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithAllFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency);
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
}
else
{
// Package is compatible with some of the project TFMs
// Add conditional package references to the project for the compatible TFMs
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithSubsetFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
var compatibleOriginalFrameworks = compatibleFrameworks
.Select(e => GetAliasForFramework(originalPackageSpec, e))
.Where(originalFramework => originalFramework != null);
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency);
msBuild.AddPackageReferencePerTFM(packageReferenceArgs.ProjectPath,
libraryDependency,
compatibleOriginalFrameworks);
}
// 6. Commit restore result
await RestoreRunner.CommitAsync(restorePreviewResult, CancellationToken.None);
return(0);
}
private static async Task <RestoreSummary> PerformNuGetV2RestoreAsync(Common.ILogger log, DependencyGraphSpec dgFile, bool noCache, bool disableParallel, bool interactive)
{
string globalPackageFolder = null;
string repositoryPath = null;
string firstPackagesConfigPath = null;
IList <PackageSource> packageSources = null;
var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer());
ISettings settings = null;
foreach (PackageSpec packageSpec in dgFile.Projects.Where(i => i.RestoreMetadata.ProjectStyle == ProjectStyle.PackagesConfig))
{
var pcRestoreMetadata = (PackagesConfigProjectRestoreMetadata)packageSpec.RestoreMetadata;
globalPackageFolder = globalPackageFolder ?? pcRestoreMetadata.PackagesPath;
repositoryPath = repositoryPath ?? pcRestoreMetadata.RepositoryPath;
if (packageSources == null)
{
packageSources = new List <PackageSource>();
if (!noCache)
{
if (!string.IsNullOrEmpty(globalPackageFolder) && Directory.Exists(globalPackageFolder))
{
packageSources.Add(new FeedTypePackageSource(globalPackageFolder, FeedType.FileSystemV3));
}
}
packageSources.AddRange(pcRestoreMetadata.Sources);
}
settings = settings ?? Settings.LoadSettingsGivenConfigPaths(pcRestoreMetadata.ConfigFilePaths);
var packagesConfigPath = Path.Combine(Path.GetDirectoryName(pcRestoreMetadata.ProjectPath), NuGetConstants.PackageReferenceFile);
firstPackagesConfigPath = firstPackagesConfigPath ?? packagesConfigPath;
installedPackageReferences.AddRange(GetInstalledPackageReferences(packagesConfigPath, allowDuplicatePackageIds: true, log));
}
if (string.IsNullOrEmpty(repositoryPath))
{
throw new InvalidOperationException(Strings.RestoreNoSolutionFound);
}
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings);
var sourceRepositoryProvider = new CachingSourceProvider(packageSourceProvider);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, repositoryPath);
var effectivePackageSaveMode = CalculateEffectivePackageSaveMode(settings);
var packageSaveMode = effectivePackageSaveMode == Packaging.PackageSaveMode.None ?
Packaging.PackageSaveMode.Defaultv2 :
effectivePackageSaveMode;
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray();
if (missingPackageReferences.Length == 0)
{
return(new RestoreSummary(true));
}
var packageRestoreData = missingPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { firstPackagesConfigPath },
isMissing: true));
var repositories = sourceRepositoryProvider.GetRepositories().ToArray();
var installCount = 0;
var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>();
var collectorLogger = new RestoreCollectorLogger(log);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); },
packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
sourceRepositories: repositories,
maxNumberOfParallelTasks: disableParallel
? 1
: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: collectorLogger);
// TODO: Check require consent?
// NOTE: This feature is currently not working at all. See https://github.com/NuGet/Home/issues/4327
// CheckRequireConsent();
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, collectorLogger);
var projectContext = new ConsoleProjectContext(collectorLogger)
{
PackageExtractionContext = new PackageExtractionContext(
packageSaveMode,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext,
collectorLogger)
};
if (effectivePackageSaveMode != Packaging.PackageSaveMode.None)
{
projectContext.PackageExtractionContext.PackageSaveMode = packageSaveMode;
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = noCache;
var downloadContext = new PackageDownloadContext(cacheContext, repositoryPath, directDownload: false)
{
ClientPolicyContext = clientPolicyContext
};
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !interactive);
var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
projectContext,
downloadContext);
return(new RestoreSummary(
result.Restored,
"packages.config projects",
settings.GetConfigFilePaths().ToArray(),
packageSources.Select(x => x.Source).ToArray(),
installCount,
collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents)).ToArray()
));
}
}
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory)
{
// Cast the NuGet version since the caller does not want to consume NuGet classes directly
var parsedSdkVersion = (NuGetVersion)nuGetVersion;
// Stores errors and warnings for the result
ICollection <string> errors = new List <string>();
ICollection <string> warnings = new List <string>();
// Load NuGet settings and a path resolver
var settings = Settings.LoadDefaultSettings(context.ProjectFilePath);
var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, sdk.Name, parsedSdkVersion, out var installedPath, out var installedVersion))
{
try
{
var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: true);
// Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files
var results = RestoreRunnerEx.RunWithoutCommit(
context.ProjectFilePath,
sdk.Name,
parsedSdkVersion.ToFullString(),
settings,
nugetSDKLogger)
.ConfigureAwait(continueOnCapturedContext: false)
.GetAwaiter()
.GetResult();
fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Look for a successful result, any errors are logged by NuGet
foreach (var result in results.Select(i => i.Result).Where(i => i.Success))
{
// Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0)
var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i.Name.Equals(sdk.Name));
if (installedPackage != null)
{
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage.Name, installedPackage.Version, out installedPath, out installedVersion))
{
// This should never happen because we were told the package was successfully installed.
// If we can't find it, we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk));
}
}
else
{
// This should never happen because we were told the restore succeeded.
// If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name));
}
}
}
catch (Exception e)
{
errors.Add(e.Message);
}
}
if (errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings));
}
return(factory.IndicateFailure(errors, warnings));
}
