/// <summary>
/// This constructor is just used for testing.
/// </summary>
public VsPathContextProvider(
ISettings settings,
IVsSolutionManager solutionManager,
NuGet.Common.ILogger logger,
IVsProjectAdapterProvider vsProjectAdapterProvider,
Func <string, LockFile> getLockFileOrNull)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (solutionManager == null)
{
throw new ArgumentNullException(nameof(solutionManager));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (vsProjectAdapterProvider == null)
{
throw new ArgumentNullException(nameof(vsProjectAdapterProvider));
}
_settings = new Lazy <ISettings>(() => settings);
_solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager);
_logger = new Lazy <NuGet.Common.ILogger>(() => logger);
_vsProjectAdapterProvider = new Lazy <IVsProjectAdapterProvider>(() => vsProjectAdapterProvider);
_getLockFileOrNull = getLockFileOrNull ?? BuildIntegratedProjectUtility.GetLockFileOrNull;
}
public VsSolutionRestoreService(
IProjectSystemCache projectSystemCache,
ISolutionRestoreWorker restoreWorker,
[Import("VisualStudioActivityLogger")]
NuGet.Common.ILogger logger)
{
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
if (restoreWorker == null)
{
throw new ArgumentNullException(nameof(restoreWorker));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_projectSystemCache = projectSystemCache;
_restoreWorker = restoreWorker;
_logger = logger;
}
/// <summary>
/// This constructor is just used for testing.
/// </summary>
public VsPathContextProvider(
ISettings settings,
IVsSolutionManager solutionManager,
NuGet.Common.ILogger logger,
Func <BuildIntegratedNuGetProject, Task <LockFile> > getLockFileOrNullAsync)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (solutionManager == null)
{
throw new ArgumentNullException(nameof(solutionManager));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_settings = new Lazy <ISettings>(() => settings);
_solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager);
_logger = new Lazy <NuGet.Common.ILogger>(() => logger);
_getLockFileOrNullAsync = getLockFileOrNullAsync ?? BuildIntegratedProjectUtility.GetLockFileOrNull;
}
public SolutionManagerProvider(ISolutionDiretoryManager solutionDiretoryManager, NuGetProjectFactory nuGetProjectFactory, IProjectAdapterProvider projectAdapterProvider, INuGetSettingsAccessor nuGetSettingsAccessor, NuGet.Common.ILogger logger)
{
_solutionDiretoryManager = solutionDiretoryManager;
_nuGetProjectFactory = nuGetProjectFactory;
_projectAdapterProvider = projectAdapterProvider;
_nuGetSettingsAccessor = nuGetSettingsAccessor;
_logger = logger;
}
public static async IAsyncEnumerable <IPackageSearchMetadata> SearchPackagesByIdAsync(
this SourceRepository repository,
string packageId,
bool includePrerelease,
NuGet.Common.ILogger logger,
int batchSize = 50,
[EnumeratorCancellation] CancellationToken cancellationToken = default
)
{
var searchResource = await repository.GetResourceAsync <PackageSearchResource>();
await foreach (var metadata in searchResource
.SearchPackagesByIdAsync(packageId, includePrerelease, logger)
.WithCancellation(cancellationToken))
{
yield return(metadata);
}
}
private async Task ResolvePackage(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
NuGet.Common.ILogger logger,
IEnumerable <SourceRepository> repositories,
ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.ContainsKey(package))
{
return;
}
// TODO
// Avoid getting info for e.g. netstandard1.x if our framework is highet (e.g. netstandard2.0)
//if (framework.IsPackageBased &&
// package.Id.Equals("netstandard.library", StringComparison.OrdinalIgnoreCase) &&
// NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(framework,
// NuGetFramework.Parse($"netstandard{package.Version.Major}.{package.Version.Minor}")))
//{
// return;
//}
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
if (availablePackages.TryAdd(new PackageIdentity(dependencyInfo.Id, dependencyInfo.Version), dependencyInfo))
{
await Task.WhenAll(dependencyInfo.Dependencies.Select(dependency =>
{
return(ResolvePackage(new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages));
}));
}
}
}
public NuGetToNpmWorker(
IPackageNameMapper nameMapper,
IPackageFilter filter,
FindPackageByIdResource findPackageByIdResource,
PackageMetadataResource metadataResource,
IConfiguration configuration,
ILogger <NuGetToNpmWorker> logger,
NuGet.Common.ILogger nugetLogger,
SourceCacheContext cacheContext)
{
_nameMapper = nameMapper;
_filter = filter;
_findPackageByIdResource = findPackageByIdResource;
_metadataResource = metadataResource;
_configuration = configuration;
_logger = logger;
_nugetLogger = nugetLogger;
_cacheContext = cacheContext;
}
private async Task <bool> DownloadPackageAsync(
PackageDownloadRequest request,
IEnumerable <SourceRepository> repositories,
SourceCacheContext cacheContext,
SemaphoreSlim throttle,
NuGet.Common.ILogger logger,
CancellationToken cancellationToken)
{
foreach (var repo in repositories)
{
var findPackageByIdResource = await repo.GetResourceAsync <FindPackageByIdResource>(cancellationToken);
if (findPackageByIdResource == null)
{
logger.LogError($"{nameof(FindPackageByIdResource)} for '{repo}' could not be loaded.");
return(false);
}
using (var downloader = await findPackageByIdResource.GetPackageDownloaderAsync(request.Identity, cacheContext, logger, cancellationToken))
{
if (downloader == null)
{
logger.LogInformation($"Package {request.Identity.Id} {request.Identity.Version} is not available on '{repo}'");
// Skip to the next source if a package cannot be found in a given source.
continue;
}
downloader.SetThrottle(throttle);
if (!await downloader.CopyNupkgFileToAsync(request.OutputPath, cancellationToken))
{
logger.LogError($"Could not download {request.Identity.Id} {request.Identity.Version} from {repo}.");
return(false);
}
}
return(true);
}
logger.LogError($"{request.Identity.Id} {request.Identity.Version} is not available.'");
return(false);
}
public NuGetClientIntegrationTests(ITestOutputHelper output)
{
_app = new BaGetApplication(output);
_client = _app.CreateDefaultClient();
_packageStream = TestResources.GetResourceStream(TestResources.Package);
var sourceUri = new Uri(_app.Server.BaseAddress, "v3/index.json");
var packageSource = new PackageSource(sourceUri.AbsoluteUri);
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.Add(new Lazy <INuGetResourceProvider>(() => new HttpSourceResourceProviderTestHost(_client)));
providers.AddRange(Repository.Provider.GetCoreV3());
_repository = new SourceRepository(packageSource, providers);
_cache = new SourceCacheContext {
NoCache = true, MaxAge = new DateTimeOffset(), DirectDownload = true
};
_logger = NuGet.Common.NullLogger.Instance;
_cancellationToken = CancellationToken.None;
}
public void Commit(NuGet.Common.ILogger log)
{
if (!Success)
{
var name = $"{ProjectName}.nuget.targets";
var path = Path.Combine(ProjectDirectory, name);
log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", name));
GenerateMSBuildErrorFile(path);
}
else
{
// Generate the files as needed
var targetsName = $"{ProjectName}.nuget.targets";
var propsName = $"{ProjectName}.nuget.props";
var targetsPath = Path.Combine(ProjectDirectory, targetsName);
var propsPath = Path.Combine(ProjectDirectory, propsName);
if (Targets.Any())
{
log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", targetsName));
GenerateImportsFile(targetsPath, Targets);
}
else if (File.Exists(targetsPath))
{
File.Delete(targetsPath);
}
if (Props.Any())
{
log.LogMinimal(GettextCatalog.GetString("Generating MSBuild file {0}.", propsName));
GenerateImportsFile(propsPath, Props);
}
else if (File.Exists(propsPath))
{
File.Delete(propsPath);
}
}
}
public PackageLoader(UpgradeOptions options, ILogger <PackageLoader> logger)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.ProjectPath is null)
{
throw new ArgumentException("Project path must be set in UpgradeOptions", nameof(options));
}
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_nugetLogger = new NuGetLogger(logger);
_cache = new SourceCacheContext();
_packageSources = GetPackageSources(Path.GetDirectoryName(options.ProjectPath));
_sourceRepositoryCache = new Dictionary <PackageSource, SourceRepository>();
var settings = Settings.LoadDefaultSettings(null);
_cachePath = SettingsUtility.GetGlobalPackagesFolder(settings);
}
public static async IAsyncEnumerable <IPackageSearchMetadata> SearchPackagesByIdAsync(
this PackageSearchResource searchResource,
string packageId,
bool includePrerelease,
NuGet.Common.ILogger logger,
int batchSize = 50,
[EnumeratorCancellation] CancellationToken cancellationToken = default
)
{
var skip = 0;
while (true)
{
var metadataBatch = (await searchResource.SearchAsync(
$"packageId:{packageId}",
filters: new SearchFilter(includePrerelease: includePrerelease),
skip: skip,
take: batchSize,
logger,
cancellationToken
))
.ToList();
foreach (var metadata in metadataBatch)
{
yield return(metadata);
}
if (metadataBatch.Count == batchSize)
{
// There may be more...
skip += batchSize;
}
else
{
yield break;
}
}
}
public abstract System.Threading.Tasks.Task <NuGet.Protocol.Core.Types.DownloadResourceResult> GetDownloadResourceResultAsync(NuGet.Packaging.Core.PackageIdentity identity, NuGet.Configuration.ISettings settings, NuGet.Common.ILogger logger, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.SourcePackageDependencyInfo> > ResolvePackages(string packageId, NuGet.Frameworks.NuGetFramework projectFramework, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public virtual System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.RemoteSourceDependencyInfo> > ResolvePackages(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token)
{
throw null;
}
public abstract System.Threading.Tasks.Task <NuGet.Protocol.Core.Types.SourcePackageDependencyInfo> ResolvePackage(NuGet.Packaging.Core.PackageIdentity package, NuGet.Frameworks.NuGetFramework projectFramework, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > VersionStartsWith(string packageId, string versionPrefix, bool includePrerelease, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.IPackageSearchMetadata> > SearchAsync(string searchTerm, NuGet.Protocol.Core.Types.SearchFilter filters, int skip, int take, NuGet.Common.ILogger log, System.Threading.CancellationToken cancellationToken);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > GetVersions(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public override Task <bool> Exists(string packageId, bool includePrerelease, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token)
{
return(Task.FromResult(Packages
.Exists((p) =>
p.Id.Equals(packageId, StringComparison.InvariantCultureIgnoreCase) &&
(!p.Version.IsPrerelease || includePrerelease) &&
(p.Listed || includeUnlisted))
));
}
public System.Threading.Tasks.Task <bool> Exists(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token)
{
throw null;
}
public abstract System.Threading.Tasks.Task <bool> Exists(NuGet.Packaging.Core.PackageIdentity identity, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public System.Threading.Tasks.Task <bool> Exists(NuGet.Packaging.Core.PackageIdentity identity, NuGet.Common.ILogger log, System.Threading.CancellationToken token)
{
throw null;
}
/// <summary>
/// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json).
/// </summary>
/// <param name="projectPath">The full path to the project.</param>
/// <param name="id">The ID of the package.</param>
/// <param name="version">The version of the package.</param>
/// <param name="settings">The NuGet settings to use.</param>
/// <param name="logger">An <see cref="ILogger"/> to use for logging.</param>
/// <returns></returns>
public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(string projectPath, string id, string version, ISettings settings, ILogger logger)
{
using (SourceCacheContext sourceCacheContext = new SourceCacheContext
{
IgnoreFailedSources = true,
})
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i,
}).ToList())
{
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
SuppressParent = LibraryIncludeFlags.All,
AutoReferenced = true,
IncludeType = LibraryIncludeFlags.None,
Type = LibraryDependencyType.Build
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)),
Log = logger,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
return(RestoreRunner.RunWithoutCommit(requests, restoreArgs));
}
}
public abstract System.Threading.Tasks.Task <bool> Exists(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public abstract System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Protocol.Core.Types.IPackageSearchMetadata> > GetMetadataAsync(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token);
public override Task <bool> Exists(PackageIdentity identity, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token)
{
return(Task.FromResult(Packages
.Exists(p =>
((PackageIdentity)p).Equals(identity) &&
(p.Listed || includeUnlisted))
));
}
public System.Threading.Tasks.Task <NuGet.Versioning.NuGetVersion> GetLatestVersion(string packageId, bool includePrerelease, bool includeUnlisted, NuGet.Common.ILogger log, System.Threading.CancellationToken token)
{
throw null;
}
public async override Task <IEnumerable <KeyValuePair <string, NuGetVersion> > > GetLatestVersions(IEnumerable <string> packageIds, bool includePrerelease, bool includeUnlisted, SourceCacheContext sourceCacheContext, NuGet.Common.ILogger log, CancellationToken token)
{
var results = new List <KeyValuePair <string, NuGetVersion> >();
foreach (var id in packageIds)
{
var versions = await GetVersions(id, sourceCacheContext, log, token);
var latest = versions.OrderByDescending(p => p, VersionComparer.VersionRelease).FirstOrDefault();
if (latest != null)
{
results.Add(new KeyValuePair <string, NuGetVersion>(id, latest));
}
}
return(results);
}
public System.Threading.Tasks.Task <System.Collections.Generic.IEnumerable <NuGet.Versioning.NuGetVersion> > GetVersions(string packageId, NuGet.Common.ILogger log, System.Threading.CancellationToken token)
{
throw null;
}
