public static async Task <InstallPackageResult> InstallPackageAsync(
this Project project,
string packageId,
string packageVersion,
DependencyBehavior dependencyBehaviour,
bool allowPrerelease,
FileConflictAction?conflictAction,
IEnumerable <SourceRepository> sources,
CancellationToken token)
{
var message = new InstallPackageParams {
ProjectFileName = project.FileName,
PackageId = packageId,
PackageVersion = packageVersion,
FileConflictAction = conflictAction?.ToString(),
DependencyBehavior = dependencyBehaviour.ToString(),
AllowPrerelease = allowPrerelease,
PackageSources = GetPackageSourceInfo(sources).ToArray()
};
return(await JsonRpcProvider.Rpc.InvokeWithParameterObjectAsync <InstallPackageResult> (
Methods.ProjectInstallPackage,
new[] { message },
token));
}
private static DependencyVersion MapDependencyBehavior(DependencyBehavior behavior)
{
// Ignore is checked before calling this.
Debug.Assert(behavior != DependencyBehavior.Ignore);
switch (behavior)
{
case DependencyBehavior.Lowest:
return(DependencyVersion.Lowest);
case DependencyBehavior.HighestPatch:
return(DependencyVersion.HighestPatch);
case DependencyBehavior.HighestMinor:
return(DependencyVersion.HighestMinor);
case DependencyBehavior.Highest:
return(DependencyVersion.Highest);
default:
throw new ArgumentException(
String.Format(
CultureInfo.CurrentCulture,
Strings.ActionResolver_UnsupportedDependencyBehavior,
behavior),
"behavior");
}
}
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);
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// This does not check for already installed packages
/// </summary>
internal async Task InstallInternalCoreAsync(
NuGetPackageManager packageManager,
GatherCache gatherCache,
NuGetProject nuGetProject,
PackageIdentity package,
IEnumerable <SourceRepository> sources,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
await TaskScheduler.Default;
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
ResolutionContext resolution = new ResolutionContext(
depBehavior,
includePrerelease,
includeUnlisted: false,
versionConstraints: VersionConstraints.None,
gatherCache: gatherCache);
// install the package
if (package.Version == null)
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
else
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token);
}
}
public static async Task <UpdatePackageResult> UpdatePackageAsync(
this IEnumerable <Project> projects,
string packageId,
string packageVersion,
DependencyBehavior dependencyBehaviour,
bool allowPrerelease,
VersionConstraints versionConstraints,
FileConflictAction?conflictAction,
IEnumerable <SourceRepository> sources,
CancellationToken token)
{
var message = new UpdatePackageParams {
ProjectFileNames = projects.Select(project => project.FileName).ToArray(),
PackageId = packageId,
PackageVersion = packageVersion,
DependencyBehavior = dependencyBehaviour.ToString(),
FileConflictAction = conflictAction?.ToString(),
VersionConstraints = versionConstraints.ToString(),
AllowPrerelease = allowPrerelease,
PackageSources = GetPackageSourceInfo(sources).ToArray()
};
return(await JsonRpcProvider.Rpc.InvokeWithParameterObjectAsync <UpdatePackageResult> (
Methods.ProjectUpdatePackage,
message,
token));
}
public InstallCommand()
: base(MachineCache.Default)
{
// On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
// That are thrown.
DisableParallelProcessing = EnvironmentUtility.IsMonoRuntime;
DependencyBehavior = Client.DependencyBehavior.Lowest;
}
private static PackageResolverContext CreatePackageResolverContext(DependencyBehavior behavior,
PackageIdentity target,
IEnumerable <ResolverPackage> availablePackages)
{
var targets = new PackageIdentity[] { target };
return(CreatePackageResolverContext(behavior, targets, availablePackages));
}
public InstallCommand()
: base(MachineCache.Default)
{
// On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
// That are thrown.
DisableParallelProcessing = EnvironmentUtility.IsMonoRuntime;
DependencyBehavior = Client.DependencyBehavior.Lowest;
}
/// <summary>
/// The only public constructor to create the resolution context
/// </summary>
public ResolutionContext(
DependencyBehavior dependencyBehavior = Resolver.DependencyBehavior.Lowest,
bool includePrelease = false,
bool includeUnlisted = true)
{
DependencyBehavior = dependencyBehavior;
IncludePrerelease = includePrelease;
IncludeUnlisted = includeUnlisted;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScannerBase" /> class.
/// </summary>
/// <param name="scannerName">The name of this scanner.</param>
/// <param name="isRepeated">A value indicating whether this scan is repeated.</param>
/// <param name="dependencyBehavior">The object defining task dependencies.</param>
public ScannerBase(String scannerName, Boolean isRepeated, DependencyBehavior dependencyBehavior) : base(
taskName: scannerName,
isRepeated: isRepeated,
trackProgress: true,
dependencyBehavior: dependencyBehavior)
{
this.ScannerName = scannerName;
this.UpdateInterval = SettingsViewModel.GetInstance().RescanInterval;
}
/// <summary>
/// The only public constructor to create the resolution context
/// </summary>
public ResolutionContext(
DependencyBehavior dependencyBehavior = Resolver.DependencyBehavior.Lowest,
bool includePrelease = false,
bool includeUnlisted = true)
{
DependencyBehavior = dependencyBehavior;
IncludePrerelease = includePrelease;
IncludeUnlisted = includeUnlisted;
}
private void SetSelectedDepencyBehavior(DependencyBehavior dependencyBehavior)
{
var selectedDependencyBehavior = _detailModel.Options.DependencyBehaviors
.FirstOrDefault(d => d.Behavior == dependencyBehavior);
if (selectedDependencyBehavior != null)
{
_detailModel.Options.SelectedDependencyBehavior = selectedDependencyBehavior;
}
}
private static PackageResolverContext CreatePackageResolverContext(DependencyBehavior behavior,
IEnumerable <PackageIdentity> targets,
IEnumerable <ResolverPackage> availablePackages)
{
return(new PackageResolverContext(behavior,
targets.Select(p => p.Id), Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
targets,
availablePackages));
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync(
IReadOnlyCollection <string> projectIds,
PackageIdentity packageIdentity,
VersionConstraints versionConstraints,
bool includePrerelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
return(await GetInstallActionsAsync(projectIds, packageIdentity, versionConstraints, includePrerelease, dependencyBehavior, packageSourceNames, versionRange : null, cancellationToken));
}
/// <summary>
/// Resolver context
/// </summary>
/// <param name="dependencyBehavior">behavior for non-target packages</param>
/// <param name="targetIds">packages to install or update</param>
/// <param name="requiredPackageIds">packages required in the solution</param>
/// <param name="packagesConfig">existing packages</param>
/// <param name="preferredVersions">preferred package versions or the installed version of a package</param>
/// <param name="availablePackages">all packages from the gather stage</param>
public PackageResolverContext(DependencyBehavior dependencyBehavior,
IEnumerable <string> targetIds,
IEnumerable <string> requiredPackageIds,
IEnumerable <Packaging.PackageReference> packagesConfig,
IEnumerable <PackageIdentity> preferredVersions,
IEnumerable <SourcePackageDependencyInfo> availablePackages,
IEnumerable <PackageSource> packageSources,
Common.ILogger log)
{
if (targetIds == null)
{
throw new ArgumentNullException(nameof(targetIds));
}
if (requiredPackageIds == null)
{
throw new ArgumentNullException(nameof(requiredPackageIds));
}
if (packagesConfig == null)
{
throw new ArgumentNullException(nameof(packagesConfig));
}
if (preferredVersions == null)
{
throw new ArgumentNullException(nameof(preferredVersions));
}
if (availablePackages == null)
{
throw new ArgumentNullException(nameof(availablePackages));
}
if (packageSources == null)
{
throw new ArgumentNullException(nameof(packageSources));
}
DependencyBehavior = dependencyBehavior;
TargetIds = new HashSet <string>(targetIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds = new HashSet <string>(requiredPackageIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds.UnionWith(targetIds);
PackagesConfig = packagesConfig;
PreferredVersions = new HashSet <PackageIdentity>(preferredVersions, PackageIdentity.Comparer);
AvailablePackages = availablePackages;
PackageSources = packageSources;
Log = log;
Debug.Assert(PreferredVersions.GroupBy(p => p.Id, StringComparer.OrdinalIgnoreCase)
.All(group => group.Count() == 1), "duplicate preferred ids");
}
/// <summary>
/// Public constructor to create the resolution context
/// </summary>
public ResolutionContext(
DependencyBehavior dependencyBehavior,
bool includePrelease,
bool includeUnlisted,
VersionConstraints versionConstraints)
: this(dependencyBehavior,
includePrelease,
includeUnlisted,
versionConstraints,
new GatherCache())
{
}
/// <summary>
/// Install package by Id
/// </summary>
protected async Task InstallPackageByIdAsync(
Project project,
string packageId,
DependencyBehavior dependencyBehavior,
bool allowPrerelease,
bool isPreview)
{
//if (!ShouldContinueDueToDotnetDeprecation (actions, isPreview)) {
// return;
//}
if (isPreview)
{
var actionsList = await project.PreviewInstallPackageAsync(
packageId,
null,
dependencyBehavior,
allowPrerelease,
PrimarySourceRepositories,
Token);
if (actionsList.IsPackageAlreadyInstalled)
{
LogPackageAlreadyInstalled(packageId, project);
}
else
{
PreviewNuGetPackageActions(actionsList.Actions);
}
}
else
{
var result = await project.InstallPackageAsync(
packageId,
null,
dependencyBehavior,
allowPrerelease,
ConflictAction,
PrimarySourceRepositories,
Token);
if (result.IsPackageAlreadyInstalled)
{
LogPackageAlreadyInstalled(packageId, project);
}
}
}
/// <summary>
/// Resolver context
/// </summary>
/// <param name="dependencyBehavior">behavior for non-target packages</param>
/// <param name="targetIds">packages to install or update</param>
/// <param name="requiredPackageIds">packages required in the solution</param>
/// <param name="packagesConfig">existing packages</param>
/// <param name="preferredVersions">preferred package versions or the installed version of a package</param>
/// <param name="availablePackages">all packages from the gather stage</param>
public PackageResolverContext(DependencyBehavior dependencyBehavior,
IEnumerable<string> targetIds,
IEnumerable<string> requiredPackageIds,
IEnumerable<Packaging.PackageReference> packagesConfig,
IEnumerable<PackageIdentity> preferredVersions,
IEnumerable<SourcePackageDependencyInfo> availablePackages)
{
if (targetIds == null)
{
throw new ArgumentNullException(nameof(targetIds));
}
if (requiredPackageIds == null)
{
throw new ArgumentNullException(nameof(requiredPackageIds));
}
if (packagesConfig == null)
{
throw new ArgumentNullException(nameof(packagesConfig));
}
if (preferredVersions == null)
{
throw new ArgumentNullException(nameof(preferredVersions));
}
if (availablePackages == null)
{
throw new ArgumentNullException(nameof(availablePackages));
}
DependencyBehavior = dependencyBehavior;
TargetIds = new HashSet<string>(targetIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds = new HashSet<string>(requiredPackageIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds.UnionWith(targetIds);
PackagesConfig = packagesConfig;
PreferredVersions = new HashSet<PackageIdentity>(preferredVersions, PackageIdentity.Comparer);
AvailablePackages = availablePackages;
Debug.Assert(PreferredVersions.GroupBy(p => p.Id, StringComparer.OrdinalIgnoreCase)
.All(group => group.Count() == 1), "duplicate preferred ids");
}
/// <summary>
/// Public constructor to create the resolution context
/// </summary>
public ResolutionContext(
DependencyBehavior dependencyBehavior,
bool includePrelease,
bool includeUnlisted,
VersionConstraints versionConstraints,
GatherCache gatherCache)
{
if (gatherCache == null)
{
throw new ArgumentNullException(nameof(gatherCache));
}
DependencyBehavior = dependencyBehavior;
IncludePrerelease = includePrelease;
IncludeUnlisted = includeUnlisted;
VersionConstraints = versionConstraints;
GatherCache = gatherCache;
}
public static DependencyBehavior GetDependencyBehavior(DependencyBehavior defaultBehavior, string dependencyVersion, Configuration.ISettings settings)
{
// Check to see if dependencyVersion parameter is set. Else check for dependencyVersion in .config.
if (!string.IsNullOrEmpty(dependencyVersion))
{
return(TryGetDependencyBehavior(dependencyVersion));
}
// If the dependencyVersion wasn't provided , try to get the dependencyBehavior from the .config.
string settingsDependencyVersion =
SettingsUtility.GetConfigValue(settings, ConfigurationConstants.DependencyVersion);
if (!string.IsNullOrEmpty(settingsDependencyVersion))
{
return(TryGetDependencyBehavior(settingsDependencyVersion));
}
return(defaultBehavior);
}
/// <summary>
/// Install package by Identity
/// </summary>
protected async Task InstallPackageByIdentityAsync(
Project project,
PackageIdentity identity,
DependencyBehavior dependencyBehavior,
bool allowPrerelease,
bool isPreview)
{
if (isPreview)
{
var actionsList = await project.PreviewInstallPackageAsync(
identity.Id,
identity.Version.ToNormalizedString(),
dependencyBehavior,
allowPrerelease,
PrimarySourceRepositories,
Token);
if (actionsList.IsPackageAlreadyInstalled)
{
LogPackageAlreadyInstalled(identity, project);
}
else
{
PreviewNuGetPackageActions(actionsList.Actions);
}
}
else
{
var result = await project.InstallPackageAsync(
identity.Id,
identity.Version.ToNormalizedString(),
dependencyBehavior,
allowPrerelease,
ConflictAction,
PrimarySourceRepositories,
Token);
if (result.IsPackageAlreadyInstalled)
{
LogPackageAlreadyInstalled(identity, project);
}
}
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternal(Project project, List <PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool ignoreDependencies, CancellationToken token)
{
// store expanded node state
IDictionary <string, ISet <VsHierarchyItem> > expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager);
try
{
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
bool includePrerelease = false;
ResolutionContext resolution = new ResolutionContext(depBehavior, includePrerelease, false);
NuGetPackageManager packageManager = new NuGetPackageManager(repoProvider, _settings, _solutionManager);
// find the project
NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext);
// install the package
foreach (PackageIdentity package in packages)
{
if (package.Version == null)
{
if (!_packageServices.IsPackageInstalled(project, package.Id))
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty <SourceRepository>(), token);
}
}
else
{
if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString()))
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty <SourceRepository>(), token);
}
}
}
}
finally
{
// collapse nodes
VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes);
}
}
private static void GetPackageDependencies(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages,
DependencyBehavior dependencyBehavior,
IEnumerable <SourceRepository> primaryRepositories = null)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (var sourceRepository in primaryRepositories ?? repositories)
{
var dependencyInfoResource = sourceRepository.GetResourceAsync <DependencyInfoResource>().GetAwaiter().GetResult();
var dependencyInfo = dependencyInfoResource.ResolvePackage(package, framework, cacheContext, logger, CancellationToken.None).GetAwaiter().GetResult();
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
// No need to resolve dependencies if the dependency behavior is ignore.
if (dependencyBehavior == DependencyBehavior.Ignore)
{
return;
}
foreach (var dependency in dependencyInfo.Dependencies)
{
GetPackageDependencies(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages, dependencyBehavior);
}
// If we have already found package we can return here. No need to enumerate the other sources.
return;
}
}
public async Task <IEnumerable <PackageIdentity> > ResolveAsync(PackageIdentity package, NuGetFramework targetFramework, bool includePrelease = true, bool ignoreMissingPackages = true)
{
DependencyBehavior dependencyBehavior = DependencyBehavior.Lowest;
//gathered dependencies
var availabePackageStorage = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
//gathering resource from available sources
var getDependencyResourcesTasks = repositories.Select(repo => repo.GetResourceAsync <DependencyInfoResource>());
var dependencyResources = (await getDependencyResourcesTasks.WhenAllOrException()).Where(x => x.IsSuccess && x.Result != null)
.Select(x => x.Result).ToArray();
var dependencyInfoResources = new DependencyInfoResourceCollection(dependencyResources);
//recursively collect all dependencies
dependencyBehavior = await ResolveDependenciesRecursivelyAsync(package, targetFramework, dependencyInfoResources, NullSourceCacheContext.Instance,
availabePackageStorage, ignoreMissingPackages, default);
return(availabePackageStorage.ToList());
}
public static async Task UpdateAllPackagesAsync(
this IEnumerable <Project> projects,
DependencyBehavior dependencyBehaviour,
bool allowPrerelease,
VersionConstraints versionConstraints,
FileConflictAction?conflictAction,
IEnumerable <SourceRepository> sources,
CancellationToken token)
{
var message = new UpdatePackageParams {
ProjectFileNames = projects.Select(project => project.FileName).ToArray(),
DependencyBehavior = dependencyBehaviour.ToString(),
FileConflictAction = conflictAction?.ToString(),
VersionConstraints = versionConstraints.ToString(),
AllowPrerelease = allowPrerelease,
PackageSources = GetPackageSourceInfo(sources).ToArray()
};
await JsonRpcProvider.Rpc.InvokeWithCancellationAsync(
Methods.ProjectUpdateAllPackages,
new [] { message },
token);
}
/// <summary>
/// Parse user input for -Version switch
/// </summary>
private void ParseUserInputForVersion()
{
if (!string.IsNullOrEmpty(Version))
{
DependencyBehavior updateVersion;
IsVersionEnum = Enum.TryParse <DependencyBehavior>(Version, true, out updateVersion);
if (IsVersionEnum)
{
_updateVersionEnum = updateVersion;
}
// If Version is prerelease, automatically allow prerelease (i.e. append -Prerelease switch).
else
{
_nugetVersion = PowerShellCmdletsUtility.GetNuGetVersionFromString(Version);
if (_nugetVersion.IsPrerelease)
{
_versionSpecifiedPrerelease = true;
}
}
}
_allowPrerelease = IncludePrerelease.IsPresent || _versionSpecifiedPrerelease;
}
public ResolverComparer(DependencyBehavior dependencyBehavior,
HashSet <PackageIdentity> preferredVersions,
HashSet <string> targetIds)
{
_dependencyBehavior = dependencyBehavior;
_preferredVersions = preferredVersions;
_targetIds = targetIds;
_versionComparer = VersionComparer.Default;
_identityComparer = PackageIdentity.Comparer;
_installedVersions = new Dictionary <string, NuGetVersion>();
if (_installedVersions != null)
{
foreach (var package in _preferredVersions)
{
if (package.Version != null)
{
_installedVersions.Add(package.Id, package.Version);
}
}
}
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetInstallActionsAsync(
IReadOnlyCollection <string> projectIds,
PackageIdentity packageIdentity,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNull(packageIdentity);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.Null(_state.PackageIdentity);
Assumes.True(_state.ResolvedActions.Count == 0);
Assumes.NotNull(_state.SourceCacheContext);
cancellationToken.ThrowIfCancellationRequested();
return(await CatchAndRethrowExceptionAsync(async() =>
{
_state.PackageIdentity = packageIdentity;
IReadOnlyList <SourceRepository> sourceRepositories = GetSourceRepositories(
packageSourceNames,
cancellationToken);
Assumes.NotNullOrEmpty(sourceRepositories);
INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: false,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken);
IEnumerable <ResolvedAction> resolvedActions = await packageManager.PreviewProjectsInstallPackageAsync(
projects,
_state.PackageIdentity,
resolutionContext,
projectContext,
sourceRepositories,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (ResolvedAction resolvedAction in resolvedActions)
{
ProjectAction projectAction = CreateProjectAction(resolvedAction);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
private static PackageResolverContext CreatePackageResolverContext(DependencyBehavior behavior,
IEnumerable<PackageIdentity> targets,
IEnumerable<ResolverPackage> availablePackages)
{
return new PackageResolverContext(behavior,
targets.Select(p => p.Id), Enumerable.Empty<string>(),
Enumerable.Empty<PackageReference>(),
targets,
availablePackages);
}
/// <summary>
/// Internal install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternalAsync(
Project project,
List <PackageIdentity> packages,
ISourceRepositoryProvider repoProvider,
VSAPIProjectContext projectContext,
bool includePrerelease,
bool ignoreDependencies,
CancellationToken token)
{
// Go off the UI thread. This may be called from the UI thread. Only switch to the UI thread where necessary
// This method installs multiple packages and can likely take more than a few secs
// So, go off the UI thread explicitly to improve responsiveness
await TaskScheduler.Default;
var gatherCache = new GatherCache();
var sources = repoProvider.GetRepositories().ToList();
// store expanded node state
IDictionary <string, ISet <VsHierarchyItem> > expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync(_solutionManager);
try
{
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
ResolutionContext resolution = new ResolutionContext(
depBehavior,
includePrerelease,
includeUnlisted: false,
versionConstraints: VersionConstraints.None);
var packageManager = CreatePackageManager(repoProvider);
// find the project
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext);
// install the package
foreach (PackageIdentity package in packages)
{
// Check if the package is already installed
if (package.Version == null)
{
if (_packageServices.IsPackageInstalled(project, package.Id))
{
continue;
}
}
else
{
if (_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString()))
{
continue;
}
}
// Perform the install
await InstallInternalCoreAsync(
packageManager,
gatherCache,
nuGetProject,
package,
sources,
projectContext,
includePrerelease,
ignoreDependencies,
token);
}
}
finally
{
// collapse nodes
await VsHierarchyUtility.CollapseAllNodesAsync(_solutionManager, expandedNodes);
}
}
public ITargetDefinition WhenSkipped(DependencyBehavior dependencyBehavior)
{
DependencyBehavior = dependencyBehavior;
return(this);
}
/// <summary>
/// Get the update version for Dependent package, based on the specification of Highest, HighestMinor, HighestPatch and Lowest.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="identity"></param>
/// <param name="project"></param>
/// <param name="updateVersion"></param>
/// <param name="includePrerelease"></param>
/// <returns></returns>
public static PackageIdentity GetUpdateForPackageByDependencyEnum(SourceRepository sourceRepository, PackageIdentity identity, NuGetProject project, DependencyBehavior updateVersion, bool includePrerelease)
{
IEnumerable <NuGetVersion> allVersions = GetAllVersionsForPackageId(sourceRepository, identity.Id, project, includePrerelease);
PackageIdentity packageUpdate = null;
NuGetVersion nVersion = null;
try
{
// Find all versions that are higher than the package's current version
allVersions = allVersions.Where(p => p > identity.Version).OrderByDescending(v => v);
if (allVersions != null && allVersions.Any())
{
if (updateVersion == DependencyBehavior.Lowest)
{
nVersion = allVersions.LastOrDefault();
}
else if (updateVersion == DependencyBehavior.Highest)
{
nVersion = allVersions.FirstOrDefault();
}
else if (updateVersion == DependencyBehavior.HighestPatch)
{
var groups = from p in allVersions
group p by new { p.Version.Major, p.Version.Minor } into g
orderby g.Key.Major, g.Key.Minor
select g;
nVersion = (from p in groups.First()
orderby p.Version descending
select p).FirstOrDefault();
}
else if (updateVersion == DependencyBehavior.HighestMinor)
{
var groups = from p in allVersions
group p by new { p.Version.Major } into g
orderby g.Key.Major
select g;
nVersion = (from p in groups.First()
orderby p.Version descending
select p).FirstOrDefault();
}
}
if (nVersion != null)
{
packageUpdate = new PackageIdentity(identity.Id, nVersion);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Resources.Cmdlets_ErrorFindingUpdateVersion, identity.Id, ex.Message));
}
return(packageUpdate);
}
public DependencyBehaviorItem(string text, DependencyBehavior dependencyBehavior)
{
Text = text;
Behavior = dependencyBehavior;
}
/// <summary>
/// Parse user input for -Version switch
/// </summary>
private void ParseUserInputForVersion()
{
if (!string.IsNullOrEmpty(Version))
{
DependencyBehavior updateVersion;
IsVersionEnum = Enum.TryParse<DependencyBehavior>(Version, true, out updateVersion);
if (IsVersionEnum)
{
_updateVersionEnum = updateVersion;
}
// If Version is prerelease, automatically allow prerelease (i.e. append -Prerelease switch).
else
{
_nugetVersion = PowerShellCmdletsUtility.GetNuGetVersionFromString(Version);
if (_nugetVersion.IsPrerelease)
{
_versionSpecifiedPrerelease = true;
}
}
}
_allowPrerelease = IncludePrerelease.IsPresent || _versionSpecifiedPrerelease;
}
public async ValueTask <IReadOnlyList <ProjectAction> > GetUpdateActionsAsync(
IReadOnlyCollection <string> projectIds,
IReadOnlyCollection <PackageIdentity> packageIdentities,
VersionConstraints versionConstraints,
bool includePrelease,
DependencyBehavior dependencyBehavior,
IReadOnlyList <string> packageSourceNames,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(projectIds);
Assumes.NotNullOrEmpty(packageIdentities);
Assumes.NotNullOrEmpty(packageSourceNames);
Assumes.NotNull(_state.SourceCacheContext);
Assumes.NotNull(_state.ResolvedActions);
Assumes.Null(_state.PackageIdentity);
return(await CatchAndRethrowExceptionAsync(async() =>
{
var primarySources = new List <SourceRepository>();
var secondarySources = new List <SourceRepository>();
IEnumerable <SourceRepository> sourceRepositories = _sharedState.SourceRepositoryProvider.GetRepositories();
var packageSourceNamesSet = new HashSet <string>(packageSourceNames, StringComparer.OrdinalIgnoreCase);
foreach (SourceRepository sourceRepository in sourceRepositories)
{
if (packageSourceNamesSet.Contains(sourceRepository.PackageSource.Name))
{
primarySources.Add(sourceRepository);
}
if (sourceRepository.PackageSource.IsEnabled)
{
secondarySources.Add(sourceRepository);
}
}
INuGetProjectContext projectContext = await ServiceLocator.GetComponentModelServiceAsync <INuGetProjectContext>();
IReadOnlyList <NuGetProject> projects = await GetProjectsAsync(projectIds, cancellationToken);
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease,
includeUnlisted: true,
versionConstraints,
new GatherCache(),
_state.SourceCacheContext);
NuGetPackageManager packageManager = await _sharedState.GetPackageManagerAsync(cancellationToken);
IEnumerable <NuGetProjectAction> actions = await packageManager.PreviewUpdatePackagesAsync(
packageIdentities.ToList(),
projects,
resolutionContext,
projectContext,
primarySources,
secondarySources,
cancellationToken);
var projectActions = new List <ProjectAction>();
foreach (NuGetProjectAction action in actions)
{
var resolvedAction = new ResolvedAction(action.Project, action);
ProjectAction projectAction = CreateProjectAction(resolvedAction);
_state.ResolvedActions[projectAction.Id] = resolvedAction;
projectActions.Add(projectAction);
}
return projectActions;
}));
}
public InstallCommand()
: base()
{
DependencyBehavior = DependencyBehavior.Lowest;
}
private static DependencyVersion MapDependencyBehavior(DependencyBehavior behavior)
{
// Ignore is checked before calling this.
Debug.Assert(behavior != DependencyBehavior.Ignore);
switch (behavior)
{
case DependencyBehavior.Lowest:
return DependencyVersion.Lowest;
case DependencyBehavior.HighestPatch:
return DependencyVersion.HighestPatch;
case DependencyBehavior.HighestMinor:
return DependencyVersion.HighestMinor;
case DependencyBehavior.Highest:
return DependencyVersion.Highest;
default:
throw new ArgumentException(
String.Format(
CultureInfo.CurrentCulture,
Strings.ActionResolver_UnsupportedDependencyBehavior,
behavior),
"behavior");
}
}
/// <summary>
/// Get the update version for Dependent package, based on the specification of Highest, HighestMinor, HighestPatch and Lowest.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="identity"></param>
/// <param name="project"></param>
/// <param name="updateVersion"></param>
/// <param name="includePrerelease"></param>
/// <returns></returns>
public static PackageIdentity GetUpdateForPackageByDependencyEnum(SourceRepository sourceRepository, PackageIdentity identity, NuGetProject project, DependencyBehavior updateVersion, bool includePrerelease)
{
IEnumerable<NuGetVersion> allVersions = GetAllVersionsForPackageId(sourceRepository, identity.Id, project, includePrerelease);
PackageIdentity packageUpdate = null;
NuGetVersion nVersion = null;
try
{
// Find all versions that are higher than the package's current version
allVersions = allVersions.Where(p => p > identity.Version).OrderByDescending(v => v);
if (allVersions != null && allVersions.Any())
{
if (updateVersion == DependencyBehavior.Lowest)
{
nVersion = allVersions.LastOrDefault();
}
else if (updateVersion == DependencyBehavior.Highest)
{
nVersion = allVersions.FirstOrDefault();
}
else if (updateVersion == DependencyBehavior.HighestPatch)
{
var groups = from p in allVersions
group p by new { p.Version.Major, p.Version.Minor } into g
orderby g.Key.Major, g.Key.Minor
select g;
nVersion = (from p in groups.First()
orderby p.Version descending
select p).FirstOrDefault();
}
else if (updateVersion == DependencyBehavior.HighestMinor)
{
var groups = from p in allVersions
group p by new { p.Version.Major } into g
orderby g.Key.Major
select g;
nVersion = (from p in groups.First()
orderby p.Version descending
select p).FirstOrDefault();
}
}
if (nVersion != null)
{
packageUpdate = new PackageIdentity(identity.Id, nVersion);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Resources.Cmdlets_ErrorFindingUpdateVersion, identity.Id, ex.Message));
}
return packageUpdate;
}
private static PackageResolverContext CreatePackageResolverContext(DependencyBehavior behavior,
PackageIdentity target,
IEnumerable<ResolverPackage> availablePackages)
{
var targets = new PackageIdentity[] { target };
return CreatePackageResolverContext(behavior, targets, availablePackages);
}
public DependencyBehaviorItem(string text, DependencyBehavior dependencyBehavior)
{
Text = text;
Behavior = dependencyBehavior;
}
private void SetSelectedDepencyBehavior(DependencyBehavior dependencyBehavior)
{
var selectedDependencyBehavior = _detailModel.Options.DependencyBehaviors
.FirstOrDefault(d => d.Behavior == dependencyBehavior);
if (selectedDependencyBehavior != null)
{
_detailModel.Options.SelectedDependencyBehavior = selectedDependencyBehavior;
}
}
