private static ManifestMetadata ReadMetadata(XElement xElement)
{
var manifestMetadata = new ManifestMetadata();
manifestMetadata.MinClientVersionString = (string)xElement.Attribute("minClientVersion");
// we store all child elements under <metadata> so that we can easily check for required elements.
var allElements = new HashSet <string>();
foreach (var element in xElement.Elements())
{
ReadMetadataValue(manifestMetadata, element, allElements);
}
manifestMetadata.PackageTypes = NuspecUtility.GetPackageTypes(xElement, useMetadataNamespace: false);
// now check for required elements, which include <id>, <version>, <authors> and <description>
foreach (var requiredElement in RequiredElements)
{
if (!allElements.Contains(requiredElement))
{
throw new InvalidDataException(
String.Format(CultureInfo.CurrentCulture, NuGetResources.Manifest_RequiredElementMissing, requiredElement));
}
}
return(manifestMetadata);
}
public async Task ExecuteAsync(CancellationToken token)
{
await ShowMatchedStringCounts(
PackageQueryNames.FindCaseSensitiveDuplicateMetadataElementsNuspecQuery,
(package, nuspec) => NuspecUtility.GetDuplicateMetadataElements(nuspec, caseSensitive : true).Keys);
await ShowMatchedStringCounts(
PackageQueryNames.FindCaseInsensitiveDuplicateMetadataElementsNuspecQuery,
(package, nuspec) => NuspecUtility.GetDuplicateMetadataElements(nuspec, caseSensitive : false).Keys);
await ShowMatchedStringCounts(
PackageQueryNames.FindNonAlphabetMetadataElementsNuspecQuery,
(package, nuspec) => NuspecUtility.GetNonAlphabetMetadataElements(nuspec));
}
public async Task ExecuteAsync(CancellationToken token)
{
await ShowMatchedStringCounts(
PackageQueryNames.FindMixedDependencyGroupStylesNuspecQuery,
(package, nuspec) =>
{
if (NuspecUtility.HasMixedDependencyGroupStyles(nuspec))
{
return(new[] { package.Identity });
}
else
{
return(new string[0]);
}
});
await ShowMatchedStringCounts(
PackageQueryNames.FindInvalidDependencyVersionsNuspecQuery,
(package, nuspec) => NuspecUtility.GetInvalidDependencyVersions(nuspec));
await ShowMatchedStringCounts(
PackageQueryNames.FindWhitespaceDependencyTargetFrameworkNuspecQuery,
(package, nuspec) => NuspecUtility.GetWhitespaceDependencyTargetFrameworks(nuspec));
await ShowMatchedStringCounts(
PackageQueryNames.FindInvalidDependencyTargetFrameworkNuspecQuery,
(package, nuspec) => NuspecUtility.GetInvalidDependencyTargetFrameworks(nuspec));
await ShowMatchedStringCounts(
PackageQueryNames.FindInvalidDependencyIdNuspecQuery,
(package, nuspec) => NuspecUtility.GetInvalidDependencyIds(nuspec));
await ShowMatchedStringCounts(
PackageQueryNames.FindUnsupportedDependencyTargetFrameworkNuspecQuery,
(package, nuspec) => NuspecUtility.GetUnsupportedDependencyTargetFrameworks(nuspec));
await ShowMatchedStringCounts(
PackageQueryNames.FindDuplicateDependencyTargetFrameworksNuspecQuery,
(package, nuspec) => NuspecUtility
.GetDuplicateDependencyTargetFrameworks(nuspec)
.Select(x => x.Key));
await ShowMatchedStringCounts(
PackageQueryNames.FindDuplicateNormalizedDependencyTargetFrameworksNuspecQuery,
(package, nuspec) => NuspecUtility
.GetDuplicateNormalizedDependencyTargetFrameworks(nuspec)
.Select(x => x.Key.ToString()));
}
/// <summary>
/// Read package dependencies for all frameworks
/// </summary>
public IEnumerable <FrameworkReferenceGroup> GetFrameworkRefGroups()
{
return(NuspecUtility.GetFrameworkReferenceGroups(MetadataNode, _frameworkProvider, useMetadataNamespace: true));
}
private static IEnumerable <FrameworkReferenceGroup> ReadFrameworkReferenceGroups(XElement frameworkReferenceGroupsElement)
{
return(NuspecUtility.GetFrameworkReferenceGroups(frameworkReferenceGroupsElement, DefaultFrameworkNameProvider.Instance, useMetadataNamespace: false));
}
public static void InstallPackage(IReadOnlyList <string> packages, bool quiet)
{
Init();
RemoteWalkContext context = new RemoteWalkContext();
ILogger logger = new NullLogger();
SourceCacheContext cacheContext = new SourceCacheContext
{
IgnoreFailedSources = true
};
foreach (SourceRepository repo in Repos)
{
if (!repo.PackageSource.IsLocal)
{
context.RemoteLibraryProviders.Add(new SourceRepositoryDependencyProvider(repo, logger, cacheContext));
}
else
{
context.LocalLibraryProviders.Add(new SourceRepositoryDependencyProvider(repo, logger, cacheContext));
}
}
Paths.User.Content.CreateDirectory();
RemoteDependencyWalker walker = new RemoteDependencyWalker(context);
HashSet <Package> remainingPackages = new HashSet <Package>(packages.Select(x => new Package(x, VersionRange.All)));
HashSet <Package> encounteredPackages = new HashSet <Package>();
List <string> templateRoots = new List <string>();
List <KeyValuePair <string, string> > componentRoots = new List <KeyValuePair <string, string> >();
while (remainingPackages.Count > 0)
{
HashSet <Package> nextRound = new HashSet <Package>();
foreach (Package package in remainingPackages)
{
string name = package.PackageId;
GraphNode <RemoteResolveResult> result = walker.WalkAsync(new LibraryRange(name, package.Version, LibraryDependencyTarget.All), NuGetFramework.AnyFramework, "", RuntimeGraph.Empty, true).Result;
RemoteMatch match = result.Item.Data.Match;
PackageIdentity packageIdentity = new PackageIdentity(match.Library.Name, match.Library.Version);
nextRound.UnionWith(result.Item.Data.Dependencies.Select(x => new Package(x.Name, x.LibraryRange.VersionRange)));
VersionFolderPathContext versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
Paths.User.PackageCache,
new NullLogger(),
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.Skip,
fixNuspecIdCasing: true,
normalizeFileNames: true);
if (match.Library.Version == null)
{
if (!quiet)
{
throw new Exception($"Package '{package.PackageId}' version {package.Version} could not be located.");
}
else
{
continue;
}
}
string source = Path.Combine(Paths.User.PackageCache, match.Library.Name, match.Library.Version.ToString());
if (!source.Exists() && match.Provider != null)
{
PackageExtractor.InstallFromSourceAsync(
stream => match.Provider.CopyToAsync(match.Library, stream, CancellationToken.None),
versionFolderPathContext,
CancellationToken.None).Wait();
string target = Path.Combine(Paths.User.Content, match.Library.Name);
target.CreateDirectory();
target = Path.Combine(target, match.Library.Version.ToString());
target.CreateDirectory();
Paths.Copy(source, target);
target.Delete("*.nupkg", "*.nupkg.*");
string nuspec = target.EnumerateFiles("*.nuspec").FirstOrDefault();
//If there's a nuspec, figure out whether this package is a template and walk the dependency graph
if (nuspec?.Exists() ?? false)
{
XDocument doc = XDocument.Load(nuspec);
IReadOnlyList <PackageType> types = NuspecUtility.GetPackageTypes(doc.Root.Element(XName.Get("metadata", "http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd")), false);
//If the thing we got is a template...
if (types.Any(x => string.Equals(x.Name, "template", StringComparison.OrdinalIgnoreCase)))
{
templateRoots.Add(target);
}
else
{
componentRoots.Add(new KeyValuePair <string, string>(match.Library.Name, match.Library.Version.ToString()));
}
}
}
}
encounteredPackages.UnionWith(remainingPackages);
nextRound.ExceptWith(encounteredPackages);
remainingPackages = nextRound;
}
foreach (KeyValuePair <string, string> package in componentRoots)
{
foreach (string path in Path.Combine(Paths.User.Content, package.Key, package.Value).EnumerateFiles($"{package.Key}.dll", SearchOption.AllDirectories))
{
if (path.IndexOf($"{Path.DirectorySeparatorChar}lib{Path.DirectorySeparatorChar}", StringComparison.OrdinalIgnoreCase) < 0 ||
(path.IndexOf($"{Path.DirectorySeparatorChar}netstandard1.", StringComparison.OrdinalIgnoreCase) < 0 &&
path.IndexOf($"{Path.DirectorySeparatorChar}netcoreapp1.", StringComparison.OrdinalIgnoreCase) < 0))
{
continue;
}
#if !NET451
Assembly asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
#else
Assembly asm = Assembly.LoadFile(path);
#endif
foreach (Type type in asm.GetTypes())
{
SettingsLoader.Components.Register(type);
}
}
}
TemplateCache.Scan(templateRoots);
}
public async Task ExecuteAsync(CancellationToken token)
{
Console.Write("Package Key");
Console.Write('\t');
Console.Write("ID");
Console.Write('\t');
Console.Write("Version");
Console.Write('\t');
Console.Write("Has Type");
Console.Write('\t');
Console.Write("Type");
Console.Write('\t');
Console.Write("Has URL");
Console.Write('\t');
Console.Write("URL");
Console.Write('\t');
Console.Write("Is Valid Absolute URI");
Console.Write('\t');
Console.Write("Scheme");
Console.Write('\t');
Console.Write("Authority");
Console.Write('\t');
Console.Write("First Commit Timestamp");
Console.Write('\t');
Console.Write("Last Commit Timestamp");
Console.WriteLine();
int count;
long lastKey = 0;
do
{
var matches = await _queryService.GetMatchedPackagesAsync(
PackageQueryNames.FindRepositoriesNuspecQuery,
lastKey);
count = matches.Packages.Count;
lastKey = matches.LastKey;
foreach (var match in matches.Packages)
{
var nuspecContext = await _nuspecStore.GetNuspecContextAsync(match.PackageRegistration.Id, match.Version);
var repositoryEl = NuspecUtility.GetRepository(nuspecContext.Document);
var typeAttr = repositoryEl.Attribute("type");
var hasType = typeAttr != null;
var urlAttr = repositoryEl.Attribute("url");
var hasUrl = urlAttr != null;
var isValidAbsoluteUri = Uri.TryCreate(urlAttr?.Value, UriKind.Absolute, out Uri parsedUrl);
Console.Write(match.PackageKey);
Console.Write('\t');
Console.Write(match.PackageRegistration);
Console.Write('\t');
Console.Write(match.Version);
Console.Write('\t');
Console.Write(hasType);
Console.Write('\t');
Console.Write(typeAttr?.Value);
Console.Write('\t');
Console.Write(hasUrl);
Console.Write('\t');
Console.Write(urlAttr?.Value);
Console.Write('\t');
Console.Write(isValidAbsoluteUri);
Console.Write('\t');
Console.Write(parsedUrl?.Scheme);
Console.Write('\t');
Console.Write(parsedUrl?.Authority);
Console.Write('\t');
Console.Write(FormatDateTimeOffset(match.CatalogPackage.FirstCommitTimestamp));
Console.Write('\t');
Console.Write(FormatDateTimeOffset(match.CatalogPackage.LastCommitTimestamp));
Console.WriteLine();
}
}while (count > 0);
}
