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) { }