public NugetAnalyzedPackage AnalyzePackage(string xml, Dictionary <string, INugetPackage> packagesOnConfig, params string[] relativePaths)
{
var nugetPackage = new NugetPackage()
{
Id = "TestPkg", Version = "1.999"
};
var paths = new List <RelativePath>();
paths.Add(RelativePath.Create(m_context.StringTable, nugetPackage.Id + ".nuspec"));
foreach (var relativePath in relativePaths)
{
paths.Add(RelativePath.Create(m_context.StringTable, relativePath));
}
var packageOnDisk = new PackageOnDisk(
m_context.PathTable,
nugetPackage,
PackageDownloadResult.FromRemote(
new PackageIdentity("nuget", nugetPackage.Id, nugetPackage.Version, nugetPackage.Alias),
AbsolutePath.Create(m_context.PathTable, A("X", "Pkgs", "TestPkg", "1.999", "TestPkg.nuspec")),
paths));
return(NugetAnalyzedPackage.TryAnalyzeNugetPackage(m_context, m_monikers, XDocument.Parse(xml), packageOnDisk, packagesOnConfig, false));
}
private static void GetSpecialFiles(
PathTable pathTable,
PathAtom nuspecFileName,
PackageDownloadResult packageDownloadResult,
out AbsolutePath nuSpecFile,
out AbsolutePath moduleConfigFile)
{
nuSpecFile = AbsolutePath.Invalid;
moduleConfigFile = AbsolutePath.Invalid;
foreach (var relativePath in packageDownloadResult.Contents)
{
// Check for special files.
if (!relativePath.IsEmpty)
{
var fileName = relativePath.GetName();
if (fileName.CaseInsensitiveEquals(pathTable.StringTable, nuspecFileName))
{
nuSpecFile = packageDownloadResult.TargetLocation.Combine(pathTable, relativePath);
}
else if (IsModuleConfigFileName(fileName, pathTable.StringTable))
{
moduleConfigFile = packageDownloadResult.TargetLocation.Combine(pathTable, relativePath);
}
}
}
}
/// <inheritdoc />
/// <remarks>
/// This function should ideally queue up the work
/// </remarks>
public override async Task <Possible <PackageDownloadResult> > DownloadPackage(
string weakPackageFingerprint,
PackageIdentity package,
AbsolutePath packageTargetFolder,
Func <Task <Possible <IReadOnlyList <RelativePath> > > > producePackage)
{
// Check if we can reuse a package that is layed out on disk already.
// If the hash file is present packageHash variable will contain the content of it.
if (TryGetPackageFromFromDisk(package, packageTargetFolder, weakPackageFingerprint, out var possiblePackageFromDisk, out var packageHash))
{
return(possiblePackageFromDisk);
}
// Slower path: checking the cache first
var targetLocation = packageTargetFolder.ToString(PathTable);
var friendlyName = package.GetFriendlyName();
using (var pm = PerformanceMeasurement.StartWithoutStatistic(
LoggingContext,
nestedLoggingContext => m_logger.StartRetrievingPackage(nestedLoggingContext, friendlyName, targetLocation),
nestedLoggingContext => m_logger.EndRetrievingPackage(nestedLoggingContext, friendlyName)))
{
var loggingContext = pm.LoggingContext;
// Getting the package content from the cache
var packageFromCache = await TryGetPackageFromCache(loggingContext, weakPackageFingerprint, package, packageTargetFolder, packageHash);
if (!packageFromCache.Succeeded || packageFromCache.Result.IsValid)
{
// Cache failure or package was successfully obtained from the cache.
return(packageFromCache);
}
// Cache miss
m_logger.PackageNotFoundInCacheAndStartedDownloading(loggingContext, package.Id, package.Version);
// Step: We couldn't retrieve the package from the cache, or some blobs were missing, generate the package with the given function
var possiblePackageContents = await producePackage();
if (!possiblePackageContents.Succeeded)
{
return(possiblePackageContents.Failure);
}
// Now we can save the content to the cache
Analysis.IgnoreResult(
await TryAddPackageToCache(
loggingContext,
weakPackageFingerprint,
package,
packageTargetFolder,
possiblePackageContents.Result),
justification: "Okay to ignore putting in cache failure, will happen next time"
);
// Step: Return descriptor indicating it wasn't restored from the cache
return(PackageDownloadResult.FromRemote(package, packageTargetFolder, possiblePackageContents.Result));
}
}
private PackageDownloadResult CreatePackageDownloadResult(bool fromCache, string packageName, string version, string pkgFolder, List <RelativePath> relativePaths)
{
return(fromCache ?
PackageDownloadResult.FromCache(
new PackageIdentity("nuget", packageName, version, string.Empty),
AbsolutePath.Create(m_testContext.PathTable, pkgFolder),
relativePaths)
: PackageDownloadResult.FromRemote(
new PackageIdentity("nuget", packageName, version, string.Empty),
AbsolutePath.Create(m_testContext.PathTable, pkgFolder),
relativePaths));
}
public NugetAnalyzedPackage AnalyzePackageStub(Dictionary <string, INugetPackage> packagesOnConfig)
{
var nugetPackage = new NugetPackage()
{
Id = "TestPkgStub", Version = "1.999"
};
var packageOnDisk = new PackageOnDisk(
m_context.PathTable,
nugetPackage,
PackageDownloadResult.EmptyStub(
"testPackageStubHash",
new PackageIdentity("nuget", nugetPackage.Id, nugetPackage.Version, nugetPackage.Alias),
packageFolder: AbsolutePath.Create(m_context.PathTable, X("/X/Pkgs/TestPkgStub/1.999"))));
return(NugetAnalyzedPackage.TryAnalyzeNugetPackage(m_context, m_monikers, nuSpec: null, packageOnDisk, packagesOnConfig, false));
}
/// <nodoc />
public PackageOnDisk(PathTable pathTable, INugetPackage package, PackageDownloadResult packageDownloadResult)
{
Contract.Requires(pathTable != null);
Contract.Requires(package != null);
Contract.Requires(packageDownloadResult != null);
Package = package;
PackageDownloadResult = packageDownloadResult;
var nuspecFileName = PathAtom.Create(pathTable.StringTable, package.Id + ".nuspec");
GetSpecialFiles(pathTable, nuspecFileName, packageDownloadResult, out var nuSpecFile, out var moduleConfigFile);
NuSpecFile = nuSpecFile;
ModuleConfigFile = moduleConfigFile;
}
