|
private GetPackages ( IPackage>.Func |
||
| openPackage | IPackage>.Func | |
| return | IEnumerable |
|
internal static Target ProcessDependencies(string solutionName, PackageSpec project)
{
List <string> packageCollection = new List <string>();
Target projectTarget = new Target();
projectTarget.project = solutionName;
projectTarget.moduleId = $"netframework:{project.Name}";
projectTarget.module = project.Name;
projectTarget.release = project.Version.ToFullString();
projectTarget.dependencies = new List <Dependency>();
// Generate lock file
var lockFileService = new LockFileService();
var lockFile = lockFileService.GetLockFile(project.FilePath, project.RestoreMetadata.OutputPath);
foreach (var targetFramework in project.TargetFrameworks)
{
var lockFileTargetFramework = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFramework.FrameworkName));
ReportDependency(projectTarget.dependencies, targetFramework, false, packageCollection, lockFileTargetFramework);
}
var packageRepository = new NuGet.LocalPackageRepository($@"{project.BaseDirectory}\packages");
IQueryable <IPackage> packages = packageRepository.GetPackages();
foreach (IPackage package in packages)
{
ReportDependencyPackage(projectTarget.dependencies, package, true, packageCollection);
}
return(projectTarget);
}
public IEnumerable<string> CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
packageReferenceFile.AddEntry(package.Id, package.Version, newestFramework);
if (newestFramework == null)
{
yield return string.Format("{0}, Version {1}", package.Id, package.Version);
}
else
{
yield return string.Format("{0}, Version {1}, .NET {2}", package.Id, package.Version, newestFramework.Version);
}
}
}
public IEnumerable<string> CreatePackageFile()
{
var packageReferenceFile = new PackageReferenceFile(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile));
var repository = new LocalPackageRepository(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder));
var arbitraryPackages = repository.GetPackages();
var result = new List<string>();
foreach (var package in arbitraryPackages.GroupBy(i => i.Id))
{
var p = package.OrderByDescending(i => i.Version).FirstOrDefault();
packageReferenceFile.AddEntry(p.Id, p.Version, VersionUtility.ParseFrameworkName("net45"));
result.Add(string.Format("{0}, Version {1}, .NET 4.5", p.Id, p.Version));
}
return result;
}
public void CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
if (!newestPackages.Any())
{
_logger.Info("No packages found!");
return;
}
_logger.InfoFormat("{0} {1}...", (File.Exists(packagesFile) ? "Updating" : "Creating"), _fileSystem.PackagesFile);
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
if (!packageReferenceFile.EntryExists(package.Id, package.Version))
{
packageReferenceFile.AddEntry(package.Id, package.Version, package.DevelopmentDependency, newestFramework);
if (newestFramework == null)
{
_logger.InfoFormat("Added {0} (v{1}) to {2}", package.Id, package.Version, _fileSystem.PackagesFile);
}
else
{
_logger.InfoFormat("Added {0} (v{1}, .NET {2}) to {3}", package.Id, package.Version, newestFramework.Version, _fileSystem.PackagesFile);
}
continue;
}
_logger.InfoFormat("Skipped {0} because it already exists.", package.Id);
}
_logger.InfoFormat("Successfully {0} {1}.", (File.Exists(packagesFile) ? "updated" : "created"), _fileSystem.PackagesFile);
}
public void CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var packages = repository.GetPackages().OrderByDescending(x => x.Version);
var configFile = new JObject();
var dependencyObject = new JObject();
configFile.Add("dependencies", dependencyObject);
foreach (var package in packages)
{
if (dependencyObject[package.Id] == null)
dependencyObject.Add(new JProperty(package.Id, package.Version.ToString()));
}
File.WriteAllText(packagesFile, configFile.ToString());
}
internal static Target ProcessDependencies(string solutionName, PackageSpec project, string projectPath)
{
HashSet <string> packageCollection = new HashSet <string>();
Target projectTarget = new Target();
projectTarget.project = solutionName;
projectTarget.moduleId = $"vs:{project.Name}";
projectTarget.module = project.Name;
projectTarget.release = project.Version.ToFullString();
projectTarget.dependencies = new List <Dependency>();
foreach (var targetFramework in project.TargetFrameworks)
{
Dependency targetDependency = new Dependency();
projectTarget.dependencies.Add(targetDependency);
var frameworkName = targetFramework.FrameworkName.ToString();
packageCollection.Add(frameworkName);
targetDependency.name = frameworkName;
targetDependency.key = $"netframework:{frameworkName}";
}
var directoryInfo = VisualStudioProvider.TryGetPackagesDirectoryInfo(project.BaseDirectory);
if (directoryInfo == null)
{
directoryInfo = VisualStudioProvider.TryGetPackagesDirectoryInfo(projectPath);
}
var packageRepository = new NuGet.LocalPackageRepository($@"{directoryInfo.FullName}\packages");
IQueryable <IPackage> packages = packageRepository.GetPackages();
foreach (IPackage package in packages)
{
ReportDependencyPackage(packageRepository, projectTarget.dependencies, package, packageCollection);
}
return(projectTarget);
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences();
if (!references.Any())
{
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (_fileSystem.DirectoryExists(packagesFolder))
{
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages().Where(i => i.GetSupportedFrameworks().Any(x => x.FullName == VersionUtility.ParseFrameworkName("net40").FullName)).ToList();
if (arbitraryPackages.Any())
{
return arbitraryPackages.Select(i => new PackageReference(i.Id, VersionUtility.ParseFrameworkName("net40"), i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
}
}
return Enumerable.Empty<IPackageReference>();
}
var packages = references.Select(i => new PackageReference(i.Id, i.TargetFramework, i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
return packages;
}
internal void VerifyPackage(string filename)
{
try
{
Log.InfoFormat("Creating verify path {0}", filename);
var fi = new FileInfo(filename);
var tempPath =
new FileInfo(
Path.Combine(
Path.GetTempPath(),
"octgn",
Guid.NewGuid().ToString(),
fi.Name.Replace(fi.Extension, ".nupkg")));
if (!File.Exists(filename))
{
Log.InfoFormat("Package magically disappeared {0}", filename);
return;
}
Log.InfoFormat("Creating directory {0}", filename);
if (!Directory.Exists(tempPath.Directory.FullName)) Directory.CreateDirectory(tempPath.Directory.FullName);
Log.InfoFormat("Copying file {0}", filename);
fi.MegaCopyTo(tempPath);
Log.InfoFormat("Creating repo to make sure it loads {0}", filename);
var repo = new LocalPackageRepository(tempPath.Directory.FullName);
Log.InfoFormat("Loading repo into array to make sure it works {0}", filename);
var arr = repo.GetPackages().ToArray();
Log.InfoFormat("Fully verified {0}", filename);
}
catch (Exception)
{
Log.WarnFormat("Package not valid {0}", filename);
throw new UserMessageException(L.D.Exception__FileIsInvalid_Format, filename);
}
finally
{
Log.InfoFormat("Finished {0}", filename);
}
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences().ToList();
if (references.Any())
{
foreach (var packageReference in references)
{
yield return new PackageReference(
packageReference.Id,
packageReference.TargetFramework,
packageReference.Version.Version,
packageReference.Version.SpecialVersion);
}
yield break;
}
// No packages.config, check packages folder
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (!_fileSystem.DirectoryExists(packagesFolder)) yield break;
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages();
if (!arbitraryPackages.Any()) yield break;
foreach (var arbitraryPackage in arbitraryPackages)
{
var newestFramework = GetNewestSupportedFramework(arbitraryPackage)
?? VersionUtility.EmptyFramework;
yield return new PackageReference(
arbitraryPackage.Id,
newestFramework,
arbitraryPackage.Version.Version,
arbitraryPackage.Version.SpecialVersion);
}
}
public IEnumerable<IPackage> GetAllPackages(string rootFolder)
{
//rootFolder is repository root
var targetFolder = rootFolder.AppendPath(PackagesFolder);
var packagePathResolver = new DefaultPackagePathResolver(targetFolder);
var packagesFolderFileSystem = new PhysicalFileSystem(targetFolder);
var localRepository = new LocalPackageRepository(packagePathResolver, packagesFolderFileSystem);
return localRepository.GetPackages();
}
public static int Main(string[] args)
{
// TODO: Take a switch saying whether to use TeamCity logger
// TODO: Show extraneous packages, exclusions, etc.
// TODO: Get this from the command line
var ignoreAssistanceMode = IgnoreAssistanceMode.None;
ignoreAssistanceMode = IgnoreAssistanceMode.ShowNew;
if (args.Length < 1 || args.Length > 2)
{
Console.WriteLine(@"USAGE: NuGetSuperBVT.exe c:\path\to\packages [c:\path\to\packages-to-scan.json]");
return ReturnBadArgs;
}
var logger = new PackageVerifierLogger();
IDictionary<string, PackageSet> packageSets = null;
if (args.Length >= 2)
{
string packagesToScanJsonFilePath = args[1];
if (!File.Exists(packagesToScanJsonFilePath))
{
logger.LogError("Couldn't find packages JSON file at {0}", packagesToScanJsonFilePath);
return ReturnBadArgs;
}
string packagesToScanJsonFileContent = File.ReadAllText(packagesToScanJsonFilePath);
packageSets = JsonConvert.DeserializeObject<IDictionary<string, PackageSet>>(packagesToScanJsonFileContent, new JsonSerializerSettings()
{
MissingMemberHandling = MissingMemberHandling.Error
});
logger.LogInfo("Read {0} package set(s) from {1}", packageSets.Count, packagesToScanJsonFilePath);
}
var totalTimeStopWatch = Stopwatch.StartNew();
var nupkgsPath = args[0];
// TODO: Look this up using reflection or something
var allRules = new IPackageVerifierRule[] {
new AssemblyHasDocumentFileRule(),
new AssemblyHasVersionAttributesRule(),
new AssemblyHasServicingAttributeRule(),
new AssemblyStrongNameRule(),
new AuthenticodeSigningRule(),
new PowerShellScriptIsSignedRule(),
new RequiredPackageMetadataRule(),
new SatellitePackageRule(),
new StrictSemanticVersionValidationRule(),
}.ToDictionary(t => t.GetType().Name, t => t);
var localPackageRepo = new LocalPackageRepository(nupkgsPath);
var numPackagesInRepo = localPackageRepo.GetPackages().Count();
logger.LogInfo("Found {0} packages in {1}", numPackagesInRepo, nupkgsPath);
var processedPackages = new HashSet<IPackage>();
var totalErrors = 0;
var totalWarnings = 0;
var ignoreAssistanceData = new Dictionary<string, IDictionary<string, IDictionary<string, string>>>(StringComparer.OrdinalIgnoreCase);
foreach (var packageSet in packageSets)
{
logger.LogInfo("Processing package set '{0}' with {1} package(s)", packageSet.Key, packageSet.Value.Packages.Count);
var packageSetRuleInfo = packageSet.Value.Rules;
var packageSetRules = packageSetRuleInfo.Select(ruleId => allRules.Single(rule => string.Equals(rule.Key, ruleId, StringComparison.OrdinalIgnoreCase)).Value);
var analyzer = new PackageAnalyzer();
foreach (var ruleInstance in packageSetRules)
{
analyzer.Rules.Add(ruleInstance);
}
IList<IssueIgnore> issuesToIgnore = GetIgnoresFromFile(packageSet.Value.Packages);
var issueProcessor = new IssueProcessor(issuesToIgnore);
foreach (var packageInfo in packageSet.Value.Packages)
{
var packageId = packageInfo.Key;
var packageIgnoreInfo = packageInfo.Value;
var packagesWithId = localPackageRepo.FindPackagesById(packageId);
if (!packagesWithId.Any())
{
logger.LogError("Couldn't find package '{0}' in the repo", packageId);
totalErrors++;
continue;
}
if (packagesWithId.Count() > 1)
{
logger.LogError("Found more than one package with id '{0}' in the repo", packageId);
totalErrors++;
continue;
}
var package = packagesWithId.Single();
var packageTimeStopWatch = Stopwatch.StartNew();
logger.LogInfo("Analyzing {0} ({1})", package.Id, package.Version);
var issues = analyzer.AnalyzePackage(localPackageRepo, package, logger).ToList();
var packageErrorsAndWarnings = ProcessPackageIssues(
ignoreAssistanceMode, logger, issueProcessor,
ignoreAssistanceData, package, issues);
totalErrors += packageErrorsAndWarnings.Item1;
totalWarnings += packageErrorsAndWarnings.Item2;
packageTimeStopWatch.Stop();
logger.LogInfo("Took {0}ms", packageTimeStopWatch.ElapsedMilliseconds);
Console.WriteLine();
processedPackages.Add(package);
}
}
var unprocessedPackages = localPackageRepo.GetPackages().Except(processedPackages);
if (unprocessedPackages.Any())
{
logger.LogWarning("Found {0} unprocessed packages. Every package in the repo should be listed in exactly one package set. Running all rules on unlisted packages.", unprocessedPackages.Count());
// For unprocessed packages we run all rules (because we have no idea what exactly to run)
var analyzer = new PackageAnalyzer();
foreach (var ruleInstance in allRules.Values)
{
analyzer.Rules.Add(ruleInstance);
}
var issueProcessor = new IssueProcessor(issuesToIgnore: null);
foreach (var unprocessedPackage in unprocessedPackages)
{
logger.LogWarning("\tUnprocessed package: {0} ({1})", unprocessedPackage.Id, unprocessedPackage.Version);
var packageTimeStopWatch = Stopwatch.StartNew();
logger.LogInfo("Analyzing {0} ({1})", unprocessedPackage.Id, unprocessedPackage.Version);
var issues = analyzer.AnalyzePackage(localPackageRepo, unprocessedPackage, logger).ToList();
var packageErrorsAndWarnings = ProcessPackageIssues(
ignoreAssistanceMode, logger, issueProcessor,
ignoreAssistanceData, unprocessedPackage, issues);
totalErrors += packageErrorsAndWarnings.Item1;
totalWarnings += packageErrorsAndWarnings.Item2;
packageTimeStopWatch.Stop();
logger.LogInfo("Took {0}ms", packageTimeStopWatch.ElapsedMilliseconds);
Console.WriteLine();
}
}
if (ignoreAssistanceMode != IgnoreAssistanceMode.None)
{
Console.WriteLine("Showing JSON for ignore content:");
Console.WriteLine(JsonConvert.SerializeObject(ignoreAssistanceData, Formatting.Indented));
Console.WriteLine();
}
LogLevel errorLevel = LogLevel.Info;
if (totalWarnings > 0)
{
errorLevel = LogLevel.Warning;
}
if (totalErrors > 0)
{
errorLevel = LogLevel.Error;
}
logger.Log(
errorLevel,
"SUMMARY: {0} error(s) and {1} warning(s) found",
totalErrors, totalWarnings);
totalTimeStopWatch.Stop();
logger.LogInfo("Total took {0}ms", totalTimeStopWatch.ElapsedMilliseconds);
Console.ReadLine();
return (totalErrors + totalWarnings > 0) ? ReturnErrorsOrWarnings : ReturnOk;
}
static void Main(string[] args)
{
var orchardDirectory = args[0];
var inputDirectory = args[1];
var outputDirectory = args[2];
var cacheDirectory = args[3];
var cacheFileSystem = new PhysicalFileSystem(cacheDirectory);
var cachePackageResolver = new DefaultPackagePathResolver(cacheFileSystem, false);
var orchardRepository = new AggregateRepository(new IPackageRepository[]
{
new LocalPackageRepository(orchardDirectory),
new DataServicePackageRepository(new Uri("http://nuget.org/api/v2")),
});
var orchardManager = new PackageManager(orchardRepository, cachePackageResolver, cacheFileSystem);
var inputRepository = new LocalPackageRepository(inputDirectory);
var inputManager = new PackageManager(inputRepository, cachePackageResolver, cacheFileSystem);
var references = new[] { "Orchard.Core", "Orchard.Framework", "Orchard.External" };
foreach (var reference in references)
orchardManager.InstallPackage(orchardRepository.FindPackage(reference), false, false);
foreach (var inputPackage in inputRepository.GetPackages().Where(p => p.Id.StartsWith("Orchard.Module.")))
{
Do(inputRepository, inputManager, inputPackage, cacheDirectory, references, outputDirectory);
}
}
