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)); }