public MultiSourcePackageMetadataProvider(
IEnumerable<SourceRepository> sourceRepositories,
SourceRepository optionalLocalRepository,
IEnumerable<SourceRepository> optionalGlobalLocalRepositories,
NuGetProject[] projects,
bool isSolution,
Common.ILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
if (projects == null)
{
throw new ArgumentNullException(nameof(projects));
}
_sourceRepositories = sourceRepositories;
_localRepository = optionalLocalRepository;
_globalLocalRepositories = optionalGlobalLocalRepositories;
_projects = projects;
_isSolution = isSolution;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public NuGetPackageHandler(Common.ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
}
public NuGetLoggerAdapter(Common.ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
}
public NuGetPackageHandler(string packageSource, Common.ILogger logger)
{
if (string.IsNullOrWhiteSpace(packageSource))
{
throw new ArgumentNullException("packageSource");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.packageSource = packageSource;
this.logger = logger;
}
/// <summary>
/// Constructor for testing
/// </summary>
public AnalyzerInstaller(string packageSource, string localCacheDirectory, Common.ILogger logger)
{
if (string.IsNullOrWhiteSpace(packageSource))
{
throw new ArgumentNullException("packageSource");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (string.IsNullOrWhiteSpace(localCacheDirectory))
{
throw new ArgumentNullException("localCacheDirectory");
}
this.packageSource = packageSource;
this.localCacheDirectory = localCacheDirectory;
this.logger = logger;
}
public override async Task <IEnumerable <NuGetVersion> > VersionStartsWith(
string packageId,
string versionPrefix,
bool includePrerelease,
SourceCacheContext sourceCacheContext,
Common.ILogger log,
CancellationToken token)
{
//*TODOs : Take prerelease as parameter. Also it should return both listed and unlisted for powershell ?
var packages = await _regResource.GetPackageMetadata(packageId, includePrerelease, false, sourceCacheContext, Common.NullLogger.Instance, token);
var versions = new List <NuGetVersion>();
foreach (var package in packages)
{
var version = (string)package["version"];
if (version.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))
{
versions.Add(new NuGetVersion(version));
}
}
return(versions);
}
public override async Task <IEnumerable <NuGetVersion> > VersionStartsWith(
string packageId,
string versionPrefix,
bool includePrerelease,
SourceCacheContext sourceCacheContext,
Common.ILogger log,
CancellationToken token)
{
var apiEndpointUri = new UriBuilder(new Uri(_baseUri, @"package-versions/" + packageId))
{
Query = $"includePrerelease={includePrerelease}&semVerLevel=2.0.0"
};
var results = await GetResults(apiEndpointUri.Uri, log, token);
var versions = results.ToList();
versions = versions
.Where(item => item.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))
.ToList();
return(versions.Select(item => NuGetVersion.Parse(item)));
}
public async override Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(
string searchTerm,
SearchFilter filters,
int skip,
int take,
Common.ILogger log,
CancellationToken cancellationToken)
{
var query = await _feedParser.Search(
searchTerm,
filters,
skip,
take,
log,
cancellationToken);
// NuGet.Server does not group packages by id, this resource needs to handle it.
var results = query.GroupBy(p => p.Id)
.Select(group => group.OrderByDescending(p => p.Version).First())
.Select(package => CreatePackageSearchResult(package, filters, log, cancellationToken));
return(results.ToList());
}
public NuGetPackageHandler(IPackageRepository remoteRepository, string localCacheRoot, Common.ILogger logger)
{
if (remoteRepository == null)
{
throw new ArgumentNullException("remoteRepository");
}
if (string.IsNullOrWhiteSpace(localCacheRoot))
{
throw new ArgumentNullException("localPackageDestination");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
this.remoteRepository = remoteRepository;
this.localCacheRoot = localCacheRoot;
Directory.CreateDirectory(localCacheRoot);
this.packageManager = new PackageManager(remoteRepository, localCacheRoot);
this.packageManager.Logger = new NuGetLoggerAdapter(logger);
}
public NuGetPackageHandler(IPackageRepository remoteRepository, string localCacheRoot, Common.ILogger logger)
{
if (remoteRepository == null)
{
throw new ArgumentNullException("remoteRepository");
}
if (string.IsNullOrWhiteSpace(localCacheRoot))
{
throw new ArgumentNullException("localPackageDestination");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
this.remoteRepository = remoteRepository;
this.localCacheRoot = localCacheRoot;
Directory.CreateDirectory(localCacheRoot);
this.packageManager = new PackageManager(remoteRepository, localCacheRoot);
this.packageManager.Logger = new NuGetLoggerAdapter(logger);
}
public InstalledPackageFeed(
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public UpdatePackageFeed(
IEnumerable <PackageCollectionItem> installedPackages,
IPackageMetadataProvider metadataProvider,
NuGetProject[] projects,
PackageSearchMetadataCache optionalCachedUpdates,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (projects == null)
{
throw new ArgumentNullException(nameof(projects));
}
_projects = projects;
_cachedUpdates = optionalCachedUpdates;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public OfflineFeedAddContext(
string packagePath,
string source,
Common.ILogger logger,
bool throwIfSourcePackageIsInvalid,
bool throwIfPackageExistsAndInvalid,
bool throwIfPackageExists,
bool expand)
{
if (string.IsNullOrEmpty(packagePath))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Strings.Argument_Cannot_Be_Null_Or_Empty,
nameof(packagePath)));
}
if (string.IsNullOrEmpty(source))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Strings.Argument_Cannot_Be_Null_Or_Empty,
nameof(source)));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
PackagePath = packagePath;
Source = source;
Logger = logger;
ThrowIfSourcePackageIsInvalid = throwIfSourcePackageIsInvalid;
ThrowIfPackageExists = throwIfPackageExists;
ThrowIfPackageExistsAndInvalid = throwIfPackageExistsAndInvalid;
Expand = expand;
}
public MultiSourcePackageMetadataProvider(
IEnumerable <SourceRepository> sourceRepositories,
SourceRepository optionalLocalRepository,
IEnumerable <SourceRepository> optionalGlobalLocalRepositories,
Common.ILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
_sourceRepositories = sourceRepositories;
_localRepository = optionalLocalRepository;
_globalLocalRepositories = optionalGlobalLocalRepositories;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public ConsolidatePackageFeed(
IEnumerable <PackageIdentity> installedPackages,
IPackageMetadataProvider metadataProvider,
Common.ILogger logger)
{
if (installedPackages == null)
{
throw new ArgumentNullException(nameof(installedPackages));
}
_installedPackages = installedPackages;
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
_metadataProvider = metadataProvider;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
PageSize = 25;
}
private static void LogTaskParam(Common.ILogger log, string direction, string name, params string[] values)
{
var stringValues = values?.Select(s => s) ?? Enumerable.Empty <string>();
log.Log(Common.LogLevel.Debug, $"({direction}) {name} '{string.Join(";", stringValues)}'");
}
/// <summary>
/// Query nuget package list from nuget server. This implementation optimized for performance so doesn't iterate whole result
/// returned nuget server, so as soon as find "take" number of result packages then stop processing and return the result.
/// </summary>
/// <param name="searchTerm">The term we're searching for.</param>
/// <param name="filter">Filter for whether to include prerelease, delisted, supportedframework flags in query.</param>
/// <param name="skip">Skip how many items from beginning of list.</param>
/// <param name="take">Return how many items.</param>
/// <param name="log">Logger instance.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>List of package meta data.</returns>
public override async Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(string searchTerm, SearchFilter filter, int skip, int take, Common.ILogger log, CancellationToken cancellationToken)
{
IEnumerable <PackageSearchMetadata> searchResultMetadata;
var metadataCache = new MetadataReferenceCache();
if (_client != null && _searchEndpoints != null)
{
searchResultMetadata = await Search(
searchTerm,
filter,
skip,
take,
Common.NullLogger.Instance,
cancellationToken);
}
else
{
#pragma warning disable CS0618
var searchResultJsonObjects = await _rawSearchResource.Search(searchTerm, filter, skip, take, Common.NullLogger.Instance, cancellationToken);
#pragma warning restore CS0618
searchResultMetadata = searchResultJsonObjects
.Select(s => s.FromJToken <PackageSearchMetadata>());
}
var searchResults = searchResultMetadata
.Select(m => m.WithVersions(() => GetVersions(m, filter)))
.Select(m => metadataCache.GetObject((PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)m))
.ToArray();
return(searchResults);
}
private async Task <T> SearchPage <T>(
Func <Uri, Task <T> > getResultAsync,
string searchTerm,
SearchFilter filters,
int skip,
int take,
Common.ILogger log,
CancellationToken cancellationToken)
{
for (var i = 0; i < _searchEndpoints.Length; i++)
{
var endpoint = _searchEndpoints[i];
// The search term comes in already encoded from VS
var queryUrl = new UriBuilder(endpoint.AbsoluteUri);
var queryString =
"q=" + searchTerm +
"&skip=" + skip.ToString() +
"&take=" + take.ToString() +
"&prerelease=" + filters.IncludePrerelease.ToString().ToLowerInvariant();
if (filters.IncludeDelisted)
{
queryString += "&includeDelisted=true";
}
if (filters.SupportedFrameworks != null &&
filters.SupportedFrameworks.Any())
{
var frameworks =
string.Join("&",
filters.SupportedFrameworks.Select(
fx => "supportedFramework=" + fx.ToString()));
queryString += "&" + frameworks;
}
if (filters.PackageTypes != null &&
filters.PackageTypes.Any())
{
var types = string.Join("&",
filters.PackageTypes.Select(
s => "packageTypeFilter=" + s));
queryString += "&" + types;
}
queryString += "&semVerLevel=2.0.0";
queryUrl.Query = queryString;
var searchResult = default(T);
try
{
searchResult = await getResultAsync(queryUrl.Uri);
}
catch (OperationCanceledException)
{
throw;
}
catch when(i < _searchEndpoints.Length - 1)
{
// Ignore all failures until the last endpoint
}
public ConsoleProjectContext(Common.ILogger logger)
{
_logger = logger;
}
/// <summary>
/// Download all needed packages for install actions.
/// </summary>
public static async Task <Dictionary <PackageIdentity, PackagePreFetcherResult> > GetPackagesAsync(
IEnumerable <NuGetProjectAction> actions,
FolderNuGetProject packagesFolder,
Configuration.ISettings settings,
Common.ILogger logger,
CancellationToken token)
{
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (packagesFolder == null)
{
throw new ArgumentNullException(nameof(packagesFolder));
}
if (actions == null)
{
throw new ArgumentNullException(nameof(actions));
}
var result = new Dictionary <PackageIdentity, PackagePreFetcherResult>();
var maxParallelTasks = PackageManagementConstants.DefaultMaxDegreeOfParallelism;
var toDownload = new Queue <NuGetProjectAction>();
var seen = new HashSet <PackageIdentity>();
// Find all uninstalled packages
var uninstalledPackages = new HashSet <PackageIdentity>(
actions.Where(action => action.NuGetProjectActionType == NuGetProjectActionType.Uninstall)
.Select(action => action.PackageIdentity));
// Check the packages folder for each package
// If the package is not found mark it for download
// These actions need to stay in order!
foreach (var action in actions)
{
// Ignore uninstalls here
// Avoid duplicate downloads
if (action.NuGetProjectActionType == NuGetProjectActionType.Install &&
seen.Add(action.PackageIdentity))
{
string installPath = null;
// Packages that are also being uninstalled cannot come from the
// packages folder since it will be gone. This is true for reinstalls.
if (!uninstalledPackages.Contains(action.PackageIdentity))
{
// Check the packages folder for the id and version
installPath = packagesFolder.GetInstalledPackageFilePath(action.PackageIdentity);
// Verify the nupkg exists
if (!File.Exists(installPath))
{
installPath = null;
}
}
// installPath will contain the full path of the already installed nupkg if it
// exists. If the path is empty it will need to be downloaded.
if (!string.IsNullOrEmpty(installPath))
{
// Create a download result using the already installed package
var downloadResult = new PackagePreFetcherResult(installPath, action.PackageIdentity);
result.Add(action.PackageIdentity, downloadResult);
}
else
{
// Download this package
toDownload.Enqueue(action);
}
}
}
// Check if any packages are not already in the packages folder
if (toDownload.Count > 0)
{
var downloadResults = new List <PackagePreFetcherResult>(maxParallelTasks);
while (toDownload.Count > 0)
{
// Throttle tasks
if (downloadResults.Count == maxParallelTasks)
{
// Wait for a task to complete
// This will not throw, exceptions are stored in the result
await Task.WhenAny(downloadResults.Select(e => e.EnsureResultAsync()));
// Remove all completed tasks
downloadResults.RemoveAll(e => e.IsComplete);
}
var action = toDownload.Dequeue();
// Download the package if it does not exist in the packages folder already
// Start the download task
var task = Task.Run(async() => await PackageDownloader.GetDownloadResourceResultAsync(
action.SourceRepository,
action.PackageIdentity,
settings,
logger,
token));
var downloadResult = new PackagePreFetcherResult(
task,
action.PackageIdentity,
action.SourceRepository.PackageSource);
downloadResults.Add(downloadResult);
result.Add(action.PackageIdentity, downloadResult);
}
}
// Do not wait for the remaining tasks to finish, these will download
// in the background while other operations such as uninstall run first.
return(result);
}
public SettingsCredentialProvider(Configuration.IPackageSourceProvider packageSourceProvider, Common.ILogger logger)
{
if (packageSourceProvider == null)
{
throw new ArgumentNullException(nameof(packageSourceProvider));
}
_packageSourceProvider = packageSourceProvider;
_logger = logger;
}
public AssemblyProtectionUtilities(Common.ILogger logger)
{
_logger = logger;
}
internal /* for testing */ static bool ShouldMergeAnalysisSettings(string language, AnalysisConfig config, Common.ILogger logger)
{
Debug.Assert(!string.IsNullOrEmpty(language));
Debug.Assert(config != null);
// See https://github.com/SonarSource/sonar-scanner-msbuild/issues/561
// Legacy behaviour is to overwrite.
// The new (SQ 7.4+) behaviour is to merge only if sonar.[LANGUAGE].roslyn.ignoreIssues is false.
var serverVersion = config?.FindServerVersion();
if (serverVersion == null || serverVersion < new Version("7.4"))
{
logger.LogInfo(Resources.AnalyzerSettings_ExternalIssueNotSupported, SonarProduct.GetSonarProductToLog(config?.SonarQubeHostUrl));
return(false);
}
var settingName = $"sonar.{language}.roslyn.ignoreIssues";
var settingInFile = config.GetSettingOrDefault(settingName, includeServerSettings: true, defaultValue: "false");
if (bool.TryParse(settingInFile, out var ignoreExternalRoslynIssues))
{
logger.LogDebug(Resources.AnalyzerSettings_ImportAllSettingValue, settingName, ignoreExternalRoslynIssues.ToString().ToLowerInvariant());
return(!ignoreExternalRoslynIssues);
}
else
{
logger.LogWarning(Resources.AnalyzerSettings_InvalidValueForImportAll, settingName, settingInFile);
return(false);
}
}
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);
}
}
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()
));
}
}
/// <summary>
/// Return package metadata for the input PackageIdentity
/// </summary>
public abstract Task <IPackageSearchMetadata> GetMetadataAsync(
PackageIdentity package,
SourceCacheContext sourceCacheContext,
Common.ILogger log,
CancellationToken token);
/// <summary>
/// Determines the restore style of a project.
/// </summary>
/// <param name="restoreProjectStyle">An optional user supplied restore style.</param>
/// <param name="hasPackageReferenceItems">A <see cref="bool"/> indicating whether or not the project has any PackageReference items.</param>
/// <param name="projectJsonPath">An optional path to the project's project.json file.</param>
/// <param name="projectDirectory">The full path to the project directory.</param>
/// <param name="projectName">The name of the project file.</param>
/// <param name="log">An <see cref="NuGet.Common.ILogger"/> object used to log messages.</param>
/// <returns>A <see cref="Tuple{ProjectStyle, Boolean}"/> containing the project style and a value indicating if the project is using a style that is compatible with PackageReference.
/// If the value of <paramref name="restoreProjectStyle"/> is not empty and could not be parsed, <code>null</code> is returned.</returns>
public static (ProjectStyle ProjectStyle, bool IsPackageReferenceCompatibleProjectStyle, string PackagesConfigFilePath) GetProjectRestoreStyle(string restoreProjectStyle, bool hasPackageReferenceItems, string projectJsonPath, string projectDirectory, string projectName, Common.ILogger log)
{
ProjectStyle projectStyle;
string packagesConfigFilePath = null;
// Allow a user to override by setting RestoreProjectStyle in the project.
if (!string.IsNullOrWhiteSpace(restoreProjectStyle))
{
if (!Enum.TryParse(restoreProjectStyle, ignoreCase: true, out projectStyle))
{
// Any value that is not recognized is treated as Unknown
projectStyle = ProjectStyle.Unknown;
}
}
else if (hasPackageReferenceItems)
{
// If any PackageReferences exist treat it as PackageReference. This has priority over project.json.
projectStyle = ProjectStyle.PackageReference;
}
else if (!string.IsNullOrWhiteSpace(projectJsonPath))
{
// If this is not a PackageReference project check if project.json or projectName.project.json exists.
projectStyle = ProjectStyle.ProjectJson;
}
else if (ProjectHasPackagesConfigFile(projectDirectory, projectName, out packagesConfigFilePath))
{
// If this is not a PackageReference or ProjectJson project check if packages.config or packages.ProjectName.config exists
projectStyle = ProjectStyle.PackagesConfig;
}
else
{
// This project is either a packages.config project or one that does not use NuGet at all.
projectStyle = ProjectStyle.Unknown;
}
bool isPackageReferenceCompatibleProjectStyle = projectStyle == ProjectStyle.PackageReference || projectStyle == ProjectStyle.DotnetToolReference;
return(projectStyle, isPackageReferenceCompatibleProjectStyle, packagesConfigFilePath);
}
public async override Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(string searchTerm, SearchFilter filter, int skip, int take, Common.ILogger log, CancellationToken cancellationToken)
{
var searchResultJsonObjects = await _rawSearchResource.Search(searchTerm, filter, skip, take, Common.NullLogger.Instance, cancellationToken);
var searchResults = searchResultJsonObjects
.Select(s => s.FromJToken <PackageSearchMetadata>())
.Select(m => m.WithVersions(() => GetVersions(m, filter)))
.ToArray();
return(searchResults);
}
public static void LogOutputParam(Common.ILogger log, string name, params string[] values)
{
LogTaskParam(log, "out", name, values);
}
public async override Task <IEnumerable <IPackageSearchMetadata> > SearchAsync(string searchTerm, SearchFilter filters, int skip, int take, Common.ILogger log, CancellationToken cancellationToken)
{
return(await Task.Run(() =>
{
// Check if source is available.
if (!IsHttpSource(V2Client.Source) && !IsLocalOrUNC(V2Client.Source))
{
throw new InvalidOperationException(string.Format(
Strings.Protocol_Search_LocalSourceNotFound,
V2Client.Source));
}
var query = V2Client.Search(
searchTerm,
filters.SupportedFrameworks,
filters.IncludePrerelease);
// V2 sometimes requires that we also use an OData filter for
// latest /latest prerelease version
if (filters.IncludePrerelease)
{
query = query.Where(p => p.IsAbsoluteLatestVersion);
}
else
{
query = query.Where(p => p.IsLatestVersion);
}
query = query
.OrderByDescending(p => p.DownloadCount)
.ThenBy(p => p.Id);
// Some V2 sources, e.g. NuGet.Server, local repository, the result contains all
// versions of each package. So we need to group the result by Id.
var collapsedQuery = query.AsEnumerable().AsCollapsed();
// execute the query
var packages = collapsedQuery
.Skip(skip)
.Take(take)
.ToArray();
return packages
.Select(package => CreatePackageSearchResult(package, filters, cancellationToken))
.ToArray();
}));
}
private static IEnumerable <Packaging.PackageReference> GetInstalledPackageReferences(string projectConfigFilePath, bool allowDuplicatePackageIds, Common.ILogger log)
{
if (File.Exists(projectConfigFilePath))
{
try
{
XDocument xDocument = XmlUtility.Load(projectConfigFilePath);
var reader = new PackagesConfigReader(xDocument);
return(reader.GetPackages(allowDuplicatePackageIds));
}
catch (XmlException ex)
{
var message = string.Format(
Strings.Error_PackagesConfigParseError,
projectConfigFilePath,
ex.Message);
throw new XmlException(message, ex);
}
}
return(Enumerable.Empty <Packaging.PackageReference>());
}
/// <summary>
/// Returns all index entries of type Package within the given range and filters
/// </summary>
public virtual Task <IEnumerable <JObject> > GetPackageEntries(string packageId, bool includeUnlisted, SourceCacheContext cacheContext, Common.ILogger log, CancellationToken token)
{
return(GetPackageMetadata(packageId, VersionRange.All, true, includeUnlisted, cacheContext, log, token));
}
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,
ConfigFile = MSBuildStringUtility.TrimAndGetNullForEmpty(RestoreConfigFile),
DisableParallel = RestoreDisableParallel,
GlobalPackagesFolder = RestorePackagesPath,
Log = log,
MachineWideSettings = new XPlatMachineWideSetting(),
PreLoadedRequestProviders = providers,
CachingSourceProvider = sourceProvider,
AllowNoOp = !RestoreForce,
HideWarningsAndErrors = HideWarningsAndErrors
};
if (!string.IsNullOrEmpty(RestoreSources))
{
var sources = MSBuildStringUtility.Split(RestoreSources);
restoreContext.Sources.AddRange(sources);
}
if (restoreContext.DisableParallel)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
_cts.Token.ThrowIfCancellationRequested();
var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, _cts.Token);
// Summary
RestoreSummary.Log(log, restoreSummaries);
return(restoreSummaries.All(x => x.Success));
}
}
/// <summary>
/// Returns the registration blob for the id and version
/// </summary>
/// <remarks>The inlined entries are potentially going away soon</remarks>
public virtual async Task <JObject> GetPackageMetadata(PackageIdentity identity, SourceCacheContext cacheContext, Common.ILogger log, CancellationToken token)
{
return((await GetPackageMetadata(identity.Id, new VersionRange(identity.Version, true, identity.Version, true), true, true, cacheContext, log, token)).SingleOrDefault());
}
public NuGetPackageHandler(IPackageRepository remoteRepository, string localCacheRoot, Common.ILogger logger)
{
if (string.IsNullOrWhiteSpace(localCacheRoot))
{
throw new ArgumentNullException(nameof(localCacheRoot));
}
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.remoteRepository = remoteRepository ?? throw new ArgumentNullException(nameof(remoteRepository));
LocalCacheRoot = localCacheRoot;
Directory.CreateDirectory(localCacheRoot);
packageManager = new PackageManager(remoteRepository, localCacheRoot)
{
Logger = new NuGetLoggerAdapter(logger)
};
}
public DiagnosticCommands(Common.ILogger log)
{
_log = log;
}
