protected virtual TMetadata ReadMetadata(IList <string> files, NuspecReader nuspecReader) => default;
/// <summary>
/// Apply filters from the references node in the nuspec.
/// </summary>
private static void ApplyReferenceFilter(LockFileTargetLibrary lockFileLib, NuGetFramework framework, NuspecReader nuspec)
{
if (lockFileLib.CompileTimeAssemblies.Count > 0 || lockFileLib.RuntimeAssemblies.Count > 0)
{
var referenceSet = nuspec.GetReferenceGroups().GetNearest(framework);
if (referenceSet != null)
{
var referenceFilter = new HashSet <string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase);
// Remove anything that starts with "lib/" and is NOT specified in the reference filter.
// runtimes/* is unaffected (it doesn't start with lib/)
lockFileLib.RuntimeAssemblies = lockFileLib.RuntimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList();
lockFileLib.CompileTimeAssemblies = lockFileLib.CompileTimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList();
}
}
}
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);
}
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));
}
}
}
IEnumerable <ExternalDependency> GetKestrelLibuvDependencies(FilePath path)
{
var packageDirectoryPath = path.ParentDirectory.ParentDirectory.ParentDirectory;
// Get all the available libuv's
var allPackagesPath = packageDirectoryPath.ParentDirectory.ParentDirectory;
var libuvPackagesPath = allPackagesPath.Combine("libuv");
var libuvVersions = libuvPackagesPath.EnumerateDirectories()
.Select(dir => NuGetVersion.Parse(dir.Name))
.ToArray();
// Read the transport's nuspec to find the best matching version of libuv
var nuspecPath = packageDirectoryPath.Combine(
"microsoft.aspnetcore.server.kestrel.transport.libuv.nuspec");
var nuspecData = new NuspecReader(nuspecPath);
var libuvDependencyVersion = nuspecData.GetDependencyGroups()
.SelectMany(dg => dg.Packages)
.Where(p => PackageIdComparer.Equals(p.Id, "Libuv"))
.Distinct(PackageIdComparer.Default)
.SingleOrDefault()
?.VersionRange
.FindBestMatch(libuvVersions);
var libuvPackagePath = libuvPackagesPath.Combine(libuvDependencyVersion.ToString());
var architecture = agentArchitecture.ToString().ToLowerInvariant();
var isMac = false;
switch (HostEnvironment.OS)
{
case HostOS.Windows:
break;
case HostOS.macOS:
isMac = true;
break;
default:
yield break;
}
string runtimeName, nativeLibName;
switch (AgentType)
{
case AgentType.WPF:
// We need the win7-<bitness> library here.
nativeLibName = "libuv.dll";
runtimeName = $"win-{architecture}";
break;
case AgentType.Console:
case AgentType.MacNet45:
case AgentType.MacMobile:
case AgentType.DotNetCore:
nativeLibName = isMac ? "libuv.dylib" : "libuv.dll";
runtimeName = isMac ? "osx" : $"win-{architecture}";
break;
default:
yield break;
}
var nativeLibraryPath = libuvPackagePath.Combine(
"runtimes",
runtimeName,
"native",
nativeLibName
);
if (nativeLibraryPath.FileExists)
{
yield return(new NativeDependency(nativeLibraryPath.Name, nativeLibraryPath));
}
}
private static void AddContentFiles(RestoreTargetGraph targetGraph, LockFileTargetLibrary lockFileLib, NuGetFramework framework, ContentItemCollection contentItems, NuspecReader nuspec)
{
// content v2 items
var contentFileGroups = contentItems.FindItemGroups(targetGraph.Conventions.Patterns.ContentFiles).ToList();
if (contentFileGroups.Count > 0)
{
// Multiple groups can match the same framework, find all of them
var contentFileGroupsForFramework = ContentFileUtils.GetContentGroupsForFramework(
lockFileLib,
framework,
contentFileGroups);
lockFileLib.ContentFiles = ContentFileUtils.GetContentFileGroup(
framework,
nuspec,
contentFileGroupsForFramework);
}
}
protected override RepositoryMetadata ReadMetadata(NuspecReader reader)
{
return(reader.GetRepositoryMetadata());
}
/// <summary>
/// Add framework references.
/// </summary>
private static void AddFrameworkReferences(LockFileTargetLibrary lockFileLib, NuGetFramework framework, NuspecReader nuspec)
{
// Exclude framework references for package based frameworks.
if (!framework.IsPackageBased)
{
var frameworkAssemblies = nuspec.GetFrameworkAssemblyGroups().GetNearest(framework);
if (frameworkAssemblies != null)
{
foreach (var assemblyReference in frameworkAssemblies.Items)
{
lockFileLib.FrameworkAssemblies.Add(assemblyReference);
}
}
}
// Related to: FrameworkReference item, added first in .NET Core 3.0
var frameworkRef = nuspec.GetFrameworkRefGroups().GetNearest(framework);
if (frameworkRef != null)
{
lockFileLib.FrameworkReferences.AddRange(frameworkRef.FrameworkReferences.Select(e => e.Name));
}
}
/// <summary>
/// Apply build actions from the nuspec to items from the contentFiles folder.
/// </summary>
internal static List <LockFileContentFile> GetContentFileGroup(
NuGetFramework framework,
NuspecReader nuspec,
List <ContentItemGroup> contentFileGroups)
{
var results = new List <LockFileContentFile>(contentFileGroups.Count);
var rootFolderPathLength = ContentFilesFolderName.Length;
// Read the contentFiles section of the nuspec
// Read the entries so that the bottom entry has priority
var nuspecContentFiles = nuspec.GetContentFiles().ToList();
// Initialize mappings
var entryMappings = new Dictionary <string, List <ContentFilesEntry> >(StringComparer.OrdinalIgnoreCase);
var languageMappings = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var group in contentFileGroups)
{
var codeLanguage = group.Properties[ManagedCodeConventions.PropertyNames.CodeLanguage] as string;
foreach (var item in group.Items)
{
if (!entryMappings.ContainsKey(item.Path))
{
entryMappings.Add(item.Path, new List <ContentFilesEntry>());
languageMappings.Add(item.Path, codeLanguage);
}
}
}
// Virtual root for file globbing
var rootDirectory = new VirtualFileInfo(VirtualFileProvider.RootDir, isDirectory: true);
// Apply all nuspec property mappings to the files returned by content model
foreach (var filesEntry in nuspecContentFiles)
{
// this is validated in the nuspec reader
Debug.Assert(filesEntry.Include != null, "invalid contentFiles entry");
// Create a filesystem matcher for globbing patterns
var matcher = new Matcher(StringComparison.OrdinalIgnoreCase);
matcher.AddInclude(filesEntry.Include);
if (filesEntry.Exclude != null)
{
matcher.AddExclude(filesEntry.Exclude);
}
// Check each file against the patterns
foreach (var file in entryMappings.Keys)
{
// Remove contentFiles/ from the string
Debug.Assert(file.StartsWith(ContentFilesFolderName, StringComparison.OrdinalIgnoreCase),
"invalid file path: " + file);
// All files should begin with the same root folder
if (file.Length > rootFolderPathLength)
{
var relativePath = file.Substring(rootFolderPathLength, file.Length - rootFolderPathLength);
// Check if the nuspec group include/exclude patterns apply to the file
var virtualDirectory = new VirtualFileProvider(new List <string>()
{
relativePath
});
var globbingDirectory = new FileProviderGlobbingDirectory(
virtualDirectory,
fileInfo: rootDirectory,
parent: null);
// Currently Matcher only returns the file name not the full path, each file must be
// check individually.
var matchResults = matcher.Execute(globbingDirectory);
if (matchResults.Files.Any())
{
entryMappings[file].Add(filesEntry);
}
}
}
}
// Create lock file entries for each item in the contentFiles folder
foreach (var file in entryMappings.Keys)
{
// defaults
var action = BuildAction.Parse(PackagingConstants.ContentFilesDefaultBuildAction);
var copyToOutput = false;
var flatten = false;
// _._ is needed for empty codeLanguage groups
if (file.EndsWith(PackagingCoreConstants.ForwardSlashEmptyFolder, StringComparison.Ordinal))
{
action = BuildAction.None;
}
else
{
// apply each entry
// entries may not have all the attributes, if a value is null
// ignore it and continue using the previous value.
foreach (var filesEntry in entryMappings[file])
{
if (!string.IsNullOrEmpty(filesEntry.BuildAction))
{
action = BuildAction.Parse(filesEntry.BuildAction);
}
if (filesEntry.CopyToOutput.HasValue)
{
copyToOutput = filesEntry.CopyToOutput.Value;
}
if (filesEntry.Flatten.HasValue)
{
flatten = filesEntry.Flatten.Value;
}
}
}
// Add attributes to the lock file item
var lockFileItem = new LockFileContentFile(file);
// Add the language from the directory path
lockFileItem.CodeLanguage = languageMappings[file].ToLowerInvariant();
if (!action.IsKnown)
{
// Throw an error containing the package identity, invalid action, and file where it occurred.
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_UnknownBuildAction, nuspec.GetIdentity(), action, file);
throw new PackagingException(message);
}
lockFileItem.BuildAction = action;
lockFileItem.CopyToOutput = copyToOutput;
// Check if this is a .pp transform. If the filename is ".pp" ignore it since it will
// have no file name after the transform.
var isPP = lockFileItem.Path.EndsWith(".pp", StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrEmpty(Path.GetFileNameWithoutExtension(lockFileItem.Path));
if (copyToOutput)
{
string destination = null;
if (flatten)
{
destination = Path.GetFileName(lockFileItem.Path);
}
else
{
// Find path relative to the TxM
// Ex: contentFiles/cs/net45/config/config.xml -> config/config.xml
destination = GetContentFileFolderRelativeToFramework(file);
}
if (isPP)
{
// Remove .pp from the output file path
destination = destination.Substring(0, destination.Length - 3);
}
lockFileItem.OutputPath = destination;
}
// Add the pp transform file if one exists
if (isPP)
{
var destination = lockFileItem.Path.Substring(0, lockFileItem.Path.Length - 3);
destination = GetContentFileFolderRelativeToFramework(destination);
lockFileItem.PPOutputPath = destination;
}
results.Add(lockFileItem);
}
return(results);
}
public static async Task Main(string packageId, string packageVersion)
{
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
NuGetVersion version = new NuGetVersion(packageVersion);
using MemoryStream packageStream = new MemoryStream();
var copied = await resource.CopyNupkgToStreamAsync(
packageId,
version,
packageStream,
cache,
logger,
cancellationToken);
if (!copied)
{
Console.WriteLine("Could not find package");
return;
}
Console.WriteLine($"Downloaded package {packageId} {packageVersion}");
using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken);
var ctx = new AnalysisContext
{
PackageStream = packageStream,
PackageReader = packageReader,
PackageFiles = new HashSet <string>(
packageReader.GetFiles(),
StringComparer.OrdinalIgnoreCase),
NuspecReader = nuspecReader,
Messages = new List <string>(),
};
// TODO: NuGet client validations
// TODO: Check nupkg is well formed?
new HasXmlDocs().Run(ctx);
new StablePackageHasStableDependencies().Run(ctx);
new HasValidLicense().Run(ctx);
await new HasSymbols().RunAsync(ctx, cancellationToken);
foreach (var message in ctx.Messages)
{
Console.WriteLine(message);
}
if (!ctx.Messages.Any())
{
Console.WriteLine("No messages!");
}
}
private static void AddContentFiles(ManagedCodeConventions managedCodeConventions, LockFileTargetLibrary lockFileLib, NuGetFramework framework, ContentItemCollection contentItems, NuspecReader nuspec)
{
// content v2 items
List <ContentItemGroup> contentFileGroups = new();
contentItems.PopulateItemGroups(managedCodeConventions.Patterns.ContentFiles, contentFileGroups);
if (contentFileGroups.Count > 0)
{
// Multiple groups can match the same framework, find all of them
var contentFileGroupsForFramework = ContentFileUtils.GetContentGroupsForFramework(
framework,
contentFileGroups);
lockFileLib.ContentFiles = ContentFileUtils.GetContentFileGroup(
nuspec,
contentFileGroupsForFramework);
}
}
private IEnumerable <LibraryDependency> GetDependencies(LocalPackageInfo package, NuGetFramework targetFramework)
{
NuspecReader nuspecReader = null;
using (var stream = File.OpenRead(package.ManifestPath))
{
nuspecReader = new NuspecReader(stream);
}
var reducer = new FrameworkReducer();
var deps = nuspecReader.GetDependencyGroups()
.ToDictionary(g => new NuGetFramework(g.TargetFramework),
g => g.Packages);
var nearest = reducer.GetNearest(targetFramework, deps.Keys);
if (nearest != null)
{
foreach (var d in deps[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange == null ? null : new NuGetVersionRange(d.VersionRange)
}
});
}
}
// TODO: Remove this when we do #596
// ASP.NET Core isn't compatible with generic PCL profiles
//if (string.Equals(targetFramework.Identifier, VersionUtility.AspNetCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase))
//{
// yield break;
//}
var frameworks = nuspecReader.GetFrameworkReferenceGroups()
.ToDictionary(f => f.TargetFramework,
f => f.Items);
nearest = reducer.GetNearest(targetFramework, frameworks.Keys) ?? frameworks.Keys.FirstOrDefault(f => f.AnyPlatform);
if (nearest != null)
{
if (nearest.AnyPlatform && !targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
yield break;
}
foreach (var name in frameworks[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
IsGacOrFrameworkReference = true
}
});
}
}
}
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);
}
private static (Uri repositoryUrl, string repositoryType) GetRepositoryMetadata(NuspecReader nuspec)
{
var repository = nuspec.GetRepositoryMetadata();
if (string.IsNullOrEmpty(repository?.Url) ||
!Uri.TryCreate(repository.Url, UriKind.Absolute, out var repositoryUri))
{
return(null, null);
}
if (repositoryUri.Scheme != Uri.UriSchemeHttps)
{
return(null, null);
}
if (repository.Type.Length > 100)
{
throw new InvalidOperationException("Repository type must be less than or equal 100 characters");
}
return(repositoryUri, repository.Type);
}
/// <summary>
/// Create a PackageDetails page that contains all the package information.
/// </summary>
public JObject CreatePackageDetails(PackageInput packageInput)
{
var now = DateTimeOffset.UtcNow;
var package = packageInput.Package;
var nuspec = XDocument.Load(package.GetNuspec());
var nuspecReader = new NuspecReader(nuspec);
var pageId = Guid.NewGuid().ToString().ToLowerInvariant();
var rootUri = UriUtility.CreateUri($"{_context.Source.BaseURI}catalog/data/{pageId}.json");
packageInput.PackageDetailsUri = rootUri;
var json = JsonUtility.Create(rootUri, new List <string>()
{
"PackageDetails", "catalog:Permalink"
});
json.Add("commitId", _context.CommitId.ToString().ToLowerInvariant());
json.Add("commitTimeStamp", DateTimeOffset.UtcNow.GetDateString());
json.Add("sleet:operation", "add");
var context = JsonUtility.GetContext("Catalog");
json.Add("@context", context);
json.Add("id", packageInput.Identity.Id);
json.Add("version", packageInput.Identity.Version.ToFullVersionString());
json.Add("created", now.GetDateString());
json.Add("lastEdited", "0001-01-01T00:00:00Z");
var copyProperties = new List <string>()
{
"authors",
"copyright",
"description",
"iconUrl",
"projectUrl",
"licenseUrl",
"language",
"summary",
"owners",
"releaseNotes"
};
foreach (var propertyName in copyProperties)
{
json.Add(CreateProperty(propertyName, propertyName, nuspecReader));
}
json.Add("isPrerelease", packageInput.Identity.Version.IsPrerelease);
// Unused?
json.Add("licenseNames", string.Empty);
json.Add("licenseReportUrl", string.Empty);
// All packages are listed
json.Add("listed", true);
var titleValue = GetEntry(nuspecReader, "title");
if (!string.IsNullOrEmpty(titleValue))
{
json.Add("title", titleValue);
}
using (var stream = File.OpenRead(packageInput.PackagePath))
{
using (var sha512 = SHA512.Create())
{
var packageHash = Convert.ToBase64String(sha512.ComputeHash(stream));
json.Add("packageHash", packageHash);
json.Add("packageHashAlgorithm", "SHA512");
}
json.Add("packageSize", stream.Length);
}
json.Add("published", now.GetDateString());
json.Add("requireLicenseAcceptance", GetEntry(nuspecReader, "requireLicenseAcceptance").Equals("true", StringComparison.OrdinalIgnoreCase));
var minVersion = nuspecReader.GetMinClientVersion();
if (minVersion != null)
{
json.Add("minClientVersion", minVersion.ToIdentityString());
}
// Tags
var tagSet = new HashSet <string>(GetEntry(nuspecReader, "tags").Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries), StringComparer.OrdinalIgnoreCase);
tagSet.Remove(string.Empty);
var tagArray = new JArray(tagSet);
json.Add("tags", tagArray);
// Framework assemblies
var fwrGroups = nuspecReader.GetFrameworkReferenceGroups();
var fwrArray = new JArray();
json.Add("frameworkAssemblyGroup", fwrArray);
foreach (var group in fwrGroups.OrderBy(e => e.TargetFramework.GetShortFolderName(), StringComparer.OrdinalIgnoreCase))
{
var groupTFM = group.TargetFramework.GetShortFolderName().ToLowerInvariant();
var groupNode = JsonUtility.Create(rootUri, $"frameworkassemblygroup/{groupTFM}".ToLowerInvariant(), "FrameworkAssemblyGroup");
// Leave the framework property out for the 'any' group
if (!group.TargetFramework.IsAny)
{
groupNode.Add("targetFramework", groupTFM);
}
fwrArray.Add(groupNode);
if (group.Items.Any())
{
var assemblyArray = new JArray();
groupNode.Add("assembly", assemblyArray);
foreach (var fwAssembly in group.Items.Distinct().OrderBy(e => e, StringComparer.OrdinalIgnoreCase))
{
assemblyArray.Add(fwAssembly);
}
}
}
// Dependencies
var dependencyGroups = nuspecReader.GetDependencyGroups();
var depArray = new JArray();
json.Add("dependencyGroups", depArray);
foreach (var group in dependencyGroups.OrderBy(e => e.TargetFramework.GetShortFolderName(), StringComparer.OrdinalIgnoreCase))
{
var groupTFM = group.TargetFramework.GetShortFolderName().ToLowerInvariant();
var groupNode = JsonUtility.Create(rootUri, $"dependencygroup/{groupTFM}".ToLowerInvariant(), "PackageDependencyGroup");
// Leave the framework property out for the 'any' group
if (!group.TargetFramework.IsAny)
{
groupNode.Add("targetFramework", groupTFM);
}
depArray.Add(groupNode);
if (group.Packages.Any())
{
var packageArray = new JArray();
groupNode.Add("dependencies", packageArray);
foreach (var depPackage in group.Packages.Distinct().OrderBy(e => e.Id, StringComparer.OrdinalIgnoreCase))
{
var packageNode = JsonUtility.Create(rootUri, $"dependencygroup/{groupTFM}/{depPackage.Id}".ToLowerInvariant(), "PackageDependency");
packageNode.Add("id", depPackage.Id);
packageNode.Add("range", depPackage.VersionRange.ToNormalizedString());
packageArray.Add(packageNode);
}
}
}
json.Add("packageContent", packageInput.NupkgUri.AbsoluteUri);
// add flatcontainer files
var packageEntriesArray = new JArray();
json.Add("packageEntries", packageEntriesArray);
var packageEntryIndex = 0;
foreach (var entry in packageInput.Zip.Entries.OrderBy(e => e.FullName, StringComparer.OrdinalIgnoreCase))
{
var fileEntry = JsonUtility.Create(rootUri, $"packageEntry/{packageEntryIndex}", "packageEntry");
fileEntry.Add("fullName", entry.FullName);
fileEntry.Add("length", entry.Length);
fileEntry.Add("lastWriteTime", entry.LastWriteTime.GetDateString());
packageEntriesArray.Add(fileEntry);
packageEntryIndex++;
}
json.Add("sleet:toolVersion", Constants.SleetVersion.ToFullVersionString());
return(JsonLDTokenComparer.Format(json));
}
private static void Run(CommandLineApplication cmd, ILogger log)
{
cmd.Description = "Add framework assemblies to the nuspec file for desktop frameworks.";
var idFilter = cmd.Option(Constants.IdFilterTemplate, Constants.IdFilterDesc, CommandOptionType.SingleValue);
var versionFilter = cmd.Option(Constants.VersionFilterTemplate, Constants.VersionFilterDesc, CommandOptionType.SingleValue);
var excludeSymbolsFilter = cmd.Option(Constants.ExcludeSymbolsTemplate, Constants.ExcludeSymbolsDesc, CommandOptionType.NoValue);
var highestVersionFilter = cmd.Option(Constants.HighestVersionFilterTemplate, Constants.HighestVersionFilterDesc, CommandOptionType.NoValue);
var assemblyNames = cmd.Option("-n|--assembly-name", "AssemblyName value of the FrameworkAssembly entry. May be specified multiple times.", CommandOptionType.MultipleValue);
var targetFrameworks = cmd.Option("-f|--framework", "TargetFramework value of the FrameworkAssembly entry. If no frameworks are given this command will automatically add the reference for all desktop frameworks. Framework may be specified multiple time.", CommandOptionType.MultipleValue);
var noFrameworks = cmd.Option("--no-frameworks", "Exclude the TargetFramework attribute.", CommandOptionType.NoValue);
var argRoot = cmd.Argument(
"[root]",
Constants.MultiplePackagesRootDesc,
multipleValues: true);
cmd.HelpOption(Constants.HelpOption);
cmd.OnExecute(() =>
{
try
{
// Validate required parameters
CmdUtils.VerifyRequiredOptions(assemblyNames);
CmdUtils.VerifyMutallyExclusiveOptions(targetFrameworks, noFrameworks);
var inputs = argRoot.Values;
if (inputs.Count < 1)
{
inputs.Add(Directory.GetCurrentDirectory());
}
var packages = Util.GetPackagesWithFilter(idFilter, versionFilter, excludeSymbolsFilter, highestVersionFilter, inputs.ToArray());
foreach (var package in packages)
{
log.LogMinimal($"modifying {package}");
// Get nuspec file path
string nuspecPath = null;
XDocument nuspecXml = null;
NuspecReader nuspecReader = null;
var packageFrameworks = new List <NuGetFramework>();
using (var stream = File.OpenRead(package))
using (var packageReader = new PackageArchiveReader(stream, leaveStreamOpen: false))
{
nuspecPath = packageReader.GetNuspecFile();
nuspecXml = XDocument.Load(packageReader.GetNuspec());
nuspecReader = packageReader.NuspecReader;
packageFrameworks.AddRange(packageReader.GetSupportedFrameworks().Where(e => e.IsSpecificFramework));
}
var frameworks = new HashSet <NuGetFramework>();
if (!noFrameworks.HasValue())
{
if (targetFrameworks.HasValue())
{
// Validate user input
ValidateTargetFrameworkInputs(targetFrameworks.Values);
// Add user input frameworks
frameworks.AddRange(targetFrameworks.Values.Select(e => NuGetFramework.Parse(e)));
}
else
{
frameworks.AddRange(packageFrameworks);
}
}
// Remove unknown frameworks and package based frameworks.
frameworks.RemoveWhere(e => !e.IsSpecificFramework || e.IsPackageBased);
var assemblyNamesUnique = new HashSet <string>(assemblyNames.Values, StringComparer.OrdinalIgnoreCase);
log.LogMinimal($"Adding framework assemblies: {string.Join(", ", assemblyNamesUnique)}");
// Modify nuspec
Util.AddFrameworkAssemblyReferences(nuspecXml, assemblyNamesUnique, frameworks);
// Update zip
Util.AddOrReplaceZipEntry(package, nuspecPath, nuspecXml, log);
}
return(0);
}
catch (Exception ex)
{
log.LogError(ex.Message);
log.LogDebug(ex.ToString());
}
return(1);
});
}
/// <summary>
/// Get the view of installed packages. Use for Get-Package command.
/// </summary>
internal static List <PowerShellInstalledPackage> GetPowerShellPackageView(
Dictionary <NuGetProject, IEnumerable <PackageReference> > dictionary,
ISolutionManager SolutionManager,
Configuration.ISettings settings)
{
var views = new List <PowerShellInstalledPackage>();
foreach (var entry in dictionary)
{
var nugetProject = entry.Key;
var projectName = entry.Key.GetMetadata <string>(NuGetProjectMetadataKeys.Name);
FolderNuGetProject packageFolderProject = null;
FallbackPackagePathResolver fallbackResolver = null;
// Build a project-specific strategy for resolving a package .nupkg path.
if (nugetProject is INuGetIntegratedProject) // This is technically incorrect for DNX projects,
// however since that experience is deprecated we don't
// care.
{
var pathContext = NuGetPathContext.Create(settings);
fallbackResolver = new FallbackPackagePathResolver(pathContext);
}
else
{
var project = nugetProject as MSBuildNuGetProject;
if (project != null)
{
packageFolderProject = project.FolderNuGetProject;
}
}
// entry.Value is an empty list if no packages are installed.
foreach (var package in entry.Value)
{
string installPackagePath = null;
string licenseUrl = null;
// Try to get the path to the package .nupkg on disk.
if (fallbackResolver != null)
{
var packageInfo = fallbackResolver.GetPackageInfo(
package.PackageIdentity.Id,
package.PackageIdentity.Version);
installPackagePath = packageInfo?.PathResolver.GetPackageFilePath(
package.PackageIdentity.Id,
package.PackageIdentity.Version);
}
else if (packageFolderProject != null)
{
installPackagePath = packageFolderProject.GetInstalledPackageFilePath(package.PackageIdentity);
}
// Try to read out the license URL.
using (var reader = GetPackageReader(installPackagePath))
using (var nuspecStream = reader?.GetNuspec())
{
if (nuspecStream != null)
{
var nuspecReader = new NuspecReader(nuspecStream);
licenseUrl = nuspecReader.GetLicenseUrl();
}
}
var view = new PowerShellInstalledPackage
{
Id = package.PackageIdentity.Id,
AsyncLazyVersions = new AsyncLazy <IEnumerable <NuGetVersion> >(
() => Task.FromResult <IEnumerable <NuGetVersion> >(new[] { package.PackageIdentity.Version }),
NuGetUIThreadHelper.JoinableTaskFactory),
ProjectName = projectName,
LicenseUrl = licenseUrl
};
views.Add(view);
}
}
return(views);
}
private static JProperty CreateProperty(string catalogName, string nuspecName, NuspecReader nuspec)
{
var value = GetEntry(nuspec, nuspecName);
return(new JProperty(catalogName, value));
}
private async Task <bool?> CheckPackageExistsAsync(
FileInfo nugetPackage,
string nugetExePath,
ILogger logger,
string sourceName)
{
if (!File.Exists(nugetPackage.FullName))
{
logger.WriteError(
$"The NuGet package '{nugetPackage}' does not exist");
return(null);
}
logger.WriteDebug($"Searching for existing NuGet package '{nugetPackage}'");
string packageVersion;
string packageId;
using (var fs = new FileStream(nugetPackage.FullName, FileMode.Open, FileAccess.Read))
{
using (var archive = new ZipArchive(fs))
{
ZipArchiveEntry nuspecEntry =
archive.Entries.SingleOrDefault(
entry =>
Path.GetExtension(entry.Name)
.Equals(".nuspec", StringComparison.InvariantCultureIgnoreCase));
if (nuspecEntry == null)
{
throw new InvalidOperationException("The nuget package does not contain any nuspec");
}
var nuspecReader = new NuspecReader(nuspecEntry.Open());
NuGetVersion nuGetVersion = nuspecReader.GetVersion();
packageVersion = nuGetVersion.ToNormalizedString();
packageId = nuspecReader.GetIdentity().Id;
}
}
SemanticVersion expectedVersion = SemanticVersion.Parse(packageVersion);
var packageInfo = new { Id = packageId, Version = expectedVersion };
var args = new List <string>
{
"list",
packageId
};
if (!string.IsNullOrWhiteSpace(sourceName))
{
logger.WriteVerbose($"Using specific source name '{sourceName}'");
args.Add("-source");
args.Add(sourceName);
}
args.Add("-verbosity");
args.Add("normal");
if (packageInfo.Version.IsPrerelease)
{
logger.WriteVerbose($"Package '{nugetPackage.Name}' is pre-release");
args.Add("-prerelease");
}
var errorBuilder = new StringBuilder();
var standardBuilder = new List <string>();
string expectedNameAndVersion = $"{packageInfo.Id} {expectedVersion.ToNormalizedString()}";
logger.Write($"Looking for '{expectedNameAndVersion}' package");
ExitCode exitCode =
await
ProcessRunner.ExecuteAsync(
nugetExePath,
arguments : args,
standardOutLog :
(message, prefix) =>
{
standardBuilder.Add(message);
logger.Write(message, prefix);
},
standardErrorAction : (message, prefix) =>
{
errorBuilder.AppendLine(message);
logger.WriteError(message, prefix);
},
toolAction : logger.Write,
addProcessNameAsLogCategory : true,
addProcessRunnerCategory : true);
if (!exitCode.IsSuccess)
{
logger.WriteError($"Could not execute process to check if package '{expectedNameAndVersion}' exists");
return(null);
}
bool foundSpecificPackage = standardBuilder.Any(
line => line.Equals(expectedNameAndVersion, StringComparison.InvariantCultureIgnoreCase));
if (foundSpecificPackage)
{
logger.Write($"Found existing package id '{expectedNameAndVersion}'");
}
else
{
logger.Write($"Could not find existing package id '{expectedNameAndVersion}'");
}
return(foundSpecificPackage);
}
/// <summary>
/// Populate assets for a <see cref="LockFileLibrary"/>.
/// </summary>
private static void AddAssets(
string aliases,
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType,
LockFileTargetLibrary lockFileLib,
NuGetFramework framework,
string runtimeIdentifier,
ContentItemCollection contentItems,
NuspecReader nuspec,
IReadOnlyList <SelectionCriteria> orderedCriteria,
MaccatalystFallback maccatalystFallback)
{
// Add framework references for desktop projects.
AddFrameworkReferences(lockFileLib, framework, nuspec);
// Compile
// Set-up action to update the compile time items.
Action <LockFileItem> applyAliases = (item) => ApplyAliases(aliases, item);
// ref takes precedence over lib
var compileGroup = GetLockFileItems(
orderedCriteria,
contentItems,
applyAliases,
maccatalystFallback,
targetGraph.Conventions.Patterns.CompileRefAssemblies,
targetGraph.Conventions.Patterns.CompileLibAssemblies);
lockFileLib.CompileTimeAssemblies.AddRange(compileGroup);
// Runtime
var runtimeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
maccatalystFallback,
targetGraph.Conventions.Patterns.RuntimeAssemblies);
lockFileLib.RuntimeAssemblies.AddRange(runtimeGroup);
// Embed
var embedGroup = GetLockFileItems(
orderedCriteria,
contentItems,
maccatalystFallback,
targetGraph.Conventions.Patterns.EmbedAssemblies);
lockFileLib.EmbedAssemblies.AddRange(embedGroup);
// Resources
var resourceGroup = GetLockFileItems(
orderedCriteria,
contentItems,
maccatalystFallback,
targetGraph.Conventions.Patterns.ResourceAssemblies);
lockFileLib.ResourceAssemblies.AddRange(resourceGroup);
// Native
var nativeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
maccatalystFallback,
targetGraph.Conventions.Patterns.NativeLibraries);
lockFileLib.NativeLibraries.AddRange(nativeGroup);
// Add MSBuild files
AddMSBuildAssets(library, targetGraph, lockFileLib, orderedCriteria, contentItems, maccatalystFallback);
// Add content files
AddContentFiles(targetGraph, lockFileLib, framework, contentItems, nuspec, maccatalystFallback);
// Runtime targets
// These are applied only to non-RID target graphs.
// They are not used for compatibility checks.
AddRuntimeTargets(targetGraph, dependencyType, lockFileLib, framework, runtimeIdentifier, contentItems, maccatalystFallback);
// COMPAT: Support lib/contract so older packages can be consumed
ApplyLibContract(package, lockFileLib, framework, contentItems);
// Apply filters from the <references> node in the nuspec
ApplyReferenceFilter(lockFileLib, framework, nuspec);
}
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))
{
// Audit that a non-owner tried to push the package
await AuditingService.SaveAuditRecord(
new FailedAuthenticatedOperationAuditRecord(
user.Username,
AuditedAuthenticatedOperationAction.PackagePushAttemptByNonOwner,
attemptedPackage : new AuditedPackageIdentifier(
nuspec.GetId(), nuspec.GetVersion().ToNormalizedStringSafe())));
// User can not push this package
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);
}
// Write an audit record
await AuditingService.SaveAuditRecord(
new PackageAuditRecord(package, AuditedPackageAction.Create, PackageCreatedVia.Api));
// Notify user of push
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 static LibraryDependency GenerateLibraryDependency(
PackageSpec project,
PackageReferenceArgs packageReferenceArgs,
RestoreResultPair restorePreviewResult,
IEnumerable <NuGetFramework> userSpecifiedFrameworks,
PackageDependency packageDependency)
{
// get the package resolved version from restore preview result
var resolvedVersion = GetPackageVersionFromRestoreResult(restorePreviewResult, packageReferenceArgs, userSpecifiedFrameworks);
// correct package version to write in project file
var version = packageDependency.VersionRange;
// update default packages path if user specified custom package directory
var packagesPath = project.RestoreMetadata.PackagesPath;
if (!string.IsNullOrEmpty(packageReferenceArgs.PackageDirectory))
{
packagesPath = packageReferenceArgs.PackageDirectory;
}
// create a path resolver to get nuspec file of the package
var pathResolver = new FallbackPackagePathResolver(
packagesPath,
project.RestoreMetadata.FallbackFolders);
var info = pathResolver.GetPackageInfo(packageReferenceArgs.PackageId, resolvedVersion);
var packageDirectory = info?.PathResolver.GetInstallPath(packageReferenceArgs.PackageId, resolvedVersion);
var nuspecFile = info?.PathResolver.GetManifestFileName(packageReferenceArgs.PackageId, resolvedVersion);
var nuspecFilePath = Path.GetFullPath(Path.Combine(packageDirectory, nuspecFile));
// read development dependency from nuspec file
var developmentDependency = new NuspecReader(nuspecFilePath).GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in project.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(
dep => dep.Name.Equals(packageReferenceArgs.PackageId, StringComparison.OrdinalIgnoreCase));
// if suppressParent and IncludeType aren't set by user, then only update those as per dev dependency
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Compile;
}
if (dependency != null)
{
dependency.LibraryRange.VersionRange = version;
return(dependency);
}
}
}
return(new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageId,
versionRange: version,
typeConstraint: LibraryDependencyTarget.Package)
});
}
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);
}
/// <summary>
/// Populate assets for a <see cref="LockFileLibrary"/>.
/// </summary>
private static void AddAssets(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType,
LockFileTargetLibrary lockFileLib,
NuGetFramework framework,
string runtimeIdentifier,
IList <string> files,
ContentItemCollection contentItems,
NuspecReader nuspec,
IReadOnlyList <SelectionCriteria> orderedCriteria)
{
// Add framework references for desktop projects.
AddFrameworkReferences(lockFileLib, framework, nuspec);
// Compile
// ref takes precedence over lib
var compileGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.CompileRefAssemblies,
targetGraph.Conventions.Patterns.CompileLibAssemblies);
lockFileLib.CompileTimeAssemblies.AddRange(compileGroup);
// Runtime
var runtimeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.RuntimeAssemblies);
lockFileLib.RuntimeAssemblies.AddRange(runtimeGroup);
// Resources
var resourceGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.ResourceAssemblies);
lockFileLib.ResourceAssemblies.AddRange(resourceGroup);
// Native
var nativeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.NativeLibraries);
lockFileLib.NativeLibraries.AddRange(nativeGroup);
// Build
var buildGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.MSBuildFiles);
lockFileLib.Build.AddRange(GetBuildItemsForPackageId(buildGroup, library.Name));
// Build multi targeting
var buildMultiTargetingGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.MSBuildMultiTargetingFiles);
lockFileLib.BuildMultiTargeting.AddRange(GetBuildItemsForPackageId(buildMultiTargetingGroup, library.Name));
// Add content files
AddContentFiles(targetGraph, lockFileLib, framework, contentItems, nuspec);
// Runtime targets
// These are applied only to non-RID target graphs.
// They are not used for compatibility checks.
AddRuntimeTargets(targetGraph, dependencyType, lockFileLib, framework, runtimeIdentifier, contentItems);
// COMPAT: Support lib/contract so older packages can be consumed
ApplyLibContract(package, lockFileLib, framework, files);
// Apply filters from the <references> node in the nuspec
ApplyReferenceFilter(lockFileLib, framework, nuspec);
}
/// <summary>
/// Gets package metadata from a the provided <see cref="NuspecReader"/> instance.
/// </summary>
/// <param name="nuspecReader">The <see cref="NuspecReader"/> instance used to read the <see cref="PackageMetadata"/></param>
/// <param name="strict">
/// Whether or not to be strict when reading the <see cref="NuspecReader"/>. This should be <code>true</code>
/// on initial ingestion but false when a package that has already been accepted is being processed.</param>
/// <exception cref="PackagingException">
/// We default to use a strict version-check on dependency groups.
/// When an invalid dependency version range is detected, a <see cref="PackagingException"/> will be thrown.
/// </exception>
public static PackageMetadata FromNuspecReader(NuspecReader nuspecReader, bool strict)
{
var strictNuspecReader = new StrictNuspecReader(nuspecReader.Xml);
var metadataLookup = strictNuspecReader.GetMetadataLookup();
if (strict)
{
var duplicates = metadataLookup
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
if (duplicates.Any())
{
throw new PackagingException(string.Format(
CoreStrings.Manifest_DuplicateMetadataElements,
string.Join("', '", duplicates)));
}
}
// Reject invalid metadata element names. Today this only rejects element names that collide with
// properties generated downstream.
var metadataKeys = new HashSet <string>(metadataLookup.Select(g => g.Key));
metadataKeys.IntersectWith(RestrictedMetadataElements);
if (metadataKeys.Any())
{
throw new PackagingException(string.Format(
CoreStrings.Manifest_InvalidMetadataElements,
string.Join("', '", metadataKeys.OrderBy(x => x))));
}
// Reject non-boolean values for boolean metadata.
foreach (var booleanName in BooleanMetadataElements)
{
foreach (var unparsedBoolean in metadataLookup[booleanName])
{
if (!bool.TryParse(unparsedBoolean, out var parsedBoolean))
{
throw new PackagingException(string.Format(
CoreStrings.Manifest_InvalidBooleanMetadata,
booleanName));
}
}
}
// Reject invalid package types.
foreach (var packageType in nuspecReader.GetPackageTypes())
{
if (!NuGet.Packaging.PackageIdValidator.IsValidPackageId(packageType.Name))
{
throw new PackagingException(string.Format(
CoreStrings.Manifest_InvalidPackageTypeName,
packageType.Name));
}
}
return(new PackageMetadata(
nuspecReader.GetMetadata().ToDictionary(kvp => kvp.Key, kvp => kvp.Value),
nuspecReader.GetDependencyGroups(useStrictVersionCheck: strict),
nuspecReader.GetFrameworkReferenceGroups(),
nuspecReader.GetPackageTypes(),
nuspecReader.GetMinClientVersion(),
nuspecReader.GetRepositoryMetadata(),
nuspecReader.GetLicenseMetadata()));
}
/// <summary>
/// Add framework references.
/// </summary>
private static void AddFrameworkReferences(LockFileTargetLibrary lockFileLib, NuGetFramework framework, NuspecReader nuspec)
{
// Exclude framework references for package based frameworks.
if (!framework.IsPackageBased)
{
var frameworkAssemblies = nuspec.GetFrameworkReferenceGroups().GetNearest(framework);
if (frameworkAssemblies != null)
{
foreach (var assemblyReference in frameworkAssemblies.Items)
{
lockFileLib.FrameworkAssemblies.Add(assemblyReference);
}
}
}
}
/// <summary>
/// Get the view of installed packages. Use for Get-Package command.
/// </summary>
internal static List <PowerShellInstalledPackage> GetPowerShellPackageView(Dictionary <NuGetProject, IEnumerable <Packaging.PackageReference> > dictionary,
ISolutionManager SolutionManager, Configuration.ISettings settings)
{
var views = new List <PowerShellInstalledPackage>();
foreach (var entry in dictionary)
{
var nugetProject = entry.Key;
string packageFolder = null;
FolderNuGetProject packageFolderProject = null;
if (nugetProject is BuildIntegratedNuGetProject)
{
packageFolder = BuildIntegratedProjectUtility.GetEffectiveGlobalPackagesFolder(SolutionManager.SolutionDirectory, settings);
}
else
{
var project = nugetProject as MSBuildNuGetProject;
if (project != null)
{
packageFolderProject = project.FolderNuGetProject;
}
}
// entry.Value is an empty list if no packages are installed
foreach (var package in entry.Value)
{
string installPackagePath = null;
string licenseUrl = null;
if (packageFolder != null)
{
var defaultPackagePathResolver = new VersionFolderPathResolver(packageFolder, normalizePackageId: false);
installPackagePath = defaultPackagePathResolver.GetPackageFilePath(package.PackageIdentity.Id, package.PackageIdentity.Version);
}
else if (packageFolderProject != null)
{
installPackagePath = packageFolderProject.GetInstalledPackageFilePath(package.PackageIdentity);
}
using (var reader = GetPackageReader(installPackagePath))
{
var nuspecReader = new NuspecReader(reader.GetNuspec());
licenseUrl = nuspecReader.GetLicenseUrl();
}
var view = new PowerShellInstalledPackage()
{
Id = package.PackageIdentity.Id,
AsyncLazyVersions = new AsyncLazy <IEnumerable <NuGetVersion> >(() => Task.FromResult <IEnumerable <NuGetVersion> >(new[] { package.PackageIdentity.Version }), NuGetUIThreadHelper.JoinableTaskFactory),
ProjectName = entry.Key.GetMetadata <string>(NuGetProjectMetadataKeys.Name),
LicenseUrl = licenseUrl
};
views.Add(view);
}
}
return(views);
}
private static void AddDependencies(IEnumerable <LibraryDependency> dependencies, LockFileTargetLibrary lockFileLib, NuGetFramework framework, NuspecReader nuspec)
{
if (dependencies == null)
{
// AssetFallbackFramework does not apply to dependencies.
// Convert it to a fallback framework if needed.
var currentFramework = (framework as AssetTargetFallbackFramework)?.AsFallbackFramework() ?? framework;
var dependencySet = nuspec
.GetDependencyGroups()
.GetNearest(currentFramework);
if (dependencySet != null)
{
var set = dependencySet.Packages;
if (set != null)
{
lockFileLib.Dependencies = set.AsList();
}
}
}
else
{
// Filter the dependency set down to packages and projects.
// Framework references will not be displayed
lockFileLib.Dependencies = dependencies
.Where(ld => ld.LibraryRange.TypeConstraintAllowsAnyOf(LibraryDependencyTarget.PackageProjectExternal))
.Select(ld => new PackageDependency(ld.Name, ld.LibraryRange.VersionRange))
.ToList();
}
}
public LocalPackageSearchMetadata(LocalPackageInfo package)
{
_package = package ?? throw new ArgumentNullException(nameof(package));
_nuspec = package.Nuspec;
}
public static NuGetPackageId GetPackageId(string folderPath)
{
NuspecReader reader = GetNuspec(folderPath);
return(CreateIdentity(reader, folderPath));
}
protected virtual TMetadata ReadMetadata(NuspecReader reader) => default;
