public static V2FeedPackageInfo ToV2FeedPackageInfo(
this NuspecReader reader, PackageDerivedData packageDerivedData, string downloadUrl, long downloadCount)
{
return(new V2FeedPackageInfo(
identity: new PackageIdentity(reader.GetId(), reader.GetVersion()),
title: reader.GetTitle(),
summary: reader.GetSummary(),
description: reader.GetDescription(),
authors: reader.GetAuthors().Split(','),
owners: reader.GetOwners().Split(','),
iconUrl: reader.GetIconUrl(),
licenseUrl: reader.GetLicenseUrl(),
projectUrl: reader.GetProjectUrl(),
reportAbuseUrl: reader.GetProjectUrl(),
tags: reader.GetTags(),
created: packageDerivedData.Created,
lastEdited: packageDerivedData.LastUpdated,
published: packageDerivedData.LastUpdated,
dependencies: DependencySetsAsString(reader.GetDependencyGroups()),
requireLicenseAccept: reader.GetRequireLicenseAcceptance(),
downloadUrl: downloadUrl,
downloadCount: downloadCount.ToString(),
packageHash: packageDerivedData.PackageHash,
packageHashAlgorithm: packageDerivedData.PackageHashAlgorithm,
minClientVersion: reader.GetMinClientVersion()
));
}
private static void ReadPackage()
{
// This code region is referenced by the NuGet docs. Please update the docs if you rename the region
// or move it to a different file.
#region ReadPackage
using FileStream inputStream = new FileStream("MyPackage.nupkg", FileMode.Open);
using PackageArchiveReader reader = new PackageArchiveReader(inputStream);
NuspecReader nuspec = reader.NuspecReader;
Console.WriteLine($"ID: {nuspec.GetId()}");
Console.WriteLine($"Version: {nuspec.GetVersion()}");
Console.WriteLine($"Description: {nuspec.GetDescription()}");
Console.WriteLine($"Authors: {nuspec.GetAuthors()}");
Console.WriteLine("Dependencies:");
foreach (var dependencyGroup in nuspec.GetDependencyGroups())
{
Console.WriteLine($" - {dependencyGroup.TargetFramework.GetShortFolderName()}");
foreach (var dependency in dependencyGroup.Packages)
{
Console.WriteLine($" > {dependency.Id} {dependency.VersionRange}");
}
}
Console.WriteLine("Files:");
foreach (var file in reader.GetFiles())
{
Console.WriteLine($" - {file}");
}
#endregion
}
private static Table CreateTable(NuspecReader nuspecReader)
{
var second = new Table()
.Border(TableBorder.Rounded)
.BorderColor(Color.Green)
.AddColumn(new TableColumn("[u]Name[/]"))
.AddColumn(new TableColumn("[u]Score[/]"))
.AddColumn(new TableColumn("[u]Total[/]"))
.AddRow(new Text(Emoji.Known.GlobeShowingEuropeAfrica),
new Text(Emoji.Known.Frog + nuspecReader.GetDescription()), new Text(Emoji.Known.Rocket));
return(new Table()
.Centered()
.Border(TableBorder.DoubleEdge)
.Title($"DOTNET [yellow]SCORE[/] - [red]{nuspecReader.GetId()}[/]")
.Caption("TOTAL [yellow]SCORE[/]")
.AddColumn(
new TableColumn(new Panel("[u]POPULARITY[/]").BorderColor(Color.Red)).Footer(
"[u]POPULARITY SCORE[/]"))
.AddColumn(
new TableColumn(new Panel("[u]QUALITY[/]").BorderColor(Color.Green)).Footer("[u]QUALITY SCORE[/]"))
.AddColumn(
new TableColumn(new Panel("[u]MAINTENANCE[/]").BorderColor(Color.Blue)).Footer(
"[u]MAINTENANCE SCORE[/]"))
.AddRow(second, second, second));
}
public static Package CreatePackageObject(string packagePath)
{
List <PackageAsset> packageAssets = new List <PackageAsset>();
Dictionary <NuGetFramework, List <PackageDependency> > packageDependencies = new Dictionary <NuGetFramework, List <PackageDependency> >();
PackageArchiveReader nupkgReader = new PackageArchiveReader(packagePath);
NuspecReader nuspecReader = nupkgReader.NuspecReader;
string packageId = nuspecReader.GetId();
string version = nuspecReader.GetVersion().ToString();
IEnumerable <PackageDependencyGroup> dependencyGroups = nuspecReader.GetDependencyGroups();
foreach (var item in dependencyGroups)
{
packageDependencies.Add(item.TargetFramework, item.Packages.ToList());
}
var files = nupkgReader.GetFiles().ToList().Where(t => t.EndsWith(".dll")).Where(t => t.Contains(packageId + ".dll"));
foreach (var file in files)
{
packageAssets.Add(ExtractAssetFromFile(file));
}
return(new Package(packageId, version, packageAssets, packageDependencies));
}
private void LoadNuSpecFile(string filePath)
{
var nuSpecFilePath = Directory.GetFiles(System.IO.Path.GetDirectoryName(filePath), "*.nuspec", SearchOption.AllDirectories).FirstOrDefault();
if (nuSpecFilePath != null && !nuSpecFilePath.StartsWith(NuGetPackagesPath))
{
NuSpecFilePath = nuSpecFilePath;
using (var stream = File.Open(NuSpecFilePath, FileMode.Open))
{
var reader = new NuspecReader(stream);
var packageId = reader.GetId();
if (packageId != null && packageId.ToLower() == "$id$")
{
packageId = Name;
}
NuGetPackageId = packageId;
NuGetPackageTitle = Name;
var metadata = reader.GetMetadata().ToArray();
if (metadata.Any(p => p.Key == "title"))
{
var titlePair = metadata.SingleOrDefault(p => p.Key == "title");
NuGetPackageTitle = titlePair.Value;
}
}
}
}
internal static LibraryIdentity CreateLibraryFromNupkg(string nupkgPath)
{
using (var fileStream = File.OpenRead(nupkgPath))
{
using (var archive = new ZipArchive(fileStream))
{
foreach (var entry in archive.Entries)
{
if (!entry.Name.EndsWith(ManifestExtension, StringComparison.OrdinalIgnoreCase))
{
continue;
}
using (var entryStream = entry.Open())
{
var reader = new NuspecReader(entryStream);
return(new LibraryIdentity()
{
Name = reader.GetId(),
Version = reader.GetVersion(),
Type = LibraryTypes.Package
});
}
}
throw new FormatException(
string.Format("{0} doesn't contain {1} entry", nupkgPath, ManifestExtension));
}
}
}
public void NuspecReaderTests_NamespaceOnMetadata()
{
NuspecReader reader = GetReader(NamespaceOnMetadataNuspec);
string id = reader.GetId();
Assert.Equal("packageB", id);
}
public void NuspecReaderTests_Id()
{
NuspecReader reader = GetReader(BasicNuspec);
string id = reader.GetId();
Assert.Equal("packageA", id);
}
public Tuple <string, NuGetVersion> GetNugetPackageVersion(string package)
{
using (var reader = new PackageArchiveReader(package))
using (var nuspecStream = reader.GetNuspec())
{
NuspecReader nuspec = new NuspecReader(nuspecStream);
return(new Tuple <string, NuGetVersion>(nuspec.GetId(), nuspec.GetVersion()));
}
}
public static Package CreatePackageObject(string packagePath)
{
PackageArchiveReader nupkgReader = new PackageArchiveReader(packagePath);
NuspecReader nuspecReader = nupkgReader.NuspecReader;
string packageId = nuspecReader.GetId();
string version = nuspecReader.GetVersion().ToString();
return(new Package(packageId, version, nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll"))));
}
private List <CachedPackageInfo> GetPackageInfos(string id)
{
List <CachedPackageInfo> cachedPackageInfos;
if (_packageInfoCache.TryGetValue(id, out cachedPackageInfos))
{
cachedPackageInfos = cachedPackageInfos.ToList();
}
var result = new List <CachedPackageInfo>();
// packages\{packageId}.{version}.nupkg
foreach (var nupkgInfo in GetNupkgFiles(_source, id))
{
var cachedPackageInfo = cachedPackageInfos?.FirstOrDefault(package => string.Equals(package.Path, nupkgInfo.FullName, StringComparison.OrdinalIgnoreCase));
if (cachedPackageInfo != null &&
cachedPackageInfo.LastWriteTimeUtc == nupkgInfo.LastWriteTimeUtc)
{
result.Add(cachedPackageInfo);
}
using (var stream = nupkgInfo.OpenRead())
using (var packageReader = new PackageArchiveReader(stream))
{
NuspecReader reader;
try
{
reader = new NuspecReader(packageReader.GetNuspec());
}
catch (XmlException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, nupkgInfo.Name, _source);
throw new FatalProtocolException(message, ex);
}
catch (PackagingException ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Protocol_PackageMetadataError, nupkgInfo.Name, _source);
throw new FatalProtocolException(message, ex);
}
if (string.Equals(reader.GetId(), id, StringComparison.OrdinalIgnoreCase))
{
result.Add(new CachedPackageInfo {
Path = nupkgInfo.FullName, Reader = reader
});
}
}
}
_packageInfoCache.TryAdd(id, result);
return(result);
}
internal IEnumerable <LocalPackageInfo> GetPackages(string packageId, IEnumerable <string> packagePaths)
{
foreach (var path in packagePaths)
{
using (var stream = File.OpenRead(path))
{
var zip = new ZipArchive(stream);
var spec = zip.GetManifest();
using (var specStream = spec.Open())
{
var reader = new NuspecReader(specStream);
if (string.Equals(reader.GetId(), packageId, StringComparison.OrdinalIgnoreCase))
{
yield return(new LocalPackageInfo(reader.GetId(), reader.GetVersion(), _physicalPath));
}
}
}
}
}
public async Task SaveSymbolPackage(NuspecReader nuspec, Stream stream)
{
var packageId = nuspec.GetId().ToLower();
var packageVersion = nuspec.GetVersion().OriginalVersion;
var path = Path.Combine(SymbolsPathPrefix,
packageId,
packageVersion,
$"{packageId}.{packageVersion}.snupkg");
await _storage.PutAsync(path, stream, PdbContentType);
}
private NuGetPackageInfo ReadPackageInformation(string packageLocation)
{
using Stream inputStream = _environmentSettings.Host.FileSystem.OpenRead(packageLocation);
using PackageArchiveReader reader = new PackageArchiveReader(inputStream);
NuspecReader nuspec = reader.NuspecReader;
return(new NuGetPackageInfo(
nuspec.GetAuthors(),
packageLocation,
null,
nuspec.GetId(),
nuspec.GetVersion().ToNormalizedString()));
}
private static Package CreatePackage(PackageArchiveReader packageReader, RuntimeGraph runtimeGraph)
{
NuspecReader nuspecReader = packageReader.NuspecReader;
string packageId = nuspecReader.GetId();
string version = nuspecReader.GetVersion().ToString();
IEnumerable <PackageDependencyGroup> dependencyGroups = nuspecReader.GetDependencyGroups();
Dictionary <NuGetFramework, IEnumerable <PackageDependency> > packageDependencies = new Dictionary <NuGetFramework, IEnumerable <PackageDependency> >();
foreach (PackageDependencyGroup item in dependencyGroups)
{
packageDependencies.Add(item.TargetFramework, item.Packages);
}
return(new Package(packageId, version, packageReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll")), packageDependencies, runtimeGraph));
}
private static NuGetPackageId CreateIdentity(NuspecReader reader, string folderPath)
{
NuGetPackageId package = null;
NuGetVersion version = null;
if (NuGetVersion.TryParse(reader.GetVersion(), out version))
{
package = new NuGetPackageId(reader.GetId(), version, folderPath);
}
else
{
throw new InvalidDataException("invalid version");
}
return(package);
}
private void ProcessNuspecContent(NuspecReader reader)
{
if (Specification.Id == null)
{
Update(reader.GetId(), (id) => Specification.Id = id);
}
UpdateUrl(reader.GetLicenseUrl(), url => Specification.LicenseUrl = url, DEFAULT_LICENCE_URL);
UpdateUrl(reader.GetProjectUrl(), url => Specification.ProjectUrl = url, DEFAULT_PROJECT_URL);
UpdateUrl(reader.GetIconUrl(), url => Specification.IconUrl = url, DEFAULT_ICON_URL);
UpdateList(reader.GetAuthors(), list => Specification.Authors = list);
UpdateList(reader.GetOwners(), list => Specification.Owners = list);
Update(reader.GetReleaseNotes(), notes => Specification.ReleaseNotes = notes, DEFAULT_RELEASE_NOTES);
Update(reader.GetCopyright(), copyright => Specification.Copyright = copyright);
UpdateList(reader.GetTags(), list => Specification.Tags = list, ' ', DEFAULT_TAGS);
Update(reader.GetDescription(), desc => Specification.Description = desc);
}
public static Package CreatePackageObject(string packagePath)
{
PackageArchiveReader nupkgReader = new(packagePath);
NuspecReader nuspecReader = nupkgReader.NuspecReader;
string packageId = nuspecReader.GetId();
string version = nuspecReader.GetVersion().ToString();
NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups()
.Select(dg => dg.TargetFramework)
.Where(tfm => tfm != null)
.ToArray();
IEnumerable <string> files = nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll"));
return(new Package(packageId, version, files, dependencyFrameworks));
}
public ServerPackage(NuspecReader package, PackageDerivedData packageDerivedData)
{
Id = package.GetId();
Version = package.GetVersion();
Title = package.GetTitle();
Authors = package.GetAuthors();
Owners = package.GetOwners();
IconUrl = package.GetIconUrl();
LicenseUrl = package.GetLicenseUrl();
ProjectUrl = package.GetProjectUrl();
RequireLicenseAcceptance = package.GetRequireLicenseAcceptance();
DevelopmentDependency = package.GetDevelopmentDependency();
Description = package.GetDescription();
Summary = package.GetSummary();
ReleaseNotes = package.GetReleaseNotes();
Language = package.GetLanguage();
Tags = package.GetTags();
Copyright = package.GetCopyright();
MinClientVersion = package.GetMinClientVersion();
ReportAbuseUrl = null;
DownloadCount = 0;
SemVer1IsAbsoluteLatest = false;
SemVer1IsLatest = false;
SemVer2IsAbsoluteLatest = false;
SemVer2IsLatest = false;
//FIXME is this OK?
Listed = true;
IsSemVer2 = IsPackageSemVer2(package);
_dependencySets = package.GetDependencyGroups().ToList();
Dependencies = _dependencySets.DependencySetsAsString();
_supportedFrameworks = package.GetFrameworkReferenceGroups().Select(f => f.TargetFramework).ToList();
SupportedFrameworks = string.Join("|", _supportedFrameworks.Select(f => f.GetFrameworkString()));
PackageSize = packageDerivedData.PackageSize;
PackageHash = packageDerivedData.PackageHash;
PackageHashAlgorithm = packageDerivedData.PackageHashAlgorithm;
LastUpdated = packageDerivedData.LastUpdated;
Created = packageDerivedData.Created;
Path = packageDerivedData.Path;
FullPath = packageDerivedData.FullPath;
}
private ProjectData(string targetPackagesPath, string dllPath, string srcPath)
{
this.DllPath = dllPath;
this.targetPackagesPath = targetPackagesPath;
// Find the corresponding nuspec
var splitPath = dllPath.Replace(targetPackagesPath, "").Split(Path.DirectorySeparatorChar);
if (splitPath.Length < 4)
{
throw new ArgumentException("Path does not have expected depth", nameof(dllPath));
}
var rootDir = Path.Combine(targetPackagesPath, Path.Combine(splitPath.Take(2).ToArray()));
this.NuSpecFile = Directory.GetFiles(rootDir, "*.nuspec", SearchOption.TopDirectoryOnly)[0];
nReader = new NuspecReader(NuSpecFile);
// Find the package name
this.PackageName = nReader.GetId();
// Find the package version
this.PackageVersion = nReader.GetVersion();
// Find the tfm for the dll
this.ShortTfm = splitPath[splitPath.Length - 2];
// Find the project name for the dll
this.ProjectFileName = dllPath.Replace(targetPackagesPath, srcPath).Replace(".dll", ".csproj");
// Find the source file name for the dll
this.SourceFileName = dllPath.Replace(targetPackagesPath, srcPath).Replace(".dll", ".cs");
// Find the subPath for the dll (either ref or lib, usually)
this.SubPath = splitPath[splitPath.Length - 3];
var pkgData = PackageData.GetOrCreatePackageData(srcPath, this.PackageName, this.PackageVersion.ToString());
pkgData.ReferenceProjects.Add(this);
}
private List <CachedPackageInfo> GetPackageInfos(string id)
{
List <CachedPackageInfo> cachedPackageInfos;
if (_packageInfoCache.TryGetValue(id, out cachedPackageInfos))
{
cachedPackageInfos = cachedPackageInfos.ToList();
}
var result = new List <CachedPackageInfo>();
// packages\{packageId}.{version}.nupkg
foreach (var nupkgInfo in GetNupkgFiles(_source, id))
{
var cachedPackageInfo = cachedPackageInfos?.FirstOrDefault(package => string.Equals(package.Path, nupkgInfo.FullName, StringComparison.OrdinalIgnoreCase));
if (cachedPackageInfo != null && cachedPackageInfo.LastWriteTimeUtc == nupkgInfo.LastWriteTimeUtc)
{
result.Add(cachedPackageInfo);
}
using (var stream = nupkgInfo.OpenRead())
{
var packageReader = new PackageReader(stream);
var reader = new NuspecReader(packageReader.GetNuspec());
if (string.Equals(reader.GetId(), id, StringComparison.Ordinal))
{
result.Add(new CachedPackageInfo {
Path = nupkgInfo.FullName, Reader = reader
});
}
}
}
_packageInfoCache.TryAdd(id, result);
return(result);
}
/// <summary>
/// A package is deemed to be a satellite package if it has a language property set, the id of the package is
/// of the format [.*].[Language]
/// and it has at least one dependency with an id that maps to the runtime package .
/// </summary>
public static bool IsSatellitePackage(this IPackageCoreReader packageReader)
{
// A satellite package has the following properties:
// 1) A package suffix that matches the package's language, with a dot preceding it
// 2) A dependency on the package with the same Id minus the language suffix
// 3) The dependency can be found by Id in the repository (as its path is needed for installation)
// Example: foo.ja-jp, with a dependency on foo
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
var packageId = nuspecReader.GetId();
var packageLanguage = nuspecReader.GetLanguage();
if (!string.IsNullOrEmpty(packageLanguage)
&&
packageId.EndsWith('.' + packageLanguage, StringComparison.OrdinalIgnoreCase))
{
// The satellite pack's Id is of the format <Core-Package-Id>.<Language>. Extract the core package id using this.
// Additionally satellite packages have a strict dependency on the core package
var localruntimePackageId = packageId.Substring(0, packageId.Length - packageLanguage.Length - 1);
foreach (var group in nuspecReader.GetDependencyGroups())
{
foreach (var dependencyPackage in group.Packages)
{
if (dependencyPackage.Id.Equals(localruntimePackageId, StringComparison.OrdinalIgnoreCase) &&
dependencyPackage.VersionRange != null &&
dependencyPackage.VersionRange.MaxVersion == dependencyPackage.VersionRange.MinVersion &&
dependencyPackage.VersionRange.IsMaxInclusive &&
dependencyPackage.VersionRange.IsMinInclusive)
{
return(true);
}
}
}
}
return(false);
}
private void LoadNuSpecFile(string filePath)
{
var nuSpecFilePath = Directory.GetFiles(System.IO.Path.GetDirectoryName(filePath), "*.nuspec", SearchOption.AllDirectories).FirstOrDefault();
if (nuSpecFilePath != null && !nuSpecFilePath.StartsWith(NuGetPackagesPath) && !nuSpecFilePath.Contains("node_modules"))
{
NuSpecFilePath = nuSpecFilePath;
using (var stream = File.Open(NuSpecFilePath, FileMode.Open))
{
var reader = new NuspecReader(stream);
var packageId = reader.GetId();
if (packageId != null && packageId.ToLower() == "$id$")
{
packageId = Name;
}
NuGetPackageId = packageId;
NuGetPackageTitle = Name;
var metadata = reader.GetMetadata().ToArray();
if (metadata.Any(p => p.Key == "title"))
{
var titlePair = metadata.SingleOrDefault(p => p.Key == "title");
NuGetPackageTitle = titlePair.Value;
}
}
}
else if (Project.GeneratesPackage() ||
Project.HasVersion() ||
!string.IsNullOrEmpty(Project.GetProperty("PackageProjectUrl")?.EvaluatedValue) ||
!string.IsNullOrEmpty(Project.GetProperty("PackageTags")?.EvaluatedValue))
{
NuGetPackageId = Project.GetProperty("PackageId")?.EvaluatedValue;
NuGetPackageTitle = Project.GetProperty("PackageTitle")?.EvaluatedValue ?? Name;
}
}
private static async Task WritePackageNotice(StreamWriter writer, NuspecReader package)
{
await writer.WriteAsync("License notice for ").ConfigureAwait(false);
await writer.WriteAsync(package.GetId()).ConfigureAwait(false);
await writer.WriteAsync(" (v").ConfigureAwait(false);
await writer.WriteAsync(package.GetVersion().ToFullString()).ConfigureAwait(false);
await writer.WriteLineAsync(")").ConfigureAwait(false);
await writer.WriteLineAsync("------------------------------------").ConfigureAwait(false);
var repository = package.GetRepositoryMetadata();
if (!string.IsNullOrEmpty(repository?.Url))
{
await writer.WriteLineAsync().ConfigureAwait(false);
await writer.WriteAsync(repository.Url).ConfigureAwait(false);
if (!string.IsNullOrEmpty(repository.Commit))
{
await writer.WriteAsync(" at ").ConfigureAwait(false);
await writer.WriteAsync(repository.Commit).ConfigureAwait(false);
}
await writer.WriteLineAsync().ConfigureAwait(false);
}
string projectUrl = package.GetProjectUrl();
if (projectUrl != repository?.Url)
{
await WriteIfNotEmpty(writer, string.Empty, projectUrl).ConfigureAwait(false);
}
string copyright = package.GetCopyright();
string copyrightPrefix = string.Empty;
if (copyright?.Length > 0 && copyright[0] == '©')
{
copyrightPrefix = "Copyright ";
}
await WriteIfNotEmpty(writer, copyrightPrefix, copyright).ConfigureAwait(false);
var license = package.GetLicenseMetadata();
if (license != null)
{
string licenseExpression = license.LicenseExpression?.ToString();
await WriteIfNotEmpty(writer, "Licensed under ", licenseExpression).ConfigureAwait(false);
await WriteIfNotEmpty(writer, "Available at ", license.LicenseUrl?.AbsoluteUri).ConfigureAwait(false);
if (license.License != licenseExpression)
{
await WriteIfNotEmpty(writer, string.Empty, license.License).ConfigureAwait(false);
}
}
else
{
await WriteIfNotEmpty(writer, "License available at ", package.GetLicenseUrl()).ConfigureAwait(false);
}
await writer.WriteLineAsync().ConfigureAwait(false);
await writer.WriteLineAsync().ConfigureAwait(false);
}
public static string PackageId(this NuspecReader nuspec) => nuspec.GetId();
private async Task <ActionResult> CreatePackageInternal()
{
// Get the user
var user = GetCurrentUser();
using (var packageStream = ReadPackageFromRequest())
{
try
{
using (var archive = new ZipArchive(packageStream, ZipArchiveMode.Read, leaveOpen: true))
{
var reference = DateTime.UtcNow.AddDays(1); // allow "some" clock skew
var entryInTheFuture = archive.Entries.FirstOrDefault(
e => e.LastWriteTime.UtcDateTime > reference);
if (entryInTheFuture != null)
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.BadRequest, string.Format(
CultureInfo.CurrentCulture,
Strings.PackageEntryFromTheFuture,
entryInTheFuture.Name)));
}
}
using (var packageToPush = new PackageArchiveReader(packageStream, leaveStreamOpen: false))
{
NuspecReader nuspec = null;
try
{
nuspec = packageToPush.GetNuspecReader();
}
catch (Exception ex)
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.BadRequest, string.Format(
CultureInfo.CurrentCulture,
Strings.UploadPackage_InvalidNuspec,
ex.Message)));
}
if (nuspec.GetMinClientVersion() > Constants.MaxSupportedMinClientVersion)
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.BadRequest, string.Format(
CultureInfo.CurrentCulture,
Strings.UploadPackage_MinClientVersionOutOfRange,
nuspec.GetMinClientVersion())));
}
// Ensure that the user can push packages for this partialId.
var packageRegistration = PackageService.FindPackageRegistrationById(nuspec.GetId());
if (packageRegistration != null)
{
if (!packageRegistration.IsOwner(user))
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.Forbidden,
Strings.ApiKeyNotAuthorized));
}
// Check if a particular Id-Version combination already exists. We eventually need to remove this check.
string normalizedVersion = nuspec.GetVersion().ToNormalizedString();
bool packageExists =
packageRegistration.Packages.Any(
p => String.Equals(
p.NormalizedVersion,
normalizedVersion,
StringComparison.OrdinalIgnoreCase));
if (packageExists)
{
return(new HttpStatusCodeWithBodyResult(
HttpStatusCode.Conflict,
String.Format(CultureInfo.CurrentCulture, Strings.PackageExistsAndCannotBeModified,
nuspec.GetId(), nuspec.GetVersion().ToNormalizedStringSafe())));
}
}
var packageStreamMetadata = new PackageStreamMetadata
{
HashAlgorithm = Constants.Sha512HashAlgorithmId,
Hash = CryptographyService.GenerateHash(packageStream.AsSeekableStream()),
Size = packageStream.Length,
};
var package = await PackageService.CreatePackageAsync(
packageToPush,
packageStreamMetadata,
user,
commitChanges : false);
await AutoCuratePackage.ExecuteAsync(package, packageToPush, commitChanges : false);
await EntitiesContext.SaveChangesAsync();
using (Stream uploadStream = packageStream)
{
uploadStream.Position = 0;
await PackageFileService.SavePackageFileAsync(package, uploadStream.AsSeekableStream());
IndexingService.UpdatePackage(package);
}
MessageService.SendPackageAddedNotice(package,
Url.Action("DisplayPackage", "Packages", routeValues: new { id = package.PackageRegistration.Id, version = package.Version }, protocol: Request.Url.Scheme),
Url.Action("ReportMyPackage", "Packages", routeValues: new { id = package.PackageRegistration.Id, version = package.Version }, protocol: Request.Url.Scheme),
Url.Action("Account", "Users", routeValues: null, protocol: Request.Url.Scheme));
return(new HttpStatusCodeResult(HttpStatusCode.Created));
}
}
catch (InvalidPackageException ex)
{
return(BadRequestForExceptionMessage(ex));
}
catch (InvalidDataException ex)
{
return(BadRequestForExceptionMessage(ex));
}
catch (EntityException ex)
{
return(BadRequestForExceptionMessage(ex));
}
catch (FrameworkException ex)
{
return(BadRequestForExceptionMessage(ex));
}
}
}
private async Task <ActionResult> CreatePackageInternal()
{
// Get the user
var user = GetCurrentUser();
using (var packageStream = ReadPackageFromRequest())
{
try
{
using (var packageToPush = new PackageArchiveReader(packageStream, leaveStreamOpen: false))
{
NuspecReader nuspec = null;
try
{
nuspec = packageToPush.GetNuspecReader();
}
catch (Exception ex)
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.BadRequest, string.Format(
CultureInfo.CurrentCulture,
Strings.UploadPackage_InvalidNuspec,
ex.Message)));
}
if (nuspec.GetMinClientVersion() > Constants.MaxSupportedMinClientVersion)
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.BadRequest, string.Format(
CultureInfo.CurrentCulture,
Strings.UploadPackage_MinClientVersionOutOfRange,
nuspec.GetMinClientVersion())));
}
// Ensure that the user can push packages for this partialId.
var packageRegistration = PackageService.FindPackageRegistrationById(nuspec.GetId());
if (packageRegistration != null)
{
if (!packageRegistration.IsOwner(user))
{
return(new HttpStatusCodeWithBodyResult(HttpStatusCode.Forbidden, Strings.ApiKeyNotAuthorized));
}
// Check if a particular Id-Version combination already exists. We eventually need to remove this check.
string normalizedVersion = nuspec.GetVersion().ToNormalizedString();
bool packageExists =
packageRegistration.Packages.Any(
p => String.Equals(
p.NormalizedVersion,
normalizedVersion,
StringComparison.OrdinalIgnoreCase));
if (packageExists)
{
return(new HttpStatusCodeWithBodyResult(
HttpStatusCode.Conflict,
String.Format(CultureInfo.CurrentCulture, Strings.PackageExistsAndCannotBeModified,
nuspec.GetId(), nuspec.GetVersion().ToNormalizedStringSafe())));
}
}
var packageStreamMetadata = new PackageStreamMetadata
{
HashAlgorithm = Constants.Sha512HashAlgorithmId,
Hash = CryptographyService.GenerateHash(packageStream.AsSeekableStream()),
Size = packageStream.Length,
};
var package = await PackageService.CreatePackageAsync(packageToPush, packageStreamMetadata, user, commitChanges : false);
await AutoCuratePackage.ExecuteAsync(package, packageToPush, commitChanges : false);
await EntitiesContext.SaveChangesAsync();
using (Stream uploadStream = packageStream)
{
uploadStream.Position = 0;
await PackageFileService.SavePackageFileAsync(package, uploadStream.AsSeekableStream());
IndexingService.UpdatePackage(package);
}
return(new HttpStatusCodeResult(HttpStatusCode.Created));
}
}
catch (InvalidDataException ex)
{
return(new HttpStatusCodeWithBodyResult(
HttpStatusCode.BadRequest,
string.Format(CultureInfo.CurrentCulture, Strings.UploadPackage_InvalidPackage, ex.Message)));
}
}
}
/// <summary>
/// This method combines the logic used in restore operations to make a determination about the TFM supported by the package.
/// We have curated a set of compatibility requirements for our needs in NuGet.org. The client logic can be found here:
/// https://github.com/NuGet/NuGet.Client/blob/63255047fe7052cc33b763356ff995d9166f719e/src/NuGet.Core/NuGet.Commands/RestoreCommand/CompatibilityChecker.cs#L252-L294
/// https://github.com/NuGet/NuGet.Client/blob/63255047fe7052cc33b763356ff995d9166f719e/src/NuGet.Core/NuGet.Commands/RestoreCommand/CompatibilityChecker.cs#L439-L442
/// ...and our combination of these elements is below.
/// The logic is essentially this:
/// - Determine whether we're looking at a tools package. In this case we will use tools "pattern sets" (collections of file patterns
/// defined in <see cref="ManagedCodeConventions" />) to assess which frameworks are targeted by the package.
/// - If this isn't a tools package, we look for build-time, runtime, content and resource file patterns
/// For added details on the various cases, see unit tests targeting this method.
/// </summary>
public virtual IEnumerable <NuGetFramework> GetSupportedFrameworks(NuspecReader nuspecReader, IList <string> packageFiles)
{
var supportedTFMs = Enumerable.Empty <NuGetFramework>();
if (packageFiles != null && packageFiles.Any() && nuspecReader != null)
{
// Setup content items for analysis
var items = new ContentItemCollection();
items.Load(packageFiles);
var runtimeGraph = new RuntimeGraph();
var conventions = new ManagedCodeConventions(runtimeGraph);
// Let's test for tools packages first--they're a special case
var groups = Enumerable.Empty <ContentItemGroup>();
var packageTypes = nuspecReader.GetPackageTypes();
if (packageTypes.Count == 1 && (packageTypes[0] == PackageType.DotnetTool ||
packageTypes[0] == PackageType.DotnetCliTool))
{
// Only a package that is a tool package (and nothing else) will be matched against tools pattern set
groups = items.FindItemGroups(conventions.Patterns.ToolsAssemblies);
}
else
{
// Gather together a list of pattern sets indicating the kinds of packages we wish to evaluate
var patterns = new[]
{
conventions.Patterns.CompileRefAssemblies,
conventions.Patterns.CompileLibAssemblies,
conventions.Patterns.RuntimeAssemblies,
conventions.Patterns.ContentFiles,
conventions.Patterns.ResourceAssemblies,
};
// Add MSBuild to this list, but we need to ensure we have package assets before they make the cut.
// A series of files in the right places won't matter if there's no {id}.props|targets.
var msbuildPatterns = new[]
{
conventions.Patterns.MSBuildFiles,
conventions.Patterns.MSBuildMultiTargetingFiles,
};
// We'll create a set of "groups" --these are content items which satisfy file pattern sets
var standardGroups = patterns
.SelectMany(p => items.FindItemGroups(p));
// Filter out MSBuild assets that don't match the package ID and append to groups we already have
var packageId = nuspecReader.GetId();
var msbuildGroups = msbuildPatterns
.SelectMany(p => items.FindItemGroups(p))
.Where(g => HasBuildItemsForPackageId(g.Items, packageId));
groups = standardGroups.Concat(msbuildGroups);
}
// Now that we have a collection of groups which have made it through the pattern set filter, let's transform them into TFMs
supportedTFMs = groups
.SelectMany(p => p.Properties)
.Where(pair => pair.Key == ManagedCodeConventions.PropertyNames.TargetFrameworkMoniker)
.Select(pair => pair.Value)
.Cast <NuGetFramework>()
.Distinct();
}
return(supportedTFMs);
}
/// <summary>
/// 从文件中加载插件并管理(但不初始化)
/// </summary>
/// <param name="fileName">相对于运行目录的文件名</param>
public async Task LoadPackageAsync(string fileName)
{
using PackageArchiveReader reader = new PackageArchiveReader(File.OpenRead(fileName), false);
NuspecReader nuspecReader = await reader.GetNuspecReaderAsync(CancellationToken.None);
string identity = nuspecReader.GetId();
IEnumerable <FrameworkSpecificGroup> groups = await reader.GetLibItemsAsync(CancellationToken.None);
FrameworkSpecificGroup group = groups.Where(x => x.TargetFramework.GetShortFolderName().StartsWith("netstandard")).OrderByDescending(x => x.TargetFramework.GetShortFolderName()).FirstOrDefault();
foreach (string packageFile in group.Items)
{
if (!packageFile.EndsWith(".dll"))
{
continue;
}
string tmpPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
string path = reader.ExtractFile(packageFile, tmpPath, NullLogger.Instance);
//Type type = Load(await File.ReadAllBytesAsync(path));
Type type = Load(path);
if (type != null)// 为null时则不是插件程序集， 但不一定不是依赖程序集
{
PluginContext context = new PluginContext();
PluginMeta meta = new PluginMeta(identity, fileName, Path.Combine(Environment.CurrentDirectory, "plugins", identity));
context.Meta = meta;
if (!Directory.Exists(meta.SpaceDirectory))
{
Directory.CreateDirectory(meta.SpaceDirectory);
FrameworkSpecificGroup item = (await reader.GetContentItemsAsync(CancellationToken.None)).FirstOrDefault();
if (item != null)
{
foreach (string file in item.Items)
{
if (file.EndsWith('/') || file.EndsWith('\\'))
{
continue;
}
ZipArchiveEntry entry = reader.GetEntry(file);
entry.SaveAsFile(Path.Combine(meta.SpaceDirectory, file.Substring(8)), NullLogger.Instance);
}
}
}
string configFile = Path.Combine(meta.SpaceDirectory, "config.json");
if (File.Exists(configFile))
{
context.Configuration = new Lazy <IConfiguration>(() =>
{
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddJsonFile(configFile);
return(builder.Build());
});
}
else
{
context.Configuration = new Lazy <IConfiguration>(() => (new ConfigurationBuilder().Build()));
}
string dataFile = Path.Combine(meta.SpaceDirectory, "data.db");
context.Repository = new Lazy <IRepository>(() => new LiteDbRepository(new LiteDatabase(dataFile)));
plugins.Add(type, context);
}
}
}
public async Task <string> DownloadPackageAsync(string connectionID, RequestDownloadInfo requestInfo)
{
// cast
RequestDownloadNuGetInfo info = (RequestDownloadNuGetInfo)requestInfo;
// server response
ServerResponse response = new ServerResponse()
{
payload = new Dictionary <string, string>()
};
string _outputDirectory = $"{_environment.ContentRootPath}/wwwroot/{_configuration.GetValue<string>("DownloadPath")}";
// check if output directory exists
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
string connectionSubName = $"nuget-{connectionID}-{DateTime.Now:yyyymmddHHmmss}";
string connectionDirectory = $"{_outputDirectory}/{connectionSubName}";
Directory.CreateDirectory(connectionDirectory);
// send message
response.payload.Clear();
response.payload.Add("Resource", $"{connectionSubName} created.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3(info.repository);
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
// set all parent packages
for (int i = 0; i < info.packageList.Count(); i++)
{
string packageId = info.packageList.ElementAt(i).packageId;
string packageVersionValue = info.packageList.ElementAt(i).packageVersion;
NuGetVersion packageVersion = new NuGetVersion(packageVersionValue);
PackageInfo package = new PackageInfo {
packageId = packageId, packageVersion = packageVersion
};
if (package.packageVersion != null)
{
_downloadQueue.Enqueue(package);
}
else
{
FloatRange floatRange = null;
if (info.preReleased == true)
{
// include pre-release
floatRange = new FloatRange(NuGetVersionFloatBehavior.AbsoluteLatest);
}
else
{
// released
floatRange = new FloatRange(NuGetVersionFloatBehavior.Major);
}
FloatRange fr = new FloatRange(NuGetVersionFloatBehavior.Major);
VersionRange range = new VersionRange(floatRange: fr);
package = await GetBestMatchPackageVersionsAsync(repository, packageId, range);
}
_downloadQueue.Enqueue(package);
}
// download counter
int download_counter = 0;
while (_downloadQueue.Count > 0)
{
PackageInfo package = _downloadQueue.Dequeue();
string validFileName = FileUtil.GetValidFileName(package.packageId);
string packageFilePath = $"{connectionDirectory}/{validFileName}.{package.packageVersion}.nupkg";
if (_cacheDownloadedFileName.Contains($"{package.packageId}-{package.packageVersion}"))
{
continue;
}
else
{
_cacheDownloadedFileName.Add($"{package.packageId}-{package.packageVersion}");
}
using FileStream packageStream = new FileStream(packageFilePath, FileMode.Create);
await resource.CopyNupkgToStreamAsync(
package.packageId,
package.packageVersion,
packageStream,
cache,
logger,
cancellationToken);
download_counter++;
// starting
if (download_counter == 1)
{
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"starting...");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
// check if send message is needed
if (download_counter % MessageFrequency == 0)
{
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"{download_counter}, {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f}%");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
Console.WriteLine($"Downloaded package {package.packageId} {package.packageVersion}");
using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken);
Console.WriteLine($"Tags: {nuspecReader.GetTags()}");
Console.WriteLine($"Description: {nuspecReader.GetDescription()}");
using PackageArchiveReader reader = new PackageArchiveReader(packageStream);
NuspecReader nuspec = reader.NuspecReader;
Console.WriteLine($"ID: {nuspec.GetId()}");
Console.WriteLine($"Version: {nuspec.GetVersion()}");
Console.WriteLine($"Description: {nuspec.GetDescription()}");
Console.WriteLine($"Authors: {nuspec.GetAuthors()}");
if (info.withDependency == false)
{
Console.WriteLine("\nDependencies download is not need.");
continue;
}
Console.WriteLine("\nStart download dependencies:");
foreach (var dependencyGroup in nuspec.GetDependencyGroups())
{
Console.WriteLine($" - {dependencyGroup.TargetFramework.GetFrameworkString()}");
// check target framework
if (!info.targetFramework.Contains("all", StringComparer.InvariantCultureIgnoreCase) &&
!info.targetFramework.Contains(dependencyGroup.TargetFramework.GetFrameworkString(), StringComparer.InvariantCultureIgnoreCase))
{
Console.WriteLine($" -- {dependencyGroup.TargetFramework.GetFrameworkString()} not match target framework.");
continue;
}
foreach (var dependency in dependencyGroup.Packages)
{
Console.WriteLine($" > {dependency.Id} {dependency.VersionRange}");
PackageInfo dependencyPackage = await GetBestMatchPackageVersionsAsync(repository, dependency.Id, dependency.VersionRange);
Console.WriteLine($" -- best match version: {dependency.Id} {dependencyPackage.packageVersion}");
_downloadQueue.Enqueue(dependencyPackage);
}
}
}
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"{download_counter}, {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f}%");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
string zipFileName = $"{_outputDirectory}/{connectionSubName}.zip";
bool result = _compressService.CompressDirectory(connectionDirectory, zipFileName);
if (result == true)
{
string readableSize = FileUtil.getFileHumanReadableSize(zipFileName);
// send message
response.payload.Clear();
response.payload.Add("CompressStatus", $"compressed ok, file sieze: {readableSize}.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
else
{
// send message
response.payload.Clear();
response.payload.Add("CompressStatus", $"compressed failed.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
// delete directory
Directory.Delete(connectionDirectory, true);
return(connectionSubName);
}
