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 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;
}
public DefaultPackageInfo(Version versionFileContent, IPackageDescriptor descriptor)
{
_descriptor = descriptor;
_packageVersion = versionFileContent
?? descriptor.Version;
//_packageName = PackageNameUtility.GetName(packageFileName);
Identifier = new PackageIdentifier(Name, Version);
}
public void PackageHasChildrenConflicting(PackageIdentifier identifier)
{
_compatiblePackageVersions.Pop();
CompatiblePackageVersions.Remove(identifier);
PackageResolveResults newIgnores = _incompatiblePackages.Pop();
_incompatiblePackages.Pop();
_incompatiblePackages.Push(newIgnores);
}
public void PackageConflicts(PackageIdentifier identifier, CallStack failingCallStack)
{
PackageResolutionStacks existingCompatible = CompatiblePackageVersions[identifier];
_compatiblePackageVersions.Pop();
CompatiblePackageVersions.Remove(identifier);
_incompatiblePackages.Pop();
IncompatiblePackageVersions.Add(identifier, existingCompatible.Successful, existingCompatible.Failed.Concat(failingCallStack));
}
public void PackageSucceeds(PackageIdentifier packageNode, CallStack succeedingCallstack)
{
// commit the new ignore list
PackageResolveResults ignoredPackagesInBranch = _incompatiblePackages.Pop();
_incompatiblePackages.Pop();
_incompatiblePackages.Push(ignoredPackagesInBranch);
// add successful package
PackageResolveResults foundPackages = _compatiblePackageVersions.Pop();
foundPackages.Add(packageNode, successful: new[] { succeedingCallstack });
_compatiblePackageVersions.Pop();
_compatiblePackageVersions.Push(foundPackages);
}
public UncompressedPackage(IPackageRepository source,
IFile originalPackage,
IDirectory wrapCacheDirectory,
IEnumerable<IExportBuilder> exporters)
{
_originalWrapFile = originalPackage;
_exporters = exporters;
BaseDirectory = wrapCacheDirectory;
// get the descriptor file inside the package
var descriptorName = originalPackage.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 DefaultPackageInfo(originalPackage.Name, versionFile.Exists ? versionFile.Read(x=>x.ReadString().ToVersion()) : null, new PackageDescriptorReaderWriter().Read(wrapDescriptor));
Identifier = new PackageIdentifier(Name, Version);
}
public PackageNode(PackageIdentifier identifier)
{
Identifier = identifier;
}
public PackageVersionNotFoundException(PackageIdentifier identifier, Exception innerException)
: this(identifier, null, innerException)
{
}
public PackageEntryWrapper(IPackageRepository source, PackageEntry entry, Func<IPackage> load)
{
Source = source;
_entry = entry;
_load = load;
Identifier = new PackageIdentifier(_entry.Name, _entry.Version);
Dependencies = entry.Dependencies.Select(DependsParser.ParseDependsValue).ToList();
}
public PackageVersionNotFoundException(PackageIdentifier identifier, string message)
: this(identifier, message, null)
{
}
public void ExistingPackageCompatible(PackageIdentifier packageIdentifier, CallStack callStack)
{
_compatiblePackageVersions.Peek().Add(packageIdentifier, new[] { callStack });
}
public Task <bool> CanHandlePackage(PackageIdentifier packageIdentifier)
{
throw new NotImplementedException();
}
public void ExistingPackageCompatible(PackageIdentifier packageIdentifier, CallStack callStack)
{
_compatiblePackageVersions.Peek().Add(packageIdentifier, new[] { callStack });
}
PackageDependency ToDependency(PackageIdentifier pid)
{
return new PackageDependencyBuilder(pid.Name).VersionVertex(new AbsolutelyEqualVersionVertex(pid.Version));
}
PackageDependency ToDependency(PackageIdentifier pid)
{
return(new PackageDependencyBuilder(pid.Name).VersionVertex(new AbsolutelyEqualVersionVertex(pid.Version)));
}
void PushStack(PackageIdentifier identifier)
{
_currentNode.Push(new PackageNode(identifier));
WriteDebug("P:" + identifier);
}
public override Task <bool> CanHandlePackage(PackageIdentifier packageIdentifier)
{
return(Task.FromResult(true));
}
public void Trying(PackageIdentifier existing)
{
_compatiblePackageVersions.Push(new PackageResolveResults(CompatiblePackageVersions));
CompatiblePackageVersions.Add(existing);
_incompatiblePackages.Push(new PackageResolveResults(IncompatiblePackageVersions));
}
public bool IsIgnored(PackageIdentifier identifier)
{
return(IncompatiblePackageVersions[identifier].Failed.Count() > 0);
}
IDisposable Push(PackageIdentifier identifier)
{
_currentNode.Push(new PackageNode(identifier));
WriteDebug("P:" + identifier);
return(new ActionOnDispose(Pop));
}
public DuplicatePackageVersionException(PackageIdentifier identifier, string message)
: this(identifier, message, null)
{
}
void PushStack(PackageIdentifier identifier)
{
_currentNode.Push(new PackageNode(identifier));
WriteDebug("P:" + identifier);
}
public DuplicatePackageVersionException(PackageIdentifier identifier, Exception innerException)
: this(identifier, null, innerException)
{
}
public void Trying(PackageIdentifier existing)
{
_compatiblePackageVersions.Push(new PackageResolveResults(CompatiblePackageVersions));
CompatiblePackageVersions.Add(existing);
_incompatiblePackages.Push(new PackageResolveResults(IncompatiblePackageVersions));
}
public DuplicatePackageVersionException(PackageIdentifier identifier, string message, Exception innerException) : base(message, innerException)
{
Identifier = identifier;
}
public bool IsIgnored(PackageIdentifier identifier)
{
return IncompatiblePackageVersions[identifier].Failed.Count() > 0;
}
static Uri?GetPackageRegistrationDownloadUri(ICredentials feedCredentials, TimeSpan httpTimeout, IDictionary <string, List <Uri> > resources, PackageIdentifier packageIdentifier)
{
var packageRegistrationUri = GetPackageRegistrationUri(resources, packageIdentifier.Id);
var packageRegistrationResponse = GetJsonResponse(packageRegistrationUri, feedCredentials, httpTimeout);
// Package Registration Response structure
// https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#response
var registrationPages = packageRegistrationResponse["items"];
// Registration Page structure
// https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#registration-page-object
foreach (var registrationPage in registrationPages)
{
var registrationLeaves = registrationPage["items"];
if (registrationLeaves == null)
{
// narrow version to specific page.
var versionedRegistrationPage = registrationPages.FirstOrDefault(x => VersionComparer.Default.Compare(new SemanticVersion(x["lower"].ToString()), packageIdentifier.SemanticVersionWithoutMetadata) <= 0 && VersionComparer.Default.Compare(new SemanticVersion(x["upper"].ToString()), packageIdentifier.SemanticVersionWithoutMetadata) >= 0);
// If we can't find a page for the version we are looking for, return null.
if (versionedRegistrationPage == null)
{
return(null);
}
var versionedRegistrationPageResponse = GetJsonResponse(new Uri(versionedRegistrationPage["@id"].ToString()), feedCredentials, httpTimeout);
registrationLeaves = versionedRegistrationPageResponse["items"];
}
// Leaf Structure
// https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#registration-leaf-object-in-a-page
var leaf = registrationLeaves.FirstOrDefault(x => string.Equals(x["catalogEntry"]["version"].ToString(), packageIdentifier.Version, StringComparison.OrdinalIgnoreCase));
// If we can't find the leaf registration for the version we are looking for, return null.
if (leaf == null)
{
return(null);
}
var contentUri = leaf["packageContent"].ToString();
// Note: We reformat the packageContent Uri here as Artifactory (and possibly others) does not include +metadata suffixes on its packageContent Uri's
var downloadUri = new Uri($"{contentUri.Remove(contentUri.LastIndexOfAny("/".ToCharArray()) + 1)}{packageIdentifier.Version}");
return(downloadUri);
}
return(null);
}
static Uri?GetPackageBaseDownloadUri(IDictionary <string, List <Uri> > resources, PackageIdentifier packageIdentifier)
{
var packageBaseUri = GetPackageBaseUri(resources);
if (packageBaseUri?.AbsoluteUri.TrimEnd('/') != null)
{
return(new Uri($"{packageBaseUri}/{packageIdentifier.Id}/{packageIdentifier.Version}/{packageIdentifier.Id}.{packageIdentifier.Version}.nupkg"));
}
return(null);
}
public Task <Tarball> GetTarballAsync(PackageIdentifier identifier)
{
return(_repository.GetTarballAsync(identifier));
}
public ResolvedPackage(PackageIdentifier packageIdentifier, IEnumerable<IPackageInfo> packages, IEnumerable<CallStack> dependencies)
{
Identifier = packageIdentifier;
Packages = packages.ToList().AsReadOnly();
DependencyStacks = dependencies.ToList().AsReadOnly();
}
public Task <Stream> GetPackageImportStream(PackageIdentifier packageIdentifier)
{
throw new NotImplementedException();
}
