public NuGetv3LocalRepository(string path, LocalPackageFileCache packageFileCache, bool isFallbackFolder)
{
RepositoryRoot = path;
PathResolver = new VersionFolderPathResolver(path);
_packageFileCache = packageFileCache ?? new LocalPackageFileCache();
_isFallbackFolder = isFallbackFolder;
}
public async Task LocalPackageFileCache_UpdateLastAccessTimestampVerifyOnce()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var path = pathResolver.GetInstallPath(identity.Id, identity.Version);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var metadataPath = pathResolver.GetNupkgMetadataPath(identity.Id, identity.Version);
cache.UpdateLastAccessTime(metadataPath);
var lastAccess = File.GetLastAccessTimeUtc(metadataPath);
cache.UpdateLastAccessTime(metadataPath);
// Verify the last access timestamp was cached
Assert.Equal(lastAccess, File.GetLastAccessTimeUtc(metadataPath));
}
}
public async Task LocalPackageFileCache_GetShaTwiceVerifyMissingFilesAreNotCached()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var shaPath = pathResolver.GetNupkgMetadataPath(identity.Id, identity.Version);
var exists1 = cache.Sha512Exists(shaPath);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var exists2 = cache.Sha512Exists(shaPath);
var sha512 = cache.GetOrAddSha512(shaPath);
var sha512B = cache.GetOrAddSha512(shaPath);
// Verify original value was not found
exists1.Should().BeFalse();
// Verify false was not cached
exists2.Should().BeTrue();
// Verify both hashes are the exact same instance
Assert.Same(sha512.Value, sha512B.Value);
}
}
/// <summary>
/// Initializes a new <see cref="SourceRepositoryDependencyProvider" /> class.
/// </summary>
/// <param name="sourceRepository">A source repository.</param>
/// <param name="logger">A logger.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="ignoreFailedSources"><c>true</c> to ignore failed sources; otherwise <c>false</c>.</param>
/// <param name="ignoreWarning"><c>true</c> to ignore warnings; otherwise <c>false</c>.</param>
/// <param name="fileCache">Optional nuspec/file cache.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="sourceRepository" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> is <c>null</c>.</exception>
public SourceRepositoryDependencyProvider(
SourceRepository sourceRepository,
ILogger logger,
SourceCacheContext cacheContext,
bool ignoreFailedSources,
bool ignoreWarning,
LocalPackageFileCache fileCache,
bool isFallbackFolderSource)
{
if (sourceRepository == null)
{
throw new ArgumentNullException(nameof(sourceRepository));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
_sourceRepository = sourceRepository;
_logger = logger;
_cacheContext = cacheContext;
_ignoreFailedSources = ignoreFailedSources;
_ignoreWarning = ignoreWarning;
_packageFileCache = fileCache;
_isFallbackFolderSource = isFallbackFolderSource;
}
public NuGetv3LocalRepository(string path, LocalPackageFileCache packageFileCache, bool isFallbackFolder, bool updateLastAccessTime)
{
RepositoryRoot = path;
PathResolver = new VersionFolderPathResolver(path);
_packageFileCache = packageFileCache ?? new LocalPackageFileCache();
_isFallbackFolder = isFallbackFolder;
_updateLastAccessTime = updateLastAccessTime;
}
/// <summary>
/// Providers used by the restore command. These can be shared across restores.
/// </summary>
/// <param name="globalPackages">Path to the global packages folder.</param>
/// <param name="fallbackPackageFolders">Path to any fallback package folders.</param>
/// <param name="localProviders">This is typically just a provider for the global packages folder.</param>
/// <param name="remoteProviders">All dependency providers.</param>
/// <param name="packageFileCache">Nuspec and package file cache.</param>
public RestoreCommandProviders(
NuGetv3LocalRepository globalPackages,
IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders,
IReadOnlyList <IRemoteDependencyProvider> localProviders,
IReadOnlyList <IRemoteDependencyProvider> remoteProviders,
LocalPackageFileCache packageFileCache)
{
GlobalPackages = globalPackages ?? throw new ArgumentNullException(nameof(globalPackages));
LocalProviders = localProviders ?? throw new ArgumentNullException(nameof(localProviders));
RemoteProviders = remoteProviders ?? throw new ArgumentNullException(nameof(remoteProviders));
FallbackPackageFolders = fallbackPackageFolders ?? throw new ArgumentNullException(nameof(fallbackPackageFolders));
PackageFileCache = packageFileCache ?? throw new ArgumentNullException(nameof(packageFileCache));
}
/// <summary>
/// Initializes a new <see cref="SourceRepositoryDependencyProvider" /> class.
/// </summary>
/// <param name="sourceRepository">A source repository.</param>
/// <param name="logger">A logger.</param>
/// <param name="cacheContext">A source cache context.</param>
/// <param name="ignoreFailedSources"><c>true</c> to ignore failed sources; otherwise <c>false</c>.</param>
/// <param name="ignoreWarning"><c>true</c> to ignore warnings; otherwise <c>false</c>.</param>
/// <param name="fileCache">Optional nuspec/file cache.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="sourceRepository" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception>
public SourceRepositoryDependencyProvider(
SourceRepository sourceRepository,
ILogger logger,
SourceCacheContext cacheContext,
bool ignoreFailedSources,
bool ignoreWarning,
LocalPackageFileCache fileCache,
bool isFallbackFolderSource) :
this(sourceRepository,
logger,
cacheContext,
ignoreFailedSources,
ignoreWarning,
fileCache,
isFallbackFolderSource,
environmentVariableReader : EnvironmentVariableWrapper.Instance)
{
}
internal SourceRepositoryDependencyProvider(
SourceRepository sourceRepository,
ILogger logger,
SourceCacheContext cacheContext,
bool ignoreFailedSources,
bool ignoreWarning,
LocalPackageFileCache fileCache,
bool isFallbackFolderSource,
IEnvironmentVariableReader environmentVariableReader)
{
_sourceRepository = sourceRepository ?? throw new ArgumentNullException(nameof(sourceRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_cacheContext = cacheContext ?? throw new ArgumentNullException(nameof(cacheContext));
_ignoreFailedSources = ignoreFailedSources;
_ignoreWarning = ignoreWarning;
_packageFileCache = fileCache;
_isFallbackFolderSource = isFallbackFolderSource;
_useLegacyAssetTargetFallbackBehavior = MSBuildStringUtility.IsTrue(environmentVariableReader.GetEnvironmentVariable("NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION"));
}
public void LocalPackageFileCache_DirNotFoundVerifyFailure()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version);
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
// Verify does not throw
var result = cache.GetOrAddNuspec(nuspec, expanded);
// This should throw
Assert.Throws <DirectoryNotFoundException>(() => result.Value);
}
}
public async Task LocalPackageFileCache_FallbackToFolderReaderVerifyResult()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version) + "invalid.nuspec";
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
var result = cache.GetOrAddNuspec(nuspec, expanded);
result.Value.GetIdentity().Should().Be(identity);
}
}
public async Task LocalPackageFileCache_GetFilesTwiceVerifySameInstance()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
var path = pathResolver.GetInstallPath(identity.Id, identity.Version);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var filesA = cache.GetOrAddFiles(path);
var filesB = cache.GetOrAddFiles(path);
// Verify both file lists are the exact same instance
Assert.Same(filesA.Value, filesB.Value);
filesA.Value.Should().NotBeEmpty();
}
}
public async Task LocalPackageFileCache_GetNuspecTwiceVerifySameInstance()
{
using (var pathContext = new SimpleTestPathContext())
{
var cache = new LocalPackageFileCache();
var pathResolver = new VersionFolderPathResolver(pathContext.PackageSource);
var identity = new PackageIdentity("X", NuGetVersion.Parse("1.0.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
identity);
var nuspec = pathResolver.GetManifestFilePath(identity.Id, identity.Version);
var expanded = pathResolver.GetInstallPath(identity.Id, identity.Version);
var result1 = cache.GetOrAddNuspec(nuspec, expanded);
var result2 = cache.GetOrAddNuspec(nuspec, expanded);
Assert.Same(result1.Value, result2.Value);
result1.Value.GetIdentity().Should().Be(identity);
}
}
private static IEnumerable <string> GetPackageFiles(LocalPackageFileCache packageFileCache, string packageId, NuGetVersion version, IEnumerable <VersionFolderPathResolver> resolvers)
{
foreach (var resolver in resolvers)
{
// Verify the SHA for each package
var hashPath = resolver.GetHashPath(packageId, version);
if (packageFileCache.Sha512Exists(hashPath))
{
yield return(hashPath);
break;
}
var nupkgMetadataPath = resolver.GetNupkgMetadataPath(packageId, version);
if (packageFileCache.Sha512Exists(nupkgMetadataPath))
{
yield return(nupkgMetadataPath);
break;
}
}
}
public static RestoreCommandProviders Create(
string globalFolderPath,
IEnumerable <string> fallbackPackageFolderPaths,
IEnumerable <SourceRepository> sources,
SourceCacheContext cacheContext,
LocalPackageFileCache packageFileCache,
ILogger log)
{
var isFallbackFolder = false;
var globalPackages = new NuGetv3LocalRepository(globalFolderPath, packageFileCache, isFallbackFolder);
var globalPackagesSource = Repository.Factory.GetCoreV3(globalFolderPath, FeedType.FileSystemV3);
var localProviders = new List <IRemoteDependencyProvider>()
{
// Do not throw or warn for global cache
new SourceRepositoryDependencyProvider(
globalPackagesSource,
log,
cacheContext,
ignoreFailedSources: true,
ignoreWarning: true,
fileCache: packageFileCache,
isFallbackFolderSource: isFallbackFolder)
};
// Add fallback sources as local providers also
var fallbackPackageFolders = new List <NuGetv3LocalRepository>();
isFallbackFolder = true;
foreach (var path in fallbackPackageFolderPaths)
{
var fallbackRepository = new NuGetv3LocalRepository(path, packageFileCache, isFallbackFolder);
var fallbackSource = Repository.Factory.GetCoreV3(path, FeedType.FileSystemV3);
var provider = new SourceRepositoryDependencyProvider(
fallbackSource,
log,
cacheContext,
ignoreFailedSources: false,
ignoreWarning: false,
fileCache: packageFileCache,
isFallbackFolderSource: isFallbackFolder);
fallbackPackageFolders.Add(fallbackRepository);
localProviders.Add(provider);
}
isFallbackFolder = false;
var remoteProviders = new List <IRemoteDependencyProvider>();
foreach (var source in sources)
{
var provider = new SourceRepositoryDependencyProvider(
source,
log,
cacheContext,
cacheContext.IgnoreFailedSources,
ignoreWarning: false,
fileCache: packageFileCache,
isFallbackFolderSource: isFallbackFolder);
remoteProviders.Add(provider);
}
return(new RestoreCommandProviders(
globalPackages,
fallbackPackageFolders,
localProviders,
remoteProviders,
packageFileCache));
}
private static bool IsPackageOnDisk(ISet <PackageIdentity> packagesChecked, IEnumerable <VersionFolderPathResolver> pathResolvers, LocalPackageFileCache packageFileCache, PackageIdentity identity)
{
// Each id/version only needs to be checked once
if (packagesChecked.Add(identity))
{
// Check each package folder. These need to match the order used for restore.
foreach (var resolver in pathResolvers)
{
// Verify the SHA for each package
var hashPath = resolver.GetHashPath(identity.Id, identity.Version);
var nupkgMetadataPath = resolver.GetNupkgMetadataPath(identity.Id, identity.Version);
if (packageFileCache.Sha512Exists(hashPath) ||
packageFileCache.Sha512Exists(nupkgMetadataPath))
{
return(true);
}
}
return(false);
}
return(true);
}
/// <summary>
/// Creates new instance of <see cref="BoundRestoreCommandUser"/> with given parameters.
/// </summary>
/// <param name="nugetSettings">The settings to use.</param>
/// <param name="thisFramework">The framework to bind to.</param>
/// <param name="runtimeIdentifier">The runtime identifier. Will be used by <see cref="E_NuGetUtils.ExtractAssemblyPaths{TResult}(BoundRestoreCommandUser, LockFile, Func{String, IEnumerable{String}, TResult}, GetFileItemsDelegate, IEnumerable{String})"/> method.</param>
/// <param name="runtimeGraph">Optional value indicating runtime graph information: either <see cref="global::NuGet.RuntimeModel.RuntimeGraph"/> directly, or <see cref="String"/> containing package ID of package holding <c>runtime.json</c> file, containing serialized runtime graph definition. If neither is specified, then <c>"Microsoft.NETCore.Platforms"</c> package ID used to locate <c>runtime.json</c> file, as per <see href="https://docs.microsoft.com/en-us/dotnet/core/rid-catalog">official documentation</see>.</param>
/// <param name="nugetLogger">The logger to use in restore command.</param>
/// <param name="sourceCacheContext">The optional <see cref="SourceCacheContext"/> to use.</param>
/// <param name="nuspecCache">The optional <see cref="LocalPackageFileCache"/> to use.</param>
/// <param name="clientPolicyContext">The optional <see cref="ClientPolicyContext"/> to use.</param>
/// <param name="leaveSourceCacheOpen">Whether to leave the <paramref name="sourceCacheContext"/> open when disposing this <see cref="BoundRestoreCommandUser"/>.</param>
/// <param name="lockFileCacheDir">The directory where to store serialized lock files returned by <see cref="RestoreIfNeeded"/>. If <c>null</c> or empty, then <paramref name="lockFileCacheEnvironmentVariableName"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="lockFileCacheEnvironmentVariableName">The name of the environment variable containing the value for lock file cache directory. If <c>null</c> or empty, then environment variable reading will be skipped. If the environment variable itself is <c>null</c> or empty, then the user's home directory in conjunction with <paramref name="getDefaultLockFileCacheDir"/> will be used to deduce lock file cache directory. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="getDefaultLockFileCacheDir">This callback will be used when <paramref name="lockFileCacheEnvironmentVariableName"/> is <c>null</c> or empty or when the named environment variable itself was <c>null</c> or empty. This callback will receive current user's home directory as parameter and should return the lock file cache directory. If <c>null</c>, then <see cref="GetDefaultLockFileDir"/> will be used. Set <paramref name="disableLockFileCacheDir"/> to true to disable caching lock files to file system.</param>
/// <param name="disableLockFileCacheDir">This variable controls whether the results of <see cref="RestoreIfNeeded"/> will be stored to file system lock file cache directory. By default, the lock file caching is enabled. Set this parameter to <c>true</c> to completely disable caching lock files to file system.</param>
/// <exception cref="ArgumentNullException">If <paramref name="nugetSettings"/> is <c>null</c>.</exception>
public BoundRestoreCommandUser(
ISettings nugetSettings,
NuGetFramework thisFramework = null,
String runtimeIdentifier = null,
EitherOr <RuntimeGraph, String> runtimeGraph = default,
ILogger nugetLogger = null,
SourceCacheContext sourceCacheContext = null,
LocalPackageFileCache nuspecCache = null,
ClientPolicyContext clientPolicyContext = null,
Boolean leaveSourceCacheOpen = false,
String lockFileCacheDir = null,
String lockFileCacheEnvironmentVariableName = DEFAULT_LOCK_FILE_CACHE_DIR_ENV_NAME,
Func <String, String> getDefaultLockFileCacheDir = null,
Boolean disableLockFileCacheDir = false
)
{
ArgumentValidator.ValidateNotNull(nameof(nugetSettings), nugetSettings);
this.ThisFramework = thisFramework ?? NuGetUtility.TryAutoDetectThisProcessFramework();
if (nugetLogger == null)
{
nugetLogger = NullLogger.Instance;
}
var global = SettingsUtility.GetGlobalPackagesFolder(nugetSettings);
var fallbacks = SettingsUtility.GetFallbackPackageFolders(nugetSettings);
if (sourceCacheContext == null)
{
leaveSourceCacheOpen = false;
}
var ctx = sourceCacheContext ?? new SourceCacheContext();
var psp = new PackageSourceProvider(nugetSettings);
var csp = new CachingSourceProvider(psp);
this.RuntimeIdentifier = NuGetUtility.TryAutoDetectThisProcessRuntimeIdentifier(runtimeIdentifier);
this._cacheContext = ctx;
this._disposeSourceCacheContext = !leaveSourceCacheOpen;
this.NuGetLogger = nugetLogger;
this._restoreCommandProvider = RestoreCommandProviders.Create(
global,
fallbacks,
new PackageSourceProvider(nugetSettings).LoadPackageSources().Where(s => s.IsEnabled).Select(s => csp.CreateRepository(s)),
ctx,
nuspecCache ?? new LocalPackageFileCache(),
nugetLogger
);
this._nugetRestoreRootDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
this._restoreTargetFW = new TargetFrameworkInformation()
{
FrameworkName = this.ThisFramework
};
this.LocalRepositories = this._restoreCommandProvider.GlobalPackages.Singleton()
.Concat(this._restoreCommandProvider.FallbackPackageFolders)
.ToImmutableDictionary(r => r.RepositoryRoot, r => r);
this.RuntimeGraph = new Lazy <RuntimeGraph>(() =>
{
var rGraph = runtimeGraph.GetFirstOrDefault();
if (rGraph == null)
{
var packageName = runtimeGraph.GetSecondOrDefault();
if (String.IsNullOrEmpty(packageName))
{
packageName = DEFAULT_RUNTIME_GRAPH_PACKAGE_ID;
}
var platformsPackagePath = this.LocalRepositories.Values
.SelectMany(r => r.FindPackagesById(packageName))
.OrderByDescending(p => p.Version)
.FirstOrDefault()
?.ExpandedPath;
rGraph = String.IsNullOrEmpty(platformsPackagePath) ?
null :
JsonRuntimeFormat.ReadRuntimeGraph(Path.Combine(platformsPackagePath, global::NuGet.RuntimeModel.RuntimeGraph.RuntimeGraphFileName));
}
return(rGraph);
}, LazyThreadSafetyMode.ExecutionAndPublication);
if (!disableLockFileCacheDir)
{
this.DiskCacheDirectory = lockFileCacheDir
.OrIfNullOrEmpty(String.IsNullOrEmpty(lockFileCacheEnvironmentVariableName) ? null : Environment.GetEnvironmentVariable(lockFileCacheEnvironmentVariableName))
.OrIfNullOrEmpty((getDefaultLockFileCacheDir ?? GetDefaultLockFileDir)(Environment.GetEnvironmentVariable(
#if NET46
Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32S || Environment.OSVersion.Platform == PlatformID.Win32Windows || Environment.OSVersion.Platform == PlatformID.WinCE
#else
System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows)
#endif
? "USERPROFILE" : "HOME"))
)
.OrIfNullOrEmpty(null);
}
this._allLockFiles = new ConcurrentDictionary <ImmutableSortedSet <String>, ImmutableDictionary <ImmutableArray <NuGetVersion>, String> >();
this._lockFileFormat = new LockFileFormat();
this._clientPolicyContext = clientPolicyContext ?? ClientPolicyContext.GetClientPolicy(nugetSettings, nugetLogger);
}
public NuGetv3LocalRepository(string path, LocalPackageFileCache packageFileCache, bool isFallbackFolder)
: this(path, packageFileCache, isFallbackFolder, updateLastAccessTime : false)
{
}
