public IPackageRemoveResult RemoveProjectPackage(PackageRequest packageToRemove, IPackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options = PackageRemoveOptions.Default) { if (packageToRemove == null) { throw new ArgumentNullException("packageToRemove"); } if (projectDescriptor == null) { throw new ArgumentNullException("projectDescriptor"); } if (projectRepository == null) { throw new ArgumentNullException("projectRepository"); } var resultIterator = RemoveProjectPackageCore(packageToRemove, projectDescriptor, projectRepository, options); if ((options & PackageRemoveOptions.Hooks) == PackageRemoveOptions.Hooks && _hooks != null) { resultIterator = WrapWithHooks(resultIterator, projectDescriptor, projectRepository, "project"); } return(new PackageRemoveResultIterator(resultIterator)); }
public IPackageUpdateResult UpdateProjectPackages(IEnumerable <IPackageRepository> sourceRepositories, IPackageRepository projectRepository, IPackageDescriptor projectDescriptor, string packageName, PackageUpdateOptions options = PackageUpdateOptions.Default) { if (sourceRepositories == null) { throw new ArgumentNullException("sourceRepositories"); } if (projectRepository == null) { throw new ArgumentNullException("projectRepository"); } if (projectDescriptor == null) { throw new ArgumentNullException("projectDescriptor"); } if (sourceRepositories.Any(x => x == null)) { throw new ArgumentException("Some repositories are null.", "sourceRepositories"); } var resultIterator = UpdateProjectPackageCore(sourceRepositories, projectRepository, projectDescriptor, x => x.EqualsNoCase(packageName)); if ((options & PackageUpdateOptions.Hooks) == PackageUpdateOptions.Hooks) { resultIterator = WrapWithHooks(resultIterator, projectDescriptor, projectRepository, "project"); } return(new PackageUpdateResultIterator(resultIterator)); }
public IEnumerable <IPackageInfo> ListProjectPackages(IPackageDescriptor descriptor, IPackageRepository projectRepository) { Check.NotNull(projectRepository, "projectRepository"); Check.NotNull(descriptor, "descriptor"); return(_resolver.TryResolveDependencies(descriptor, new[] { projectRepository }).SuccessfulPackages.Select(_ => _.Packages.First())); }
void RewriteDescriptorFile(IPackageDescriptor descriptor) { using (var destinationStream = HostEnvironment.DescriptorFile.OpenWrite()) { new PackageDescriptorWriter().Write(descriptor, destinationStream); } }
protected virtual PackageBuilder Convert(IPackageDescriptor descriptor) { Assert.ArgumentNotNull(descriptor, "descriptor"); // var metadata = new ManifestMetadata() { Id = descriptor.Id, Title = descriptor.Title, Tags = descriptor.Tags, Authors = descriptor.Authors, Owners = descriptor.Owners, Description = descriptor.Description, RequireLicenseAcceptance = false, IconUrl = "http://www.sitecore.net/favicon.ico", Version = descriptor.Version }; // var builder = new PackageBuilder(); builder.Populate(metadata); try { AddAssemblies(builder, descriptor, this.AssemblyPath); AddDependencies(builder, descriptor); } catch (FileNotFoundException ex) { Log.Error(string.Format("Unable to convert the IPackageDescriptor {0} to a PackageBuilder because the file {1} cannot be found.", descriptor.Id, ex.FileName), ex, this); return(null); } return(builder); }
public UncompressedPackage(IPackageRepository source, IFile originalPackageFile, IDirectory wrapCacheDirectory) { Check.NotNull(source, "source"); if (originalPackageFile == null || originalPackageFile.Exists == false) { IsValid = false; return; } _originalPackageFile = originalPackageFile; BaseDirectory = wrapCacheDirectory; // get the descriptor file inside the package Source = source; var wrapDescriptor = wrapCacheDirectory.Files("*.wrapdesc").SingleOrDefault(); if (wrapDescriptor == null) { IsValid = false; return; } var versionFile = wrapCacheDirectory.GetFile("version"); _descriptor = new PackageDescriptorReaderWriter().Read(wrapDescriptor); PackageInfo = new DefaultPackageInfo(originalPackageFile.Name, versionFile.Exists ? versionFile.Read(x => x.ReadString().ToVersion()) : null, _descriptor); Identifier = new PackageIdentifier(Name, Version); IsValid = true; }
protected virtual void AddAssemblies(PackageBuilder builder, IPackageDescriptor descriptor, string assemblyPath) { if (descriptor.Assemblies.Count == 0) { return; } var assemblies = new List <ManifestFile>(); var tempPath = System.Web.Hosting.HostingEnvironment.MapPath(this.AssemblyPath); if (tempPath != null) { assemblyPath = tempPath; } foreach (var path in descriptor.Assemblies) { if (string.IsNullOrWhiteSpace(path)) { continue; } var sourcePath = Path.Combine(assemblyPath, path); if (!File.Exists(sourcePath)) { throw new FileNotFoundException("Cannot add assembly because file cannot be found", sourcePath); } var assembly = new ManifestFile() { Source = sourcePath, Target = "lib" }; assemblies.Add(assembly); } builder.PopulateFiles(assemblyPath, assemblies); }
public UncompressedPackage(IPackageRepository source, IFile originalPackageFile, IDirectory wrapCacheDirectory) { Check.NotNull(source, "source"); if (originalPackageFile == null || originalPackageFile.Exists == false) { IsValid = false; return; } _originalPackageFile = originalPackageFile; BaseDirectory = wrapCacheDirectory; // get the descriptor file inside the package Source = source; var wrapDescriptor = wrapCacheDirectory.Files("*.wrapdesc").SingleOrDefault(); if (wrapDescriptor == null) { IsValid = false; return; } var versionFile = wrapCacheDirectory.GetFile("version"); _descriptor = new PackageDescriptorReader().Read(wrapDescriptor); _semver = _descriptor.SemanticVersion ?? _descriptor.Version.ToSemVer(); if (_semver == null) _semver = versionFile.Exists ? versionFile.ReadString().ToSemVer() : null; IsValid = string.IsNullOrEmpty(Name) == false && _semver != null; if (IsValid) Identifier = new PackageIdentifier(Name, _semver); }
public void Parse(string line, IPackageDescriptor descriptor) { var match = _regex.Match(line); if (!match.Success) return; ParseContent(match.Groups["content"].Value, descriptor); }
DependencyResolutionResult BuildResult(IPackageDescriptor packageDescriptor, LoggingPackageVisitor visitor, List <IPackageInfo> allPackages) { return(new DependencyResolutionResult(packageDescriptor, FromPacks(allPackages, visitor.Success).ToList(), FromPacks(allPackages, visitor.Fail).ToList(), FromNotFound(visitor.NotFound).ToList())); }
IEnumerable <PackageOperationResult> UpdateProjectPackageCore(IEnumerable <IPackageRepository> sourceRepositories, IPackageRepository projectRepository, IPackageDescriptor projectDescriptor, Func <string, bool> nameSelector) { return(CopyPackageCore(sourceRepositories, new[] { projectRepository }, projectDescriptor, nameSelector)); }
public DependencyResolutionResult TryResolveDependencies(IPackageDescriptor packageDescriptor, IEnumerable<IPackageRepository> repositoriesToQuery) { var packageSelection = new PackageSelectionContext(); Debug.WriteLine("Resolving descriptor " + packageDescriptor.Dependencies.Select(x => x.ToString()).Join(", ")); for (int i = 0; i < MAX_RETRIES; i++) { var exclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); var visitor = new DependencyVisitor(repositoriesToQuery, packageSelection, packageDescriptor.Dependencies, packageDescriptor.Overrides); var resolutionSucceeded = visitor.VisitDependencies(packageDescriptor.Dependencies); if (resolutionSucceeded == false) { var newExclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); if (newExclusionList.Except(exclusionList).Any()) { packageSelection = new PackageSelectionContext(packageSelection.IncompatiblePackageVersions); continue; } } return Result(packageDescriptor, packageSelection, repositoriesToQuery, visitor.NotFound); } throw new InvalidOperationException(string.Format("OpenWrap tried {0} times to resolve the tree of dependencies and gave up.", MAX_RETRIES)); }
public DependencyResolutionResult TryResolveDependencies(IPackageDescriptor packageDescriptor, IEnumerable <IPackageRepository> repositoriesToQuery) { var packageSelection = new PackageSelectionContext(); Debug.WriteLine("Resolving descriptor " + packageDescriptor.Dependencies.Select(x => x.ToString()).JoinString(", ")); for (int i = 0; i < MAX_RETRIES; i++) { var exclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); var visitor = new DependencyVisitor(repositoriesToQuery.Packages(), packageSelection, packageDescriptor.Dependencies, packageDescriptor.Overrides); var resolutionSucceeded = visitor.VisitDependencies(packageDescriptor.Dependencies); if (resolutionSucceeded == false) { var newExclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); if (newExclusionList.Except(exclusionList).Any()) { packageSelection = new PackageSelectionContext(packageSelection.IncompatiblePackageVersions); continue; } } return(Result(packageDescriptor, packageSelection, repositoriesToQuery, visitor.NotFound)); } throw new InvalidOperationException(string.Format("OpenWrap tried {0} times to resolve the tree of dependencies and gave up.", MAX_RETRIES)); }
IEnumerable <PackageOperationResult> AddProjectPackageCore(PackageRequest packageToAdd, IEnumerable <IPackageRepository> sourceRepositories, IPackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageAddOptions options) { var finalDescriptor = (options & PackageAddOptions.UpdateDescriptor) == PackageAddOptions.UpdateDescriptor ? projectDescriptor : new PackageDescriptor(projectDescriptor); var existingEntries = finalDescriptor.Dependencies.Where(x => x.Name.EqualsNoCase(packageToAdd.Name)).ToList(); if (existingEntries.Count > 0) { finalDescriptor.Dependencies.RemoveRange(existingEntries); yield return(new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Updated)); } else { yield return(new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Added)); } finalDescriptor.Dependencies.Add(ToDependency(packageToAdd, options)); foreach (var m in CopyPackageCore(sourceRepositories, new[] { projectRepository }, finalDescriptor, x => true)) { yield return(m); } }
public DependencyResolutionResult TryResolveDependencies(IPackageDescriptor packageDescriptor, IEnumerable<IPackageRepository> repositoriesToQuery) { Debug.WriteLine("Resolving descriptor " + packageDescriptor.Dependencies.Select(x => x.ToString()).JoinString(", ")); var excluded = new List<IPackageInfo>(); var allPackages = repositoriesToQuery.Packages().SelectMany(_ => _).ToList(); var notFound = new List<PackageDependency>(); for (int i = 0; i < MAX_RETRIES; i++) { var visitor = new LoggingPackageVisitor( allPackages, packages => Nuke(PackageStrategy.Latest(packages)), fail: excluded); visitor.ReadDependency = LocalHints(packageDescriptor.Dependencies, Override(packageDescriptor.Overrides, visitor.ReadDependency)); if (visitor.Visit(packageDescriptor.Dependencies)) { return BuildResult(packageDescriptor, visitor, allPackages); } var hasNewIncompatibles = visitor.IncompatiblePackages.Except(excluded).Any(); var currentNotFound = ReadNotFoundDependencies(visitor); var hasNewNotFound = currentNotFound.Except(notFound).Any(); if (!hasNewNotFound && !hasNewIncompatibles) return BuildResult(packageDescriptor, visitor, allPackages); excluded.AddRange(visitor.IncompatiblePackages); notFound = currentNotFound.ToList(); } throw new InvalidOperationException(string.Format("OpenWrap tried {0} times to resolve the tree of dependencies and gave up.", MAX_RETRIES)); }
protected void given_descriptor(params string[] line) { var descriptorText = line.JoinString("\r\n"); descriptor = new PackageDescriptorReader().Read(descriptorText.ToUTF8Stream()); root.GetFile("test.wrapdesc").WriteString(descriptorText); }
DependencyResolutionResult BuildResult(IPackageDescriptor packageDescriptor, LoggingPackageVisitor visitor, List<IPackageInfo> allPackages) { return new DependencyResolutionResult(packageDescriptor, FromPacks(allPackages, visitor.Success).ToList(), FromPacks(allPackages, visitor.Fail).ToList(), FromNotFound(visitor.NotFound).ToList()); }
/// <summary> /// Creates a package. /// </summary> public static Package Create(PackageId id, AbsolutePath path, IPackageDescriptor descriptor, IEnumerable <AbsolutePath> parsedProjects = null, ModuleId moduleId = default) { Contract.Requires(id.IsValid); Contract.Requires(path.IsValid); Contract.Requires(descriptor != null); return(new Package(id, path, descriptor, parsedProjects, moduleId.IsValid ? moduleId : ModuleId.Create(id.Name))); }
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageResolver resolver, bool includeContentOnly, ExecutionEnvironment exec, IPackageDescriptor descriptor, params IPackageRepository[] repositories) { return GetAssemblyReferences(resolver.TryResolveDependencies(descriptor, repositories.NotNull()), exec, includeContentOnly); }
public DefaultPackageInfo(Version versionFileContent, IPackageDescriptor descriptor) { _descriptor = descriptor; _packageVersion = versionFileContent ?? descriptor.Version; //_packageName = PackageNameUtility.GetName(packageFileName); Identifier = new PackageIdentifier(Name, Version); }
protected static string WriteDescriptor(IPackageDescriptor descriptor) { var memString = new MemoryStream(); new PackageDescriptorWriter().Write(descriptor.GetPersistableEntries(), memString); memString.Position = 0; return(memString.ReadString()); }
/// <summary> /// Creates a package. /// </summary> public static Package Create(PackageId id, AbsolutePath path, IPackageDescriptor descriptor, IEnumerable <AbsolutePath> parsedProjects = null) { Contract.Requires(id.IsValid); Contract.Requires(path.IsValid); Contract.Requires(descriptor != null); return(new Package(id, path, descriptor, parsedProjects)); }
protected static string WriteDescriptor(IPackageDescriptor descriptor) { var memString = new MemoryStream(); new PackageDescriptorReaderWriter().Write(descriptor, memString); memString.Position = 0; return(memString.ReadString()); }
protected override void ParseContent(string content, IPackageDescriptor descriptor) { var dependency = ParseDependsValue(content); if (dependency != null) { descriptor.Dependencies.Add(dependency); } }
public IPackageAddResult AddProjectPackage(PackageRequest packageToAdd, IEnumerable<IPackageRepository> sourceRepositories, IPackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageAddOptions options = PackageAddOptions.Default) { Check.NotNull(packageToAdd, "packageToAdd"); Check.NoNullElements(sourceRepositories, "sourceRepositories"); Check.NotNull(projectDescriptor, "projectDescriptor"); Check.NotNull(projectRepository, "projectRepository"); return new PackageAddResultIterator(AddProjectPackageCore(packageToAdd, sourceRepositories, projectDescriptor, projectRepository, options)); }
public DefaultPackageInfo(string packageFileName, Version versionFileContent, IPackageDescriptor descriptor) { _descriptor = descriptor; _packageVersion = versionFileContent ?? descriptor.Version ?? PackageNameUtility.GetVersion(packageFileName); _packageName = PackageNameUtility.GetName(packageFileName); Identifier = new PackageIdentifier(Name, Version); }
IEnumerable <PackageOperationResult> RemoveProjectPackageCore(PackageRequest packageToRemove, IPackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options) { return((packageToRemove.ExactVersion == null && !packageToRemove.LastVersion) ? RemoveFromDescriptor(packageToRemove, packageDescriptor, projectRepository, options) : RemovePackageFilesFromProjectRepo(packageToRemove, projectRepository)); }
public IPackageCleanResult CleanProjectPackages(IPackageDescriptor packages, IPackageRepository projectRepository, string name, PackageCleanOptions options = PackageCleanOptions.Default) { if (packages == null) throw new ArgumentNullException("packages"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); var repoForClean = projectRepository as ISupportCleaning; if (repoForClean == null) throw new ArgumentException("projectRepository must implement ISupportCleaning"); return new PackageCleanResultIterator(CleanProjectPackagesCore(packages, repoForClean, x => name.EqualsNoCase(x))); }
IEnumerable <PackageOperationResult> AddProjectPackage(IPackageDescriptor targetDescriptor, IEnumerable <IPackageRepository> sourceRepositories) { var packageDescriptor = targetDescriptor.Lock(HostEnvironment.ProjectRepository); foreach (var m in PackageManager.AddProjectPackage(PackageRequest, sourceRepositories, packageDescriptor, HostEnvironment.ProjectRepository, AddOptions)) { yield return(m); } }
/// <nodoc /> private Package(PackageId id, AbsolutePath path, IPackageDescriptor descriptor, IEnumerable <AbsolutePath> parsedProjects = null) { Id = id; Path = path; Descriptor = descriptor; DescriptorProjects = descriptor?.Projects != null ? new HashSet <AbsolutePath>(descriptor.Projects) : null; m_parsedProjects = parsedProjects != null ? new HashSet <AbsolutePath>(parsedProjects) : new HashSet <AbsolutePath>(); }
public DependencyResolutionResult(IPackageDescriptor descriptor, IEnumerable <ResolvedPackage> successfulPackages, IEnumerable <ResolvedPackage> conflictingPackages, IEnumerable <ResolvedPackage> missingPackages) { Descriptor = descriptor; SuccessfulPackages = successfulPackages.ToList().AsReadOnly(); DiscardedPackages = conflictingPackages.ToList().AsReadOnly(); MissingPackages = missingPackages.ToList().AsReadOnly(); //IsSuccess = !(MissingPackages.Any() || DiscardedPackages.Any()); IsSuccess = !(MissingPackages.Any(x => SuccessfulPackages.None(s => s.Identifier.Name.EqualsNoCase(x.Identifier.Name))) || DiscardedPackages.Any(x => SuccessfulPackages.None(s => s.Identifier.Name.EqualsNoCase(x.Identifier.Name)))); }
public DependencyResolutionResult(IPackageDescriptor descriptor, IEnumerable<ResolvedPackage> successfulPackages, IEnumerable<ResolvedPackage> conflictingPackages, IEnumerable<ResolvedPackage> missingPackages) { Descriptor = descriptor; SuccessfulPackages = successfulPackages.ToList().AsReadOnly(); DiscardedPackages = conflictingPackages.ToList().AsReadOnly(); MissingPackages = missingPackages.ToList().AsReadOnly(); //IsSuccess = !(MissingPackages.Any() || DiscardedPackages.Any()); IsSuccess = !(MissingPackages.Any(x => SuccessfulPackages.None(s => s.Identifier.Name.EqualsNoCase(x.Identifier.Name))) || DiscardedPackages.Any(x => SuccessfulPackages.None(s => s.Identifier.Name.EqualsNoCase(x.Identifier.Name)))); }
public void AddPackage(IPackageDescriptor descriptor) { var package = Convert(descriptor); if (package == null || this.Packages.Contains(package)) { return; } this.Packages.Add(package); }
protected virtual void AddDependencies(PackageBuilder builder, IPackageDescriptor descriptor) { if (descriptor.Dependencies.Count == 0) { return; } var dependencySet = new PackageDependencySet(VersionUtility.DefaultTargetFramework, descriptor.Dependencies); builder.DependencySets.Add(dependencySet); }
public void Parse(string line, IPackageDescriptor descriptor) { var match = _regex.Match(line); if (!match.Success) { return; } ParseContent(match.Groups["content"].Value, descriptor); }
public void RegisterPackage(IPackageDescriptor descriptor) { foreach (var element in descriptor.GetElements()) { elementsResolver.Register(element.Namespace, element.Name, element.ActualType); } foreach (var attributeConverter in descriptor.GetAttributeConverters()) { attributeConvertersResolver.Register(attributeConverter.Type, attributeConverter.Converter); } }
IEnumerable <PackageOperationResult> CopyPackageCore(IEnumerable <IPackageRepository> sourceRepositories, IEnumerable <IPackageRepository> destinationRepositories, IPackageDescriptor descriptor, Func <string, bool> nameSelector) { var updateDescriptor = new PackageDescriptor(descriptor); updateDescriptor.Dependencies.Clear(); updateDescriptor.Dependencies.AddRange(descriptor.Dependencies.Where(x => nameSelector(x.Name))); var resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, sourceRepositories); if (!resolvedPackages.IsSuccess) { foreach (var packageResolution in ReturnError(resolvedPackages)) { yield return(packageResolution); } yield break; } var packagesForGacDetection = GetSelectedPackages(resolvedPackages); foreach (var conflict in from errors in _exporter.InGac(packagesForGacDetection) select new PackageGacConflictResult(errors.Key, errors)) { yield return(conflict); } foreach (var m in CopyPackagesToRepositories(sourceRepositories, resolvedPackages, destinationRepositories)) { yield return(m); } foreach (var repo in destinationRepositories) { repo.RefreshPackages(); } // need to refresh the resolve with the newly copied packages resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, destinationRepositories); foreach (var anchor in AnchorPackages(resolvedPackages, destinationRepositories)) { yield return(anchor); } }
public static IPackageDescriptor Lock(this IPackageDescriptor descriptor, IPackageRepository repository, string scope = null) { scope = scope ?? string.Empty; var lockedRepo = repository.Feature <ISupportLocking>(); if (lockedRepo == null) { return(descriptor); } var lockedDescriptor = new PackageDescriptor(descriptor); var lockedPackages = lockedRepo.LockedPackages[scope]; return(Lock(lockedDescriptor, lockedPackages)); }
public static IEnumerable<Exports.IAssembly> GetProjectAssemblyReferences(this IPackageManager manager, IPackageDescriptor descriptor, IPackageRepository repository, ExecutionEnvironment environment, bool includeContentOnly) { var sourcePackages = manager.ListProjectPackages(descriptor, repository); var assemblies = manager.GetProjectExports<Exports.IAssembly>(descriptor, repository, environment) .SelectMany(x => x); if (includeContentOnly) return assemblies; var packagesToInclude = sourcePackages.NotInContentBranch(descriptor.Dependencies).Select(x=>x.Identifier).ToList(); return assemblies.Where(x => packagesToInclude.Contains(x.Package.Identifier)).ToList(); }
IEnumerable <IPackageInfo> GetPackagesToLock(IPackageDescriptor descriptor, IEnumerable <IPackageInfo> allPackages) { var currentPackages = allPackages; var names = Name.Any() ? Name : descriptor.Dependencies.Select(x => x.Name); if (names.Any()) { var rootPackages = currentPackages.Where(_ => names.ContainsNoCase(_.Name)); currentPackages = IgnoreDependencies ? rootPackages : currentPackages.AffectedPackages(rootPackages); } return(currentPackages); }
IEnumerable <PackageOperationResult> RemoveFromDescriptor(PackageRequest packageToRemove, IPackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options) { var dependency = packageDescriptor.Dependencies.FirstOrDefault(x => x.Name.EqualsNoCase(packageToRemove.Name)); if (dependency == null) { yield return(new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.DependencyNotFound)); yield break; } packageDescriptor.Dependencies.Remove(dependency); }
public static SemanticVersion GenerateVersion(IPackageDescriptor descriptor, IFile versionFile) { var ver = versionFile.Exists ? versionFile.ReadLines().First() : descriptor.SemanticVersion.ToString(); var lastBuildFile = versionFile.Parent.GetDirectory("wraps") .GetDirectory("_cache") .GetFile("_lastBuild"); var builder = new SemanticVersionGenerator( ver, () => lastBuildFile.Exists ? lastBuildFile.ReadString() : "-1", lastBuildFile.WriteString); return builder.Version(); }
IEnumerable<IPackageInfo> GetPackagesToLock(IPackageDescriptor descriptor, IEnumerable<IPackageInfo> allPackages) { var currentPackages = allPackages; var names = Name.Any() ? Name : descriptor.Dependencies.Select(x => x.Name); if (names.Any()) { var rootPackages = currentPackages.Where(_ => names.ContainsNoCase(_.Name)); currentPackages = IgnoreDependencies ? rootPackages : currentPackages.AffectedPackages(rootPackages); } return currentPackages; }
DependencyResolutionResult Result(IPackageDescriptor descriptor, PackageSelectionContext packageSelectionContext, IEnumerable<IPackageRepository> repositoriesToQuery, IEnumerable<IGrouping<PackageDependency, CallStack>> notFound) { var success = (from compatible in packageSelectionContext.CompatiblePackageVersions let id = compatible.Key let packages = from repo in repositoriesToQuery from package in repo.FindAll(ToDependency(id)) select package select new ResolvedPackage(id, packages.ToList(), compatible.Value.Successful)) .ToList(); var missing = from callStacks in notFound select new ResolvedPackage(new PackageIdentifier(callStacks.Key.Name), Enumerable.Empty<IPackageInfo>(), callStacks.ToList()); var conflicting = from incompat in packageSelectionContext.IncompatiblePackageVersions.GroupBy(x => x.Key, x => x.Value) select new ResolvedPackage(incompat.Key, Enumerable.Empty<IPackageInfo>(), incompat.SelectMany(x => x.Failed.Concat(x.Successful))); return new DependencyResolutionResult(descriptor, success, conflicting, missing); }
public UncompressedPackage(IPackageRepository source, IFile originalPackageFile, IDirectory wrapCacheDirectory) { _originalPackageFile = originalPackageFile; BaseDirectory = wrapCacheDirectory; // get the descriptor file inside the package var descriptorName = originalPackageFile.NameWithoutExtension; Source = source; var wrapDescriptor = wrapCacheDirectory.Files("*.wrapdesc").SingleOrDefault(); if (wrapDescriptor == null) throw new InvalidOperationException("Could not find descriptor in wrap cache directory, or there are multiple .wrapdesc files in the package."); var versionFile = wrapCacheDirectory.GetFile("version"); _descriptor = new PackageDescriptorReaderWriter().Read(wrapDescriptor); PackageInfo = new DefaultPackageInfo(originalPackageFile.Name, versionFile.Exists ? versionFile.Read(x => x.ReadString().ToVersion()) : null, _descriptor); Identifier = new PackageIdentifier(Name, Version); }
// TODO: Issue with not using the correct IFile when building -from public static SemanticVersion GenerateVersion(IPackageDescriptor descriptor, IFile versionFile, Func<string> incrementalReader = null, Action<string> incrementalWriter = null) { var ver = versionFile.Exists ? versionFile.ReadLines().First() : (descriptor.SemanticVersion != null ? descriptor.SemanticVersion.ToString() : descriptor.Version.ToString()); var lastBuildFile = versionFile.Parent.GetDirectory("wraps") .GetDirectory("_cache") .GetFile("_lastBuild"); var builder = new SemanticVersionGenerator( ver, incrementalReader ?? (() => lastBuildFile.Exists ? lastBuildFile.ReadString() : "-1"), incrementalWriter ?? lastBuildFile.WriteString); return builder.Version(); }
protected void given_scoped_descriptor(params string[] lines) { ScopedDescriptor = ReadDescriptor(lines, x=>Descriptor.CreateScoped(x)); }
protected override void ParseContent(string content, IPackageDescriptor descriptor) { var dependency = ParseDependsValue(content); if (dependency != null) descriptor.Dependencies.Add(dependency); }
IEnumerable<PackageOperationResult> RemoveFromDescriptor(PackageRequest packageToRemove, IPackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options) { var dependency = packageDescriptor.Dependencies.FirstOrDefault(x => x.Name.EqualsNoCase(packageToRemove.Name)); if (dependency == null) { yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.DependencyNotFound); yield break; } packageDescriptor.Dependencies.Remove(dependency); if ((options & PackageRemoveOptions.Clean) == PackageRemoveOptions.Clean) foreach (var cleaned in CleanProjectPackages(packageDescriptor, projectRepository, packageToRemove.Name)) yield return cleaned; }
IEnumerable<PackageOperationResult> AddProjectPackageCore(PackageRequest packageToAdd, IEnumerable<IPackageRepository> sourceRepositories, IPackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageAddOptions options) { var finalDescriptor = (options & PackageAddOptions.UpdateDescriptor) == PackageAddOptions.UpdateDescriptor ? projectDescriptor : new PackageDescriptor(projectDescriptor); var existingEntries = finalDescriptor.Dependencies.Where(x => x.Name.EqualsNoCase(packageToAdd.Name)).ToList(); if (existingEntries.Count > 0) { finalDescriptor.Dependencies.RemoveRange(existingEntries); yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Updated); } else { yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Added); } finalDescriptor.Dependencies.Add(ToDependency(packageToAdd, options)); foreach (var m in CopyPackageCore(sourceRepositories, new[] { projectRepository }, finalDescriptor, x => true)) yield return m; }
void LoadDescriptor() { using (Stream zipStream = PackageFile.OpenRead()) using (var zip = new ZipFile(zipStream)) { var entries = zip.Cast<ZipEntry>(); ZipEntry descriptorFile = entries.FirstOrDefault(x => x.Name.EndsWithNoCase(".wrapdesc")); if (descriptorFile == null) return; ZipEntry versionFile = entries.SingleOrDefault(x => x.Name.EqualsNoCase("version")); SemanticVersion versionFromVersionFile = versionFile != null ? zip.Read(versionFile, x => x.ReadString().Replace("\r","").Replace("\n", "").ToSemVer()) : null; _descriptor = zip.Read(descriptorFile, x => new PackageDescriptorReader().Read(x)); _semver = _descriptor.SemanticVersion ?? versionFromVersionFile ?? _descriptor.Version.ToSemVer(); } }
IEnumerable<PackageOperationResult> CleanProjectPackagesCore(IPackageDescriptor projectDescriptor, ISupportCleaning projectRepository, Func<string, bool> packageName) { var resolvedPackages = _resolver.TryResolveDependencies(projectDescriptor, new[] { projectRepository }); if (resolvedPackages.SuccessfulPackages.Any() == false) { yield return new PackageCleanCannotDo(projectDescriptor); yield break; } var projectPackagesInUse = from successfulPackageStack in resolvedPackages.SuccessfulPackages from package in successfulPackageStack.Packages where packageName(package.Identifier.Name) select package; var otherPackages = from packagesByName in projectRepository.PackagesByName where !packageName(packagesByName.Key) from package in packagesByName select package; var packagesInUse = projectPackagesInUse.Concat(otherPackages).ToList(); foreach (var cleanedPackage in projectRepository.Clean(packagesInUse)) yield return cleanedPackage; foreach (var anchored in AnchorPackages(resolvedPackages, new[] { projectRepository })) yield return anchored; }
public PackageCleanCannotDo(IPackageDescriptor projectDescriptor) { _projectDescriptor = projectDescriptor; }
IEnumerable<PackageOperationResult> AddProjectPackage(IPackageDescriptor targetDescriptor, IEnumerable<IPackageRepository> sourceRepositories) { var packageDescriptor = targetDescriptor.Lock(HostEnvironment.ProjectRepository); foreach (var m in PackageManager.AddProjectPackage(PackageRequest, sourceRepositories, packageDescriptor, HostEnvironment.ProjectRepository, AddOptions)) yield return m; }
void RewriteDescriptorFile(IPackageDescriptor descriptor) { using (var destinationStream = HostEnvironment.DescriptorFile.OpenWrite()) { new PackageDescriptorReaderWriter().Write(descriptor, destinationStream); } }
IEnumerable<PackageOperationResult> CopyPackageCore(IEnumerable<IPackageRepository> sourceRepositories, IEnumerable<IPackageRepository> destinationRepositories, IPackageDescriptor descriptor, Func<string, bool> nameSelector) { var updateDescriptor = new PackageDescriptor(descriptor); updateDescriptor.Dependencies.Clear(); updateDescriptor.Dependencies.AddRange(descriptor.Dependencies.Where(x => nameSelector(x.Name))); var resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, sourceRepositories); if (!resolvedPackages.IsSuccess) { foreach (var packageResolution in ReturnError(resolvedPackages)) yield return packageResolution; yield break; } var packagesForGacDetection = resolvedPackages.SuccessfulPackages.Select(x => x.Packages.First()).ToList(); foreach (var conflict in from errors in GacResolver.InGac(packagesForGacDetection) select new PackageGacConflictResult(errors.Key, errors)) yield return conflict; foreach (var m in CopyPackagesToRepositories(sourceRepositories, resolvedPackages, destinationRepositories)) yield return m; foreach (var repo in destinationRepositories) repo.RefreshPackages(); // need to refresh the resolve with the newly copied packages resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, destinationRepositories); foreach (var anchor in AnchorPackages(resolvedPackages, destinationRepositories)) yield return anchor; }
public IPackageRemoveResult RemoveProjectPackage(PackageRequest packageToRemove, IPackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options = PackageRemoveOptions.Default) { if (packageToRemove == null) throw new ArgumentNullException("packageToRemove"); if (packageDescriptor == null) throw new ArgumentNullException("packageDescriptor"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); return new PackageRemoveResultIterator((packageToRemove.ExactVersion == null && !packageToRemove.LastVersion) ? RemoveFromDescriptor(packageToRemove, packageDescriptor, projectRepository, options) : RemovePackageFilesFromProjectRepo(packageToRemove, projectRepository)); }
public IPackageUpdateResult UpdateProjectPackages(IEnumerable<IPackageRepository> sourceRepositories, IPackageRepository projectRepository, IPackageDescriptor projectDescriptor, string packageName, PackageUpdateOptions options = PackageUpdateOptions.Default) { if (sourceRepositories == null) throw new ArgumentNullException("sourceRepositories"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); if (projectDescriptor == null) throw new ArgumentNullException("projectDescriptor"); if (sourceRepositories.Any(x => x == null)) throw new ArgumentException("Some repositories are null.", "sourceRepositories"); return new PackageUpdateResultIterator(CopyPackageCore(sourceRepositories, new[] { projectRepository }, projectDescriptor, x => x.EqualsNoCase(packageName))); }