public InstallWalker(IPackageRepository localRepository,
IDependencyResolver2 dependencyResolver,
IPackageConstraintProvider constraintProvider,
FrameworkName targetFramework,
ILogger logger,
bool ignoreDependencies,
bool allowPrereleaseVersions,
DependencyVersion dependencyVersion)
: base(targetFramework)
{
if (dependencyResolver == null)
{
throw new ArgumentNullException("dependencyResolver");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Repository = localRepository;
Logger = logger;
DependencyResolver = dependencyResolver;
_ignoreDependencies = ignoreDependencies;
ConstraintProvider = constraintProvider;
_operations = new OperationLookup();
_allowPrereleaseVersions = allowPrereleaseVersions;
DependencyVersion = dependencyVersion;
CheckDowngrade = true;
}
public InstallWalker(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
FrameworkName targetFramework,
ILogger logger,
bool ignoreDependencies,
bool allowPrereleaseVersions)
: base(targetFramework)
{
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Repository = localRepository;
Logger = logger;
SourceRepository = sourceRepository;
_ignoreDependencies = ignoreDependencies;
ConstraintProvider = constraintProvider;
_operations = new OperationLookup();
_allowPrereleaseVersions = allowPrereleaseVersions;
}
public override IQueryable <IPackage> GetPackages(string searchTerm, bool allowPrereleaseVersions)
{
// We need to call ToList() here so that we don't evaluate the enumerable twice
// when trying to count it.
IList <FrameworkName> solutionFrameworks = Provider.SupportedFrameworks.Select(s => new FrameworkName(s)).ToList();
// The allow prerelease flag passed to this method indicates if we are allowed to show prerelease packages as part of the updates
// and does not reflect the filtering of packages we are looking for updates to.
var packages = _localRepository.GetPackages();
if (!String.IsNullOrEmpty(searchTerm))
{
packages = packages.Find(searchTerm);
}
// Tf the local repository contains constraints for each package, we send the version constraints to the GetUpdates() service.
IPackageConstraintProvider constraintProvider = _localRepository as IPackageConstraintProvider;
if (constraintProvider != null)
{
IList <IPackage> packagesList = packages.ToList();
IList <IVersionSpec> constraintList = packagesList.Select(p => constraintProvider.GetConstraint(p.Id)).ToList();
return(Repository.GetUpdates(packagesList, allowPrereleaseVersions, includeAllVersions: false, targetFrameworks: solutionFrameworks, versionConstraints: constraintList)
.AsQueryable());
}
return(Repository.GetUpdates(packages, allowPrereleaseVersions, includeAllVersions: false, targetFrameworks: solutionFrameworks)
.AsQueryable());
}
public InstallWalker(IPackageRepository localRepository,
IDependencyResolver2 dependencyResolver,
IPackageConstraintProvider constraintProvider,
FrameworkName targetFramework,
ILogger logger,
bool ignoreDependencies,
bool allowPrereleaseVersions,
DependencyVersion dependencyVersion)
: base(targetFramework)
{
if (dependencyResolver == null)
{
throw new ArgumentNullException("dependencyResolver");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Repository = localRepository;
Logger = logger;
DependencyResolver = dependencyResolver;
_ignoreDependencies = ignoreDependencies;
ConstraintProvider = constraintProvider;
_operations = new OperationLookup();
_allowPrereleaseVersions = allowPrereleaseVersions;
DependencyVersion = dependencyVersion;
CheckDowngrade = true;
}
public InstallWalker(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
FrameworkName targetFramework,
ILogger logger,
bool ignoreDependencies,
bool allowPrereleaseVersions)
: base(targetFramework)
{
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Repository = localRepository;
Logger = logger;
SourceRepository = sourceRepository;
_ignoreDependencies = ignoreDependencies;
ConstraintProvider = constraintProvider;
_operations = new OperationLookup();
_allowPrereleaseVersions = allowPrereleaseVersions;
}
public void ConstraintProvider_LocalRepositoryDoesNotImplementIConstraintProvider_ReturnsNullConstraintProviderInstance()
{
CreateProject();
IPackageConstraintProvider provider = project.ConstraintProvider;
Assert.AreEqual(NullConstraintProvider.Instance, provider);
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
try
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0}", package.Id);
}
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
if (Safe)
{
IVersionSpec safeRange = VersionUtility.GetSafeRange(package.Version);
projectManager.UpdatePackageReference(package.Id, safeRange, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
else
{
projectManager.UpdatePackageReference(package.Id, version: null, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
}
catch (InvalidOperationException e)
{
Log(Level.Warning, e.Message);
}
}
}
}
}
public UpdatedPackages(
IQueryable<IPackage> installedPackages,
IPackageRepository aggregrateRepository,
IPackageConstraintProvider constraintProvider)
{
this.installedPackages = installedPackages;
this.sourceRepository = aggregrateRepository;
this.constraintProvider = constraintProvider;
}
public UpdatedPackages(
IQueryable <IPackage> installedPackages,
IPackageRepository aggregrateRepository,
IPackageConstraintProvider constraintProvider)
{
this.installedPackages = installedPackages;
this.sourceRepository = aggregrateRepository;
this.constraintProvider = constraintProvider;
}
public static IPackage FindPackage(
this IPackageRepository repository,
string packageId,
SemanticVersion version,
IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions,
bool allowUnlisted)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (packageId == null)
{
throw new ArgumentNullException("packageId");
}
// if an explicit version is specified, disregard the 'allowUnlisted' argument
// and always allow unlisted packages.
if (version != null)
{
allowUnlisted = true;
}
// If the repository implements it's own lookup then use that instead.
// This is an optimization that we use so we don't have to enumerate packages for
// sources that don't need to.
var packageLookup = repository as IPackageLookup;
if (packageLookup != null && version != null)
{
return(packageLookup.FindPackage(packageId, version));
}
IEnumerable <IPackage> packages = repository.FindPackagesById(packageId);
packages = packages.ToList()
.OrderByDescending(p => p.Version);
if (!allowUnlisted)
{
packages = packages.Where(PackageExtensions.IsListed);
}
if (version != null)
{
packages = packages.Where(p => p.Version == version);
}
else if (constraintProvider != null)
{
packages = FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions);
}
return(packages.FirstOrDefault());
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
if (!this.ResolveDependenciesVertically)
{
return(DependencyResolveUtility.ResolveDependencyCore(this, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
Func <IPackageRepository, IPackage> resolveDependency = this.Wrap <IPackage>(r => DependencyResolveUtility.ResolveDependency(r, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion), null);
return((from r in this.Repositories select Task.Factory.StartNew <IPackage>(() => resolveDependency(r))).ToArray <Task <IPackage> >().WhenAny <IPackage>(package => (package != null)));
}
// this ctor is used for unit tests
internal UpdateWalker(IPackageRepository localRepository,
IDependencyResolver2 sourceRepository,
IDependentsResolver dependentsResolver,
IPackageConstraintProvider constraintProvider,
ILogger logger,
bool updateDependencies,
bool allowPrereleaseVersions)
: this(localRepository, sourceRepository, dependentsResolver, constraintProvider, null, logger, updateDependencies, allowPrereleaseVersions)
{
}
// this ctor is used for unit tests
internal UpdateWalker(IPackageRepository localRepository,
IDependencyResolver2 sourceRepository,
IDependentsResolver dependentsResolver,
IPackageConstraintProvider constraintProvider,
ILogger logger,
bool updateDependencies,
bool allowPrereleaseVersions)
: this(localRepository, sourceRepository, dependentsResolver, constraintProvider, null, logger, updateDependencies, allowPrereleaseVersions)
{
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
return(DependencyResolveUtility.ResolveDependencyCore(
new CoreInteropSourceRepository(_source),
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion));
}
public void ConstraintProvider_LocalRepositoryImplementsIConstraintProvider_ReturnsLocalRepository()
{
CreateProject();
var localRepository = new FakePackageRepositoryWithConstraintProvider();
fakeProjectManager.FakeLocalRepository = localRepository;
IPackageConstraintProvider provider = project.ConstraintProvider;
Assert.AreEqual(localRepository, provider);
}
public UpdateWalker(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IDependentsResolver dependentsResolver,
IPackageConstraintProvider constraintProvider,
ILogger logger,
bool updateDependencies,
bool allowPrereleaseVersions)
: base(localRepository, sourceRepository, constraintProvider, logger, !updateDependencies, allowPrereleaseVersions)
{
_dependentsResolver = dependentsResolver;
AcceptedTargets = PackageTargets.All;
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
if (ResolveDependenciesVertically)
{
Func <IPackageRepository, IPackage> resolveDependency = Wrap(r => r.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
return(Repositories.Select(r => Task.Factory.StartNew(() => resolveDependency(r)))
.ToArray()
.WhenAny(package => package != null));
}
return(this.ResolveDependencyCore(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec,
IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool allowUnlisted)
{
var packages = repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted);
if (constraintProvider != null)
{
packages = FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions);
}
return(packages.FirstOrDefault());
}
public UpdateWalker(IPackageRepository localRepository,
IDependencyResolver2 sourceRepository,
IDependentsResolver dependentsResolver,
IPackageConstraintProvider constraintProvider,
FrameworkName targetFramework,
ILogger logger,
bool updateDependencies,
bool allowPrereleaseVersions)
: base(localRepository, sourceRepository, constraintProvider, targetFramework, logger, !updateDependencies, allowPrereleaseVersions, DependencyVersion.Lowest)
{
_dependentsResolver = dependentsResolver;
AcceptedTargets = PackageTargets.All;
}
public UpdatedPackages (
IEnumerable<PackageReference> packageReferences,
IPackageRepository aggregrateRepository,
IPackageConstraintProvider constraintProvider)
{
installedPackages = packageReferences
.Select (packageReference => new PackageName (packageReference.Id, packageReference.Version))
.Select (packageReference => (IPackageName)packageReference)
.ToList ();
this.sourceRepository = aggregrateRepository;
this.constraintProvider = constraintProvider;
}
public UpdatedPackages(
IEnumerable <PackageReference> packageReferences,
IPackageRepository aggregrateRepository,
IPackageConstraintProvider constraintProvider)
{
installedPackages = packageReferences
.Select(packageReference => new PackageName(packageReference.Id, packageReference.Version))
.Select(packageReference => (IPackageName)packageReference)
.ToList();
this.sourceRepository = aggregrateRepository;
this.constraintProvider = constraintProvider;
}
public static IEnumerable <IPackage> FindCompatiblePackages(this IPackageRepository repository,
IPackageConstraintProvider constraintProvider,
IEnumerable <string> packageIds,
IPackage package,
FrameworkName targetFramework,
bool allowPrereleaseVersions)
{
return(from p in repository.FindPackages(packageIds)
where allowPrereleaseVersions || p.IsReleaseVersion()
let dependency = p.FindDependency(package.Id, targetFramework)
let otherConstaint = constraintProvider.GetConstraint(p.Id)
where dependency != null &&
dependency.VersionSpec.Satisfies(package.Version) &&
(otherConstaint == null || otherConstaint.Satisfies(package.Version))
select p);
}
/// <summary>
/// Will try and return a specific package from all provided local sources. Will ignore OData feeds, and will not result in network calls.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="constraintProvider"></param>
/// <param name="packageId"></param>
/// <param name="version"></param>
/// <param name="allowPrereleaseVersions"></param>
/// <returns></returns>
private static IPackage FindPackageInAggregateLocalSources(IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider, string packageId,
SemanticVersion version, bool allowPrereleaseVersions)
{
IPackage package = null;
var localAggregate = sourceRepository as AggregateRepository;
if (localAggregate != null)
{
package = localAggregate.GetLocalOnlyAggregateRepository().FindPackage(packageId, version,
constraintProvider,
allowPrereleaseVersions,
allowUnlisted: false);
}
return(package);
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = _repo as IDependencyResolver;
if (dependencyResolver != null)
{
return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
return DependencyResolveUtility.ResolveDependencyCore(
_repo,
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion);
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = _repo as IDependencyResolver;
if (dependencyResolver != null)
{
return(dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
return(DependencyResolveUtility.ResolveDependencyCore(
_repo,
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion));
}
internal static IEnumerable <IPackage> FilterPackagesByConstraints(IPackageConstraintProvider constraintProvider, IEnumerable <IPackage> packages, string packageId, bool allowPrereleaseVersions)
{
constraintProvider = constraintProvider ?? NullConstraintProvider.Instance;
IVersionSpec constraint = constraintProvider.GetConstraint(packageId);
if (constraint != null)
{
packages = packages.FindByVersion(constraint);
}
if (!allowPrereleaseVersions)
{
packages = from p in packages
where p.IsReleaseVersion()
select p;
}
return(packages);
}
public static IPackage ResolvePackage(IPackageRepository sourceRepository, IPackageRepository localRepository, IPackageConstraintProvider constraintProvider,
string packageId, SemanticVersion version, bool allowPrereleaseVersions)
{
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId");
}
IPackage package = null;
// If we're looking for an exact version of a package then try local first
if (version != null)
{
package = localRepository.FindPackage(packageId, version, allowPrereleaseVersions, allowUnlisted: true);
}
if (package == null)
{
// Try to find it in the source (regardless of version)
// We use resolve package here since we want to take any constraints into account
package = sourceRepository.FindPackage(packageId, version, constraintProvider, allowPrereleaseVersions, allowUnlisted: false);
// If we already have this package installed, use the local copy so we don't
// end up using the one from the source repository
if (package != null)
{
package = localRepository.FindPackage(package.Id, package.Version, allowPrereleaseVersions, allowUnlisted: true) ?? package;
}
}
// We still didn't find it so throw
if (package == null)
{
if (version != null)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackageSpecificVersion, packageId, version));
}
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackage, packageId));
}
return package;
}
private IPackage ResolvePackage(IPackageRepository localRepository, IPackageRepository sourceRepository, IPackageConstraintProvider constraintProvider,
string packageId, SemanticVersion version, bool allowPrereleaseVersions)
{
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException("Argument cannot be null or empty: {0}", "packageId");
}
IPackage package = null;
// If we're looking for an exact version of a package then try local first (where local is typically the target .\packages directory)
if (version != null)
{
package = localRepository.FindPackage(packageId, version, allowPrereleaseVersions, allowUnlisted: true);
}
//Check the object cache first, else fall back to on disk cache then remote call
if (package == null && !_cache.TryCacheHitByVersion(packageId, version, out package))
{
//Check the cache first by splitting the AggregateRepository into local/remote and querying seperately
package = package ?? FindPackageInAggregateLocalSources(sourceRepository, constraintProvider, packageId, version, allowPrereleaseVersions);
//If we are still null, check the remote for the package....
package = package ?? FindPackageInRemoteSources(sourceRepository, packageId, version);
}
//Not sure if this is still necessary, as we already know the version....
if (package != null)
{
package = localRepository.FindPackage(package.Id, package.Version, allowPrereleaseVersions, allowUnlisted: true) ?? package;
}
// We still didn't find it so throw
if (package == null)
{
if (version != null)
{
throw new InvalidOperationException( String.Format("Unknown Package Version: {0} {1}", packageId, version));
}
throw new InvalidOperationException(String.Format("Unknown Package Id: {0}", packageId));
}
return package;
}
private IEnumerable <PackageDependency> GetReferences(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Get the msbuild project
project = project ?? NugetUpdateTask.GetMSBuildProject(packagesConfigPath);
// Resolve the repository path
repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root);
var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath);
var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem);
// Create the local and source repositories
var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem);
var localRepository = new PackageReferenceRepository(project, sharedPackageRepository);
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
IPackageConstraintProvider constraintProvider = localRepository;
return(GetReferences(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project));
}
private void UpdatePackages(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Get the msbuild project
project = project ?? GetMSBuildProject(packagesConfigPath);
// Resolve the repository path
repositoryPath = repositoryPath ?? GetReposioryPath(project.Root);
var pathResolver = new DefaultPackagePathResolver(repositoryPath);
// Create the local and source repositories
var localRepository = new PackageReferenceRepository(project, new SharedPackageRepository(repositoryPath));
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
IPackageConstraintProvider constraintProvider = localRepository;
Console.WriteLine(NuGetResources.UpdatingProject, project.ProjectName);
UpdatePackages(localRepository, sourceRepository, constraintProvider, pathResolver, project);
project.Save();
}
internal void InstallPackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(packageManager, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
bool allowPrerelease = Prerelease;
var resolver = new ActionResolver()
{
AllowPrereleaseVersions = allowPrerelease
};
var installPackageUtility = new InstallPackageUtility(resolver)
{
AllowPrereleaseVersions = allowPrerelease,
Safe = Safe
};
var operations = installPackageUtility.ResolveActionsForInstallPackage(Id.FirstOrDefault(), Version, new[] { projectManager }, false);
var userOperationExecutor = new ActionExecutor();
userOperationExecutor.Execute(operations);
}
internal void UpdatePackages(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
if (Verbose)
{
projectManager.Logger = Console;
}
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
UpdatePackages(localRepository, projectManager);
}
}
internal IEnumerable <PackageDependency> GetReferences(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new NugetUpdateTask.VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0} version {1}", package.Id, package.Version);
yield return(new PackageDependency(package.Id, new VersionSpec(package.Version)));
}
}
}
}
}
public static IPackage ResolveDependencyCore(
IPackageRepository repository,
PackageDependency dependency,
IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions,
bool preferListedPackages,
DependencyVersion dependencyVersion)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
IEnumerable <IPackage> packages = repository.FindPackagesById(dependency.Id).ToList();
// Always filter by constraints when looking for dependencies
packages = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions);
IList <IPackage> candidates = packages.ToList();
if (preferListedPackages)
{
// pick among Listed packages first
IPackage listedSelectedPackage = ResolveDependencyCore(
candidates.Where(PackageExtensions.IsListed),
dependency,
dependencyVersion);
if (listedSelectedPackage != null)
{
return(listedSelectedPackage);
}
}
return(ResolveDependencyCore(candidates, dependency, dependencyVersion));
}
private static IEnumerable <IPackage> FilterPackagesByConstraints(
IPackageConstraintProvider constraintProvider,
IEnumerable <IPackage> packages,
string packageId,
bool allowPrereleaseVersions)
{
constraintProvider = constraintProvider ?? NullConstraintProvider.Instance;
// Filter packages by this constraint
IVersionSpec constraint = constraintProvider.GetConstraint(packageId);
if (constraint != null)
{
packages = packages.FindByVersion(constraint);
}
if (!allowPrereleaseVersions)
{
packages = packages.Where(p => p.IsReleaseVersion());
}
return(packages);
}
private void UpdatePackages(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Get the msbuild project
project = project ?? GetMSBuildProject(packagesConfigPath);
// Resolve the repository path
repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root);
var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath);
var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem);
// Create the local and source repositories
var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem);
var localRepository = new PackageReferenceRepository(project, sharedPackageRepository);
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
IPackageConstraintProvider constraintProvider = localRepository;
Log(Level.Info, "Updating project {0}", project.ProjectName);
UpdatePackages(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project);
project.Save();
}
private UDirectory GetPackageDirectory(string packageName, PackageVersionRange versionRange, IPackageConstraintProvider constraintProvider = null, bool allowPreleaseVersion = false, bool allowUnlisted = false)
{
if (packageName == null) throw new ArgumentNullException("packageName");
if (store != null)
{
var versionSpec = versionRange.ToVersionSpec();
var package = store.Manager.LocalRepository.FindPackage(packageName, versionSpec, constraintProvider ?? NullConstraintProvider.Instance, allowPreleaseVersion, allowUnlisted);
// If package was not found,
if (package != null)
{
var directory = store.PathResolver.GetPackageDirectory(package);
if (directory != null)
{
return directory;
}
}
}
// TODO: Check version for default package
if (packageName == DefaultPackageName)
{
if (versionRange == null || versionRange.Contains(DefaultPackageVersion))
{
return defaultPackageDirectory;
}
}
return null;
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
return DependencyResolveUtility.ResolveDependencyCore(
new CoreInteropSourceRepository(_source),
dependency,
constraintProvider,
allowPrereleaseVersions,
preferListedPackages,
dependencyVersion);
}
/// <summary>
/// Will try and return a specific package from all provided local sources. Will ignore OData feeds, and will not result in network calls.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="constraintProvider"></param>
/// <param name="packageId"></param>
/// <param name="version"></param>
/// <param name="allowPrereleaseVersions"></param>
/// <returns></returns>
private static IPackage FindPackageInAggregateLocalSources(IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider, string packageId,
SemanticVersion version, bool allowPrereleaseVersions)
{
IPackage package = null;
var localAggregate = sourceRepository as AggregateRepository;
if (localAggregate != null)
{
package = localAggregate.GetLocalOnlyAggregateRepository().FindPackage(packageId, version,
constraintProvider,
allowPrereleaseVersions,
allowUnlisted: false);
}
return package;
}
internal void UpdatePackages(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
if (Verbose)
{
projectManager.Logger = Console;
}
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
UpdatePackages(localRepository, projectManager);
}
}
internal void UpdatePackages(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
if (Verbose)
{
projectManager.Logger = Console;
}
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
if (Safe)
{
IVersionSpec safeRange = VersionUtility.GetSafeRange(package.Version);
projectManager.UpdatePackageReference(package.Id, safeRange, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
else
{
projectManager.UpdatePackageReference(package.Id, version: null, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
}
catch (InvalidOperationException e)
{
Console.WriteWarning(e.Message);
}
}
}
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(packageManager, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
using (sourceRepository.StartOperation(RepositoryOperationNames.Update, package.Id, mainPackageVersion: null))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
var resolver = new ActionResolver()
{
AllowPrereleaseVersions = allowPrerelease
};
var updateUtility = new UpdateUtility(resolver)
{
AllowPrereleaseVersions = allowPrerelease,
Safe = Safe
};
var operations = updateUtility.ResolveActionsForUpdate(package.Id, null, new[] { projectManager }, false);
var userOperationExecutor = new ActionExecutor();
userOperationExecutor.Execute(operations);
}
catch (InvalidOperationException e)
{
if (Console.Verbosity == NuGet.Verbosity.Detailed)
{
Console.WriteWarning(e.ToString());
}
else
{
Console.WriteWarning(e.Message);
}
}
}
}
}
}
public static IPackage ResolvePackage(IPackageRepository sourceRepository, IPackageRepository localRepository, IPackageConstraintProvider constraintProvider,
string packageId, SemanticVersion version, bool allowPrereleaseVersions)
{
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId");
}
IPackage package = null;
// If we're looking for an exact version of a package then try local first
if (version != null)
{
package = localRepository.FindPackage(packageId, version, allowPrereleaseVersions, allowUnlisted: true);
}
if (package == null)
{
// Try to find it in the source (regardless of version)
// We use resolve package here since we want to take any constraints into account
package = sourceRepository.FindPackage(packageId, version, constraintProvider, allowPrereleaseVersions, allowUnlisted: false);
// If we already have this package installed, use the local copy so we don't
// end up using the one from the source repository
if (package != null)
{
package = localRepository.FindPackage(package.Id, package.Version, allowPrereleaseVersions, allowUnlisted: true) ?? package;
}
}
// We still didn't find it so throw
if (package == null)
{
if (version != null)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackageSpecificVersion, packageId, version));
}
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackage, packageId));
}
return(package);
}
private static IEnumerable<IPackage> FindCompatiblePackages(
IDependencyResolver2 dependencyResolver,
IPackageConstraintProvider constraintProvider,
IEnumerable<string> packageIds,
IPackage package,
FrameworkName targetFramework,
bool allowPrereleaseVersions)
{
return (from p in dependencyResolver.FindPackages(packageIds)
where allowPrereleaseVersions || p.IsReleaseVersion()
let dependency = p.FindDependency(package.Id, targetFramework)
let otherConstaint = constraintProvider.GetConstraint(p.Id)
where dependency != null &&
dependency.VersionSpec.Satisfies(package.Version) &&
(otherConstaint == null || otherConstaint.Satisfies(package.Version))
select p);
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
if (Safe)
{
IVersionSpec safeRange = VersionUtility.GetSafeRange(package.Version);
projectManager.UpdatePackageReference(package.Id, safeRange, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
else
{
projectManager.UpdatePackageReference(package.Id, version: null, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
}
catch (InvalidOperationException e)
{
Console.WriteWarning(e.Message);
}
}
}
}
}
internal IEnumerable<PackageDependency> GetReferences(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new NugetUpdateTask.VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0} version {1}", package.Id, package.Version);
yield return new PackageDependency(package.Id, new VersionSpec(package.Version));
}
}
}
}
}
private bool TryUpdate(IEnumerable <IPackage> dependents, ConflictResult conflictResult, IPackage package, out IEnumerable <IPackage> incompatiblePackages)
{
// Key dependents by id so we can look up the old package later
var dependentsLookup = dependents.ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase);
var compatiblePackages = new Dictionary <IPackage, IPackage>();
// Initialize each compatible package to null
foreach (var dependent in dependents)
{
compatiblePackages[dependent] = null;
}
// Get compatible packages in one batch so we don't have to make requests for each one
var packages = from p in SourceRepository.FindCompatiblePackages(ConstraintProvider, dependentsLookup.Keys, package, TargetFramework, AllowPrereleaseVersions)
group p by p.Id into g
let oldPackage = dependentsLookup[g.Key]
select new
{
OldPackage = oldPackage,
NewPackage = g.Where(p => p.Version > oldPackage.Version)
.OrderBy(p => p.Version)
.ResolveSafeVersion()
};
foreach (var p in packages)
{
compatiblePackages[p.OldPackage] = p.NewPackage;
}
// Get all packages that have an incompatibility with the specified package i.e.
// We couldn't find a version in the repository that works with the specified package.
incompatiblePackages = compatiblePackages.Where(p => p.Value == null)
.Select(p => p.Key);
if (incompatiblePackages.Any())
{
return(false);
}
IPackageConstraintProvider currentConstraintProvider = ConstraintProvider;
try
{
// Add a constraint for the incoming package so we don't try to update it by mistake.
// Scenario:
// A 1.0 -> B [1.0]
// B 1.0.1, B 1.5, B 2.0
// A 2.0 -> B (any version)
// We have A 1.0 and B 1.0 installed. When trying to update to B 1.0.1, we'll end up trying
// to find a version of A that works with B 1.0.1. The version in the above case is A 2.0.
// When we go to install A 2.0 we need to make sure that when we resolve it's dependencies that we stay within bounds
// i.e. when we resolve B for A 2.0 we want to keep the B 1.0.1 we've already chosen instead of trying to grab
// B 1.5 or B 2.0. In order to achieve this, we add a constraint for version of B 1.0.1 so we stay within those bounds for B.
// Respect all existing constraints plus an additional one that we specify based on the incoming package
var constraintProvider = new DefaultConstraintProvider();
constraintProvider.AddConstraint(package.Id, new VersionSpec(package.Version));
ConstraintProvider = new AggregateConstraintProvider(ConstraintProvider, constraintProvider);
// Mark the incoming package as visited so that we don't try walking the graph again
Marker.MarkVisited(package);
var failedPackages = new List <IPackage>();
// Update each of the existing packages to more compatible one
foreach (var pair in compatiblePackages)
{
try
{
// Remove the old package
Uninstall(pair.Key, conflictResult.DependentsResolver, conflictResult.Repository);
// Install the new package
Walk(pair.Value);
}
catch
{
// If we failed to update this package (most likely because of a conflict further up the dependency chain)
// we keep track of it so we can report an error about the top level package.
failedPackages.Add(pair.Key);
}
}
incompatiblePackages = failedPackages;
return(!incompatiblePackages.Any());
}
finally
{
// Restore the current constraint provider
ConstraintProvider = currentConstraintProvider;
// Mark the package as processing again
Marker.MarkProcessing(package);
}
}
/// <summary>
/// Gets the filename to the specific package.
/// </summary>
/// <param name="packageName">Name of the package.</param>
/// <param name="versionRange">The version range.</param>
/// <param name="constraintProvider">The package constraint provider.</param>
/// <param name="allowPreleaseVersion">if set to <c>true</c> [allow prelease version].</param>
/// <param name="allowUnlisted">if set to <c>true</c> [allow unlisted].</param>
/// <returns>A location on the disk to the specified package or null if not found.</returns>
/// <exception cref="System.ArgumentNullException">packageName</exception>
public UFile GetPackageFileName(string packageName, PackageVersionRange versionRange = null, IPackageConstraintProvider constraintProvider = null, bool allowPreleaseVersion = true, bool allowUnlisted = false)
{
if (packageName == null) throw new ArgumentNullException("packageName");
var directory = GetPackageDirectory(packageName, versionRange, constraintProvider, allowPreleaseVersion, allowUnlisted);
return directory != null ? UPath.Combine(UPath.Combine(UPath.Combine(InstallationPath, (UDirectory)store.RepositoryPath), directory), new UFile(packageName + Package.PackageFileExtension)) : null;
}
internal static IEnumerable<IPackage> FilterPackagesByConstraints(
IPackageConstraintProvider constraintProvider,
IEnumerable<IPackage> packages,
string packageId,
bool allowPrereleaseVersions)
{
constraintProvider = constraintProvider ?? NullConstraintProvider.Instance;
// Filter packages by this constraint
IVersionSpec constraint = constraintProvider.GetConstraint(packageId);
if (constraint != null)
{
packages = packages.FindByVersion(constraint);
}
if (!allowPrereleaseVersions)
{
packages = packages.Where(p => p.IsReleaseVersion());
}
return packages;
}
public static IPackage ResolveDependencyCore(
IPackageRepository repository,
PackageDependency dependency,
IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions,
bool preferListedPackages,
DependencyVersion dependencyVersion)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (dependency == null)
{
throw new ArgumentNullException("dependency");
}
IEnumerable<IPackage> packages = repository.FindPackagesById(dependency.Id).ToList();
// Always filter by constraints when looking for dependencies
packages = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions);
IList<IPackage> candidates = packages.ToList();
if (preferListedPackages)
{
// pick among Listed packages first
IPackage listedSelectedPackage = ResolveDependencyCore(
candidates.Where(PackageExtensions.IsListed),
dependency,
dependencyVersion);
if (listedSelectedPackage != null)
{
return listedSelectedPackage;
}
}
return ResolveDependencyCore(candidates, dependency, dependencyVersion);
}
private IPackage FindPackage(IPackageRepository repository, string packageId, SemanticVersion version, IPackageConstraintProvider constraintProvider,
bool allowPrereleaseVersions, bool allowUnlisted)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (packageId == null)
{
throw new ArgumentNullException("packageId");
}
// if an explicit version is specified, disregard the 'allowUnlisted' argument
// and always allow unlisted packages.
if (version != null)
{
allowUnlisted = true;
}
IEnumerable<IPackage> packages = repository.FindPackagesById(packageId);
_cache.AddCacheEntryByList(packageId, packages);
if (!allowUnlisted)
{
packages = packages.Where(PackageExtensions.IsListed);
}
if (version != null)
{
packages = packages.Where(p => p.Version == version);
}
else if (constraintProvider != null)
{
packages = FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions);
}
return packages.FirstOrDefault();
}
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
// Use the primary repository to look up dependencies. Fallback to the aggregate repository only if we can't find a package here.
return _primaryRepository.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) ??
_dependencyResolver.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = repository as IDependencyResolver;
if (dependencyResolver != null)
{
return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
return ResolveDependencyCore((IPackageRepository)repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion);
}
public static IPackage ResolveDependency(object repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
{
IDependencyResolver dependencyResolver = repository as IDependencyResolver;
if (dependencyResolver != null)
{
return(dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
return(ResolveDependencyCore((IPackageRepository)repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion));
}
