public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
if (!package.IsSatellitePackage())
{
IEnumerable <string> allXmlFiles =
from file in package.GetLibFiles()
select file.Path into path
where path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase)
select path;
foreach (IPackageFile current in package.GetLibFiles())
{
string assemblyPath = current.Path;
// TODO: Does this need to check for just managed code?
if (assemblyPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
string docFilePath = Path.ChangeExtension(assemblyPath, ".xml");
if (!allXmlFiles.Contains(docFilePath, StringComparer.OrdinalIgnoreCase))
{
yield return(PackageIssueFactory.AssemblyHasNoDocFile(assemblyPath));
}
}
}
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.Metadata.PackageTypes.Any(p => p == PackageType.DotnetCliTool))
{
yield break;
}
if (!context.PackageReader.IsSatellitePackage())
{
var allXmlFiles =
from item in context.PackageReader.GetLibItems()
from file in item.Items
select file into path
where path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase)
select path;
foreach (var current in context.PackageReader.GetLibItems())
{
foreach (var item in current.Items)
{
var assemblyPath = item;
// TODO: Does this need to check for just managed code?
if (assemblyPath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
{
var docFilePath = Path.ChangeExtension(assemblyPath, ".xml");
if (!allXmlFiles.Contains(docFilePath, StringComparer.OrdinalIgnoreCase))
{
yield return(PackageIssueFactory.AssemblyHasNoDocFile(assemblyPath));
}
}
}
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (!SemanticVersion.TryParse(context.Metadata.Version.ToString(), out var _))
{
yield return(PackageIssueFactory.NotSemanticVersion(context.Metadata.Version));
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
var repoMetadata = context.PackageReader.NuspecReader.GetRepositoryMetadata();
if (repoMetadata == null)
{
yield return(PackageIssueFactory.PackageRepositoryMetadataMissing());
}
else
{
if (string.IsNullOrEmpty(repoMetadata.Url))
{
yield return(PackageIssueFactory.PackageRepositoryUrl());
}
if (string.IsNullOrEmpty(repoMetadata.Type))
{
yield return(PackageIssueFactory.PackageRepositoryType());
}
if (string.IsNullOrEmpty(repoMetadata.Commit))
{
yield return(PackageIssueFactory.PackageRepositoryCommit());
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
throw new InvalidOperationException("Package sign verification is only supported on Windows machines");
}
var args = new[]
{
"verify",
"-NonInteractive",
"-All",
context.PackageFileInfo.FullName,
};
var psi = new ProcessStartInfo
{
FileName = _nuGetExePath,
Arguments = ArgumentEscaper.EscapeAndConcatenate(args),
RedirectStandardOutput = true,
};
var process = Process.Start(psi);
process.WaitForExit(60 * 1000);
if (process.ExitCode != 0)
{
var issueText = process.StandardOutput.ReadToEnd();
yield return(PackageIssueFactory.PackageSignVerificationFailed(context.Metadata.Id, issueText));
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (!string.Equals(context.Metadata.Copyright, ExpectedCopyright, StringComparison.Ordinal))
{
yield return(PackageIssueFactory.CopyrightIsIncorrect(context.Metadata.Id, ExpectedCopyright, context.Metadata.Copyright));
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
foreach (IPackageFile currentFile in package.GetFiles())
{
string extension = Path.GetExtension(currentFile.Path);
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) ||
extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
{
string assemblyPath = Path.ChangeExtension(Path.Combine(Path.GetTempPath(), Path.GetTempFileName()), extension);
var isManagedCode = false;
var isStrongNameSigned = false;
int hresult = 0;
try
{
using (Stream packageFileStream = currentFile.GetStream())
{
var _assemblyBytes = new byte[packageFileStream.Length];
packageFileStream.Read(_assemblyBytes, 0, _assemblyBytes.Length);
using (var fileStream = new FileStream(assemblyPath, FileMode.Create))
{
packageFileStream.Seek(0, SeekOrigin.Begin);
packageFileStream.CopyTo(fileStream);
fileStream.Flush(true);
}
if (AssemblyHelpers.IsAssemblyManaged(assemblyPath))
{
isManagedCode = true;
var clrStrongName = (IClrStrongName)RuntimeEnvironment.GetRuntimeInterfaceAsObject(new Guid("B79B0ACD-F5CD-409b-B5A5-A16244610B92"), new Guid("9FD93CCF-3280-4391-B3A9-96E1CDE77C8D"));
bool verificationForced;
hresult = clrStrongName.StrongNameSignatureVerificationEx(assemblyPath, true, out verificationForced);
if (hresult == 0)
{
isStrongNameSigned = true;
}
}
}
}
catch (Exception ex)
{
logger.LogError("Error while verifying strong name signature for {0}: {1}", currentFile.Path, ex.Message);
}
finally
{
if (File.Exists(assemblyPath))
{
File.Delete(assemblyPath);
}
}
if (isManagedCode && !isStrongNameSigned)
{
yield return(PackageIssueFactory.AssemblyNotStrongNameSigned(currentFile.Path, hresult));
}
}
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
foreach (var assemblyData in context.AssemblyData)
{
if (!HasDescriptionAttribute(assemblyData.Value.AssemblyAttributes))
{
yield return(PackageIssueFactory.AssemblyMissingDescriptionAttribute(assemblyData.Key));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.Metadata.PackageTypes.Any(p => p == Constants.DotNetTool))
{
// Skip for dotnet global tool packages which contain assemblies from other teams and projects
yield break;
}
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
foreach (var assemblyData in context.AssemblyData)
{
var assemblyInformationalVersionAttribute = assemblyData.Value.AssemblyAttributes.SingleOrDefault(a =>
a.AttributeType.FullName.Equals(
typeof(AssemblyInformationalVersionAttribute).FullName,
StringComparison.Ordinal));
var infoVersion = assemblyInformationalVersionAttribute?.ConstructorArguments[0].Value?.ToString();
if (!NuGetVersion.TryParse(infoVersion, out var assemblyInformationalNuGetVersion) ||
!VersionEquals(context.Metadata.Version, assemblyInformationalNuGetVersion))
{
yield return(PackageIssueFactory.AssemblyInformationalVersionDoesNotMatchPackageVersion(
assemblyData.Key,
infoVersion,
context.Metadata.Version,
context.Metadata.Id));
}
var assemblyFileVersionAttribute = assemblyData.Value.AssemblyAttributes.SingleOrDefault(a =>
a.AttributeType.FullName.Equals(
typeof(AssemblyFileVersionAttribute).FullName,
StringComparison.Ordinal));
var assemblyFileNuGetVersion = new NuGetVersion(assemblyFileVersionAttribute.ConstructorArguments[0].Value.ToString());
if (!VersionEquals(context.Metadata.Version, assemblyFileNuGetVersion))
{
yield return(PackageIssueFactory.AssemblyFileVersionDoesNotMatchPackageVersion(
assemblyData.Key,
assemblyFileNuGetVersion,
context.Metadata.Version,
context.Metadata.Id));
}
var assemblyVersion = assemblyData.Value.AssemblyName.Version;
if (!context.Metadata.Version.Version.Equals(assemblyVersion))
{
yield return(PackageIssueFactory.AssemblyVersionDoesNotMatchPackageVersion(
assemblyData.Key,
assemblyVersion,
context.Metadata.Version.Version,
context.Metadata.Id));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (!context.Metadata.PackageTypes.Any(p => p == Constants.DotNetTool))
{
yield break;
}
var packageFiles = context.PackageReader.GetFiles();
var manifests = packageFiles?.Where(f => Path.GetFileName(f).Equals(ToolManifestFileName, StringComparison.Ordinal)) ?? Enumerable.Empty <string>();
if (packageFiles == null || manifests.Count() == 0)
{
yield return(PackageIssueFactory.DotNetToolMustHaveManifest(Constants.DotNetTool.Name, ToolManifestFileName));
yield break;
}
foreach (var manifestPath in manifests)
{
var manifestDir = Path.GetDirectoryName(manifestPath).Replace('\\', '/');
var manifestStream = context.PackageReader.GetStream(manifestPath);
var manifest = XDocument.Load(manifestStream);
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
var commands = manifest.Descendants("Command");
foreach (var command in commands)
{
var name = command.Attribute("Name");
if (string.IsNullOrEmpty(name?.Value))
{
yield return(PackageIssueFactory.DotNetToolMalformedManifest(manifestPath, "Missing Name"));
continue;
}
var entryPoint = command.Attribute("EntryPoint");
if (entryPoint?.Value == null)
{
yield return(PackageIssueFactory.DotNetToolMalformedManifest(manifestPath, "Missing EntryPoint"));
continue;
}
var entryPointPath = manifestDir + '/' + entryPoint.Value;
if (!packageFiles.Any(a => a.Equals(entryPointPath, StringComparison.Ordinal)))
{
yield return(PackageIssueFactory.DotNetToolMissingEntryPoint(manifestPath, entryPoint.Value));
}
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
foreach (IPackageFile currentFile in package.GetFiles())
{
string extension = Path.GetExtension(currentFile.Path);
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) ||
extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
{
string assemblyPath = Path.ChangeExtension(Path.Combine(Path.GetTempPath(), Path.GetTempFileName()), extension);
try
{
using (Stream packageFileStream = currentFile.GetStream())
{
var _assemblyBytes = new byte[packageFileStream.Length];
packageFileStream.Read(_assemblyBytes, 0, _assemblyBytes.Length);
using (var fileStream = new FileStream(assemblyPath, FileMode.Create))
{
packageFileStream.Seek(0, SeekOrigin.Begin);
packageFileStream.CopyTo(fileStream);
fileStream.Flush(true);
}
if (AssemblyHelpers.IsAssemblyManaged(assemblyPath))
{
var assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyPath);
var asmAttrs = assemblyDefinition.CustomAttributes;
if (!HasAttrWithArg(asmAttrs, typeof(AssemblyFileVersionAttribute).FullName))
{
yield return(PackageIssueFactory.AssemblyMissingFileVersionAttribute(currentFile.Path));
}
if (!HasAttrWithArg(asmAttrs, typeof(AssemblyInformationalVersionAttribute).FullName))
{
yield return(PackageIssueFactory.AssemblyMissingInformationalVersionAttribute(currentFile.Path));
}
}
}
}
finally
{
if (File.Exists(assemblyPath))
{
File.Delete(assemblyPath);
}
}
}
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
foreach (var assemblyData in context.AssemblyData)
{
var fileName = Path.GetFileNameWithoutExtension(assemblyData.Key);
var isSourcesPackage = fileName.EndsWith(".Sources", StringComparison.OrdinalIgnoreCase);
if (!isSourcesPackage && !HasCommitHashInMetadataAttribute(assemblyData.Value.AssemblyAttributes))
{
yield return(PackageIssueFactory.AssemblyMissingHashAttribute(assemblyData.Key));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
SemanticVersion semanticVersion;
if (SemanticVersion.TryParseStrict(package.Version.ToString(), out semanticVersion))
{
yield break;
}
else
{
yield return(PackageIssueFactory.NotSemanticVersion(package.Version));
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
foreach (var current in context.PackageReader.GetFiles())
{
var extension = Path.GetExtension(current);
if (PowerShellExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase))
{
if (!VerifySigned(context.PackageReader, current))
{
yield return(PackageIssueFactory.PowerShellScriptNotSigned(current));
}
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
foreach (IPackageFile current in package.GetFiles())
{
string extension = Path.GetExtension(current.Path);
if (PowerShellScriptIsSignedRule.PowerShellExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase))
{
if (!VerifySigned(current))
{
yield return(PackageIssueFactory.PowerShellScriptNotSigned(current.Path));
}
}
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
var discoveredTypes = context.Metadata.PackageTypes.Select(t => t.Name);
var expectedTypes = context.Options?.PackageTypes ?? Enumerable.Empty <string>();
foreach (var missing in expectedTypes.Except(discoveredTypes))
{
yield return(PackageIssueFactory.PackageTypeMissing(missing));
}
foreach (var unexpected in discoveredTypes.Except(expectedTypes))
{
yield return(PackageIssueFactory.PackageTypeUnexpected(unexpected));
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (string.IsNullOrEmpty(context.Metadata.Description))
{
yield return(PackageIssueFactory.RequiredDescription());
}
if (string.IsNullOrEmpty(context.Metadata.Tags))
{
yield return(PackageIssueFactory.RequiredTags());
}
if (string.IsNullOrEmpty(context.Metadata.Id))
{
yield return(PackageIssueFactory.RequiredId());
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
foreach (var assemblyData in context.AssemblyData)
{
if (!HasAttrWithArg(assemblyData.Value.AssemblyAttributes, typeof(AssemblyFileVersionAttribute).FullName))
{
yield return(PackageIssueFactory.AssemblyMissingFileVersionAttribute(assemblyData.Key));
}
if (!HasAttrWithArg(assemblyData.Value.AssemblyAttributes, typeof(AssemblyInformationalVersionAttribute).FullName))
{
yield return(PackageIssueFactory.AssemblyMissingInformationalVersionAttribute(assemblyData.Key));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.Metadata.IsDotNetToolPackage())
{
yield break;
}
AssemblyAttributesDataHelper.SetAssemblyAttributesData(context);
foreach (var assemblyData in context.AssemblyData)
{
if (!HasNeutralResourcesLanguageAttribute(assemblyData.Value.AssemblyAttributes))
{
yield return(PackageIssueFactory.AssemblyMissingNeutralResourcesLanguageAttribute(assemblyData.Key));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (ExternallyOwnedPackageIds.Contains(context.Metadata.Id, StringComparer.OrdinalIgnoreCase))
{
yield return(PackageIssueFactory.IdIsNotOwned(context.Metadata.Id));
}
if (OwnedPackageIds.Contains(context.Metadata.Id, StringComparer.OrdinalIgnoreCase))
{
yield break;
}
if (OwnedPrefixes.Any(prefix => context.Metadata.Id.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
{
yield break;
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
foreach (var dependencyGroup in context.Metadata.DependencyGroups)
{
foreach (var packageDependency in dependencyGroup.Packages)
{
if (packageDependency.VersionRange.HasUpperBound)
{
yield return(PackageIssueFactory.DependencyVersionHasUpperBound(context.Metadata.Id, packageDependency.Id, dependencyGroup.TargetFramework));
}
if (!packageDependency.VersionRange.HasLowerBound)
{
yield return(PackageIssueFactory.DependencyVersionDoesNotHaveLowerBound(context.Metadata.Id, packageDependency.Id, dependencyGroup.TargetFramework));
}
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.PackageReader.IsSatellitePackage())
{
if (context.Metadata.Summary.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageSummaryNotLocalized());
}
if (context.Metadata.Title.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageTitleNotLocalized());
}
if (context.Metadata.Description.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageDescriptionNotLocalized());
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
string packagePath = packageRepo.Source + "\\" + package.Id + "." + package.Version.ToString() + ".nupkg";
string nupkgWithoutExt = Path.Combine(Path.GetDirectoryName(packagePath), Path.GetFileNameWithoutExtension(packagePath));
try
{
UnzipPackage(nupkgWithoutExt);
foreach (IPackageFile current in package.GetFiles())
{
//string packagePath = package.FileSystem.Root + "\\" + Id + "." + Version + ".nupkg"
string extension = Path.GetExtension(current.Path);
// TODO: Need to add more extensions?
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) ||
extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
{
string pathOfFileToScan = Path.Combine(nupkgWithoutExt, current.Path);
var realAssemblyPath = pathOfFileToScan;
if (!File.Exists(realAssemblyPath))
{
realAssemblyPath = pathOfFileToScan.Replace("+", "%2B").Replace("#", "%23");
if (!File.Exists(realAssemblyPath))
{
logger.LogError("The assembly '{0}' in this package can't be found (a bug in this tool, most likely).", current.Path);
continue;
}
}
bool isAuthenticodeSigned = WinTrust.IsAuthenticodeSigned(realAssemblyPath);
if (!isAuthenticodeSigned)
{
yield return(PackageIssueFactory.PEFileNotAuthenticodeSigned(current.Path));
}
}
}
}
finally
{
CleanUpFolder(nupkgWithoutExt, logger);
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
var extractPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
UnzipPackage(context.PackageFileInfo, extractPath);
foreach (var current in context.PackageReader.GetFiles())
{
//string packagePath = package.FileSystem.Root + "\\" + Id + "." + Version + ".nupkg"
var extension = Path.GetExtension(current);
// TODO: Need to add more extensions?
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase) ||
extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
{
var pathOfFileToScan = Path.Combine(extractPath, current);
var realAssemblyPath = pathOfFileToScan;
if (!File.Exists(realAssemblyPath))
{
realAssemblyPath = pathOfFileToScan.Replace("+", "%2B").Replace("#", "%23");
if (!File.Exists(realAssemblyPath))
{
context.Logger.LogError(
"The assembly '{0}' in this package can't be found (a bug in this tool, most likely).",
current);
continue;
}
}
var isAuthenticodeSigned = WinTrust.IsAuthenticodeSigned(realAssemblyPath);
if (!isAuthenticodeSigned)
{
yield return(PackageIssueFactory.PEFileNotAuthenticodeSigned(current));
}
}
}
}
finally
{
CleanUpFolder(extractPath, context.Logger);
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.Metadata.Authors == null || !context.Metadata.Authors.Any())
{
yield return(PackageIssueFactory.RequiredAuthor());
}
if (context.Metadata.Authors.Count() > 1)
{
yield return(PackageIssueFactory.SingleAuthorOnly(context.Metadata.Id));
}
var author = context.Metadata.Authors.First();
if (!string.Equals(author, _expectedAuthor, StringComparison.Ordinal))
{
yield return(PackageIssueFactory.AuthorIsIncorrect(context.Metadata.Id, _expectedAuthor, author));
}
}
public IEnumerable <PackageVerifierIssue> Validate(IPackageRepository packageRepo, IPackage package, IPackageVerifierLogger logger)
{
if (package.IsSatellitePackage())
{
if (package.Summary.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageSummaryNotLocalized());
}
if (package.Title.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageTitleNotLocalized());
}
if (package.Description.Contains("{"))
{
yield return(PackageIssueFactory.Satellite_PackageDescriptionNotLocalized());
}
}
yield break;
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
var dependencyFrameworks = new HashSet <NuGetFramework>(
context.Metadata.DependencyGroups.Select(g => g.TargetFramework));
var buildItems = context
.PackageReader
.GetBuildItems()
.Where(f => f.Items.Any(i => IsCandidateMSBuildItem(i, context.Metadata.Id)));
foreach (var buildItem in buildItems)
{
if (!dependencyFrameworks.Contains(buildItem.TargetFramework))
{
yield return(PackageIssueFactory
.BuildItemsDoNotMatchFrameworks(context.Metadata.Id, buildItem.TargetFramework));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.Metadata.PackageTypes.All(p => p != PackageType.DotnetCliTool))
{
yield break;
}
var libItems = context.PackageReader
.GetLibItems()
.FirstOrDefault(f => f.TargetFramework.Framework == FrameworkConstants.FrameworkIdentifiers.NetCoreApp);
if (libItems == null)
{
yield return(PackageIssueFactory.DotNetCliToolMustTargetNetCoreApp());
yield break;
}
var assembly = libItems.Items.Where(f =>
Path.GetFileName(f).StartsWith("dotnet-") &&
Path.GetExtension(f) == ".dll");
if (!assembly.Any())
{
yield return(PackageIssueFactory.DotNetCliToolMissingDotnetAssembly());
}
foreach (var tool in assembly)
{
var expected = Path.GetFileNameWithoutExtension(tool) + ".runtimeconfig.json";
if (libItems.Items.All(f => Path.GetFileName(f) != expected))
{
yield return(PackageIssueFactory.DotNetCliToolMissingRuntimeConfig());
}
}
if (context.PackageReader.GetFiles().All(f => f != "prefercliruntime"))
{
yield return(PackageIssueFactory.DotNetCliToolMissingPrefercliRuntime());
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (context.SignRequest == null)
{
context.Logger.Log(LogLevel.Info, "Skipping signing rule request verification for " + context.PackageFileInfo.FullName);
yield break;
}
foreach (var file in context.PackageReader.GetFiles())
{
if (!SignRequestItem.IsFileTypeSignable(file))
{
continue;
}
if (!context.SignRequest.Children.Any(f => string.Equals(f.Path, file)))
{
yield return(PackageIssueFactory.SignRequestMissingPackageFile(context.Metadata.Id, file));
}
}
}
public IEnumerable <PackageVerifierIssue> Validate(PackageAnalysisContext context)
{
if (string.IsNullOrEmpty(context.Metadata.Copyright))
{
yield return(PackageIssueFactory.RequiredCopyright());
}
if (context.Metadata.LicenseUrl == null)
{
yield return(PackageIssueFactory.RequiredLicenseUrl());
}
if (context.Metadata.IconUrl == null)
{
yield return(PackageIssueFactory.RequiredIconUrl());
}
if (context.Metadata.ProjectUrl == null)
{
yield return(PackageIssueFactory.RequiredProjectUrl());
}
if (!context.Metadata.RequireLicenseAcceptance)
{
yield return(PackageIssueFactory.RequiredRequireLicenseAcceptanceTrue());
}
}
