async Task <NuGetVersion> GetLatestPackageVersion(
IEnumerable <SourceRepository> repositories,
DependencyBehavior dependencyBehavior,
SourceCacheContext sourceCacheContext,
CancellationToken token)
{
var latestVersionContext = new ResolutionContext(
dependencyBehavior,
message.AllowPrerelease,
false,
VersionConstraints.None,
new GatherCache(),
sourceCacheContext
);
ResolvedPackage resolvedPackage = await packageManager.GetLatestVersionAsync(
message.PackageId,
nugetProject,
latestVersionContext,
repositories,
new ProjectContextLogger (projectContext),
token);
if (resolvedPackage?.LatestVersion == null)
{
throw new InvalidOperationException(GettextCatalog.GetString("Unable to find package '{0}", message.PackageId));
}
return(resolvedPackage?.LatestVersion);
}
async Task ExecuteAsync(CancellationToken cancellationToken)
{
if (Version == null)
{
ResolvedPackage resolvedPackage = await GetLatestPackageVersion(PackageId, cancellationToken);
Version = resolvedPackage?.LatestVersion;
}
var identity = new PackageIdentity(PackageId, Version);
var resolutionContext = CreateResolutionContext();
actions = await packageManager.PreviewInstallPackageAsync(
project,
identity,
resolutionContext,
context,
primarySources,
secondarySources,
cancellationToken);
if (LicensesMustBeAccepted)
{
await CheckLicenses(cancellationToken);
}
if (ShouldOpenReadmeFile(identity))
{
packageManager.SetDirectInstall(identity, context);
}
using (IDisposable fileMonitor = CreateFileMonitor()) {
using (var referenceMaintainer = CreateProjectReferenceMaintainer()) {
await packageManager.ExecuteNuGetProjectActionsAsync(
project,
actions,
context,
resolutionContext.SourceCacheContext,
cancellationToken);
if (referenceMaintainer != null)
{
await referenceMaintainer.ApplyChanges();
}
}
}
packageManager.ClearDirectInstall(context);
project.OnAfterExecuteActions(actions);
await project.RunPostProcessAsync(context, cancellationToken);
}
public Task <ResolvedPackage> GetLatestVersionAsync(
string packageId,
NuGetProject project,
ResolutionContext resolutionContext,
IEnumerable <SourceRepository> sources,
ILogger log,
CancellationToken token)
{
GetLatestVersionPackageId = packageId;
GetLatestVersionProject = project;
GetLatestVersionResolutionContext = resolutionContext;
GetLatestVersionSources = sources.ToList();
GetLatestVersionLogger = log;
GetLatestVersionCancellationToken = token;
var resolvedPackage = new ResolvedPackage(LatestVersion, true);
return(Task.FromResult(resolvedPackage));
}
public PackageMissingResult(ResolvedPackage result)
: base(result)
{
Type = CommandResultType.Error;
}
public PackageMissingResult(ResolvedPackage result)
: base(result)
{
}
public PackageResolveError(ResolvedPackage result)
{
Package = result;
}
static PackageOperationResult PackageMissing(ResolvedPackage resolvedPackage)
{
return new PackageMissingResult(resolvedPackage);
}
public PackageMissingResult(ResolvedPackage result)
: base(result)
{
}
static IPackageInfo GetExistingPackage(ISupportPublishing destinationRepository, ResolvedPackage foundPackage, Func<Version, bool> versionSelector)
{
return destinationRepository.PackagesByName.Contains(foundPackage.Identifier.Name)
? destinationRepository.PackagesByName[foundPackage.Identifier.Name]
.Where(x => foundPackage.Identifier.Version != null && versionSelector(x.Version))
.OrderByDescending(x => x.Version)
.FirstOrDefault()
: null;
}
public PackageConflictResult(ResolvedPackage result)
: base(result)
{
}
static PackageOperationResult PackageMissing(ResolvedPackage resolvedPackage)
{
return(new PackageMissingResult(resolvedPackage));
}
static PackageOperationResult PackageConflict(ResolvedPackage resolvedPackage)
{
return(new PackageConflictResult(resolvedPackage));
}
static IPackageInfo GetExistingPackage(IPackageRepository destinationRepository, ResolvedPackage foundPackage, Func <Version, bool> versionSelector)
{
return(destinationRepository.PackagesByName.Contains(foundPackage.Identifier.Name)
? destinationRepository.PackagesByName[foundPackage.Identifier.Name]
.Where(x => foundPackage.Identifier.Version != null && versionSelector(x.Version))
.OrderByDescending(x => x.Version)
.FirstOrDefault()
: null);
}
public PackageMissingResult(ResolvedPackage result)
: base(result)
{
Type = CommandResultType.Error;
}
private static void Run(ResolvedPackage resolvedPackage)
{
var runner = new Runner();
runner.Run(resolvedPackage);
}
static PackageOperationResult PackageConflict(ResolvedPackage resolvedPackage)
{
return new PackageConflictResult(resolvedPackage);
}
public PackageConflictResult(ResolvedPackage result)
: base(result)
{
}
public PackageResolveError(ResolvedPackage result)
{
Package = result;
}
