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