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