protected override void Dispose(bool disposing) { if (!_isDisposed) { foreach (var pair in _fileStreams) { if (pair.Value.Value.Status == TaskStatus.RanToCompletion) { var fileStream = pair.Value.Value.Result; if (fileStream != null) { fileStream.Dispose(); } } } _fileStreams.Clear(); _plugin.Dispose(); _getFilesSemaphore.Dispose(); _getNuspecReaderSemaphore.Dispose(); if (_tempDirectoryPath.IsValueCreated) { LocalResourceUtils.DeleteDirectoryTree(_tempDirectoryPath.Value, new List <string>()); } _isDisposed = true; } }
private bool ClearCacheDirectory(string folderPath) { // In order to get detailed error messages, we need to do recursion ourselves. var failedDeletes = new List <string>(); LocalResourceUtils.DeleteDirectoryTree(folderPath, failedDeletes); if (failedDeletes.Any()) { Console.WriteWarning( LocalizedResourceManager.GetString(nameof(NuGetResources.LocalsCommand_LocalsPartiallyCleared))); foreach (var failedDelete in failedDeletes.OrderBy(f => f, StringComparer.OrdinalIgnoreCase)) { Console.WriteWarning( LocalizedResourceManager.GetString(nameof(NuGetResources.LocalsCommand_FailedToDeletePath)), failedDelete); } return(false); } else { return(true); } }
public void Dispose() { LocalResourceUtils.DeleteDirectoryTree( Path.Combine( SettingsUtility.GetPluginsCacheFolder(), CachingUtility.RemoveInvalidFileNameChars(CachingUtility.ComputeHash(_pluginFilePath))), new List <string>()); PluginManager.Dispose(); _testDirectory.Dispose(); _reader.Verify(); _pluginDiscoverer.Verify(); foreach (var expectation in _expectations) { _connection.Verify(x => x.SendRequestAndReceiveResponseAsync <GetOperationClaimsRequest, GetOperationClaimsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.GetOperationClaims), It.Is <GetOperationClaimsRequest>( g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source), It.IsAny <CancellationToken>()), Times.Once()); var expectedSetCredentialsRequestCalls = expectation.OperationClaims.Any() ? Times.Once() : Times.Never(); _connection.Verify(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials), It.Is <SetCredentialsRequest>( g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source), It.IsAny <CancellationToken>()), expectedSetCredentialsRequestCalls); } _plugin.Verify(); _factory.Verify(); }
public void DeleteDirectoryTreeDeletesReparsePointsButNotReparsePointTargets() { // This test creates a cached package and a subdirectory in the working directory. // The subdirectory is a reparse point linked to the target directory. // Deleting the directory tree should delete the reparse point, but not the target of the reparse point. // The cached package in the working directory should also be deleted. // The also creates a dummy file in the linked target directory, and verifies // this file is left as-is after deletion of the directory tree including the reparse point. // Finally, test clean-up is verified. var failedDeletes = new List <string>(); string targetDirectoryPath; string fileInTargetDirectory; using (var targetDirectory = TestDirectory.Create()) { // Arrange targetDirectoryPath = targetDirectory.Path; using (var workingDirectory = TestDirectory.Create()) { var subDirectoryPath = Path.Combine(workingDirectory.Path, "SubDirectory"); var subDirectory = Directory.CreateDirectory(subDirectoryPath); Util.CreatePackage(workingDirectory.Path, Guid.NewGuid().ToString("N"), "1.0.0"); fileInTargetDirectory = Path.Combine(targetDirectoryPath, "test.txt"); File.WriteAllText(fileInTargetDirectory, string.Empty); Util.CreateJunctionPoint(subDirectory.FullName, targetDirectoryPath, overwrite: true); // Act LocalResourceUtils.DeleteDirectoryTree(workingDirectory.Path, failedDeletes); // Assert Assert.Empty(failedDeletes); Assert.False(Directory.Exists(workingDirectory.Path)); Assert.True(Directory.Exists(targetDirectoryPath)); Assert.True(File.Exists(fileInTargetDirectory)); } } // Verify clean-up Assert.False(Directory.Exists(targetDirectoryPath)); Assert.False(File.Exists(fileInTargetDirectory)); }
public void Dispose() { LocalResourceUtils.DeleteDirectoryTree( Path.Combine( SettingsUtility.GetPluginsCacheFolder(), CachingUtility.RemoveInvalidFileNameChars(CachingUtility.ComputeHash(_pluginFilePath))), new List <string>()); PluginManager.Dispose(); _reader.Verify(); _pluginDiscoverer.Verify(); if (_expectations.PluginLaunched) { _connection.Verify(x => x.SendRequestAndReceiveResponseAsync <GetOperationClaimsRequest, GetOperationClaimsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.GetOperationClaims), It.Is <GetOperationClaimsRequest>( g => g.PackageSourceRepository == null), // The source repository should be null in the context of credential plugins It.IsAny <CancellationToken>()), Times.Once()); if (_expectations.Success) { _connection.Verify(x => x.SendRequestAndReceiveResponseAsync <GetAuthenticationCredentialsRequest, GetAuthenticationCredentialsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.GetAuthenticationCredentials), It.IsAny <GetAuthenticationCredentialsRequest>(), It.IsAny <CancellationToken>()), Times.Once()); } if (_expectations.ProxyUsername != null && _expectations.ProxyPassword != null) { _connection.Verify(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials), It.Is <SetCredentialsRequest>(e => e.PackageSourceRepository.Equals(_expectations.Uri.AbsolutePath) && e.Password == null && e.Username == null && e.ProxyPassword.Equals(_expectations.ProxyPassword) && e.ProxyUsername.Equals(_expectations.ProxyUsername)), It.IsAny <CancellationToken>()), Times.Once()); } } _connection.Verify(); _plugin.Verify(); _factory.Verify(); _testDirectory.Dispose(); }
public void CleanupPackagesFolder() { var unusedPackages = _localPackageRepository .GetPackages() .ToList() .Where(x => !_loadedMsBuildNuGetProjects .SelectMany(y => y.Value.GetInstalledPackagesAsync(new CancellationToken()).Result) .Select(y => y.PackageIdentity) .Any(y => y.Id == x.Id && y.Version.ToString() == x.Version.ToString())) .ToArray(); foreach (IPackage package in unusedPackages) { var pathToDelete = Path.Combine(_packagesFolder, $"{package.Id}.{package.Version}"); // One would think Directory.Delete(path, recursive: true) would do the job, well // it regularly fails, and looking online it seems the solution is try/catches with // retries and recursive deletes. Well guess what, Nuget has one of those // monstrosities already, hooray! LocalResourceUtils.DeleteDirectoryTree(pathToDelete, new List <string>()); } }
/// <summary> /// Recursively deletes the specified directory tree. /// </summary> /// <param name="folderPath">Specified directory to be deleted</param> /// <returns><code>True</code> if the operation was successful; otherwise <code>false</code>.</returns> private bool ClearCacheDirectory(string folderPath, LocalsArgs localsArgs) { // In order to get detailed error messages, we need to do recursion ourselves. var failedDeletes = new List <string>(); LocalResourceUtils.DeleteDirectoryTree(folderPath, failedDeletes); if (failedDeletes.Any()) { localsArgs.LogInformation(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_LocalsPartiallyCleared)); foreach (var failedDelete in failedDeletes.OrderBy(f => f, StringComparer.OrdinalIgnoreCase)) { localsArgs.LogError(string.Format(CultureInfo.CurrentCulture, Strings.LocalsCommand_FailedToDeletePath, failedDelete)); } return(false); } else { return(true); } }
/// <summary> /// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json). /// </summary> /// <param name="libraryIdentity">The <see cref="LibraryIdentity"/> of the package.</param> /// <param name="settings">The NuGet settings to use.</param> /// <param name="logger">An <see cref="ILogger"/> to use for logging.</param> /// <returns></returns> public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(LibraryIdentity libraryIdentity, ISettings settings, ILogger logger) { using (var sourceCacheContext = new SourceCacheContext { IgnoreFailedSources = true, }) { // Create a unique temporary directory for the project var projectDirectory = Directory.CreateDirectory(Path.Combine(NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), Guid.NewGuid().ToString("N"))); try { var projectName = Guid.NewGuid().ToString("N"); var projectFullPath = Path.Combine(projectDirectory.FullName, $"{projectName}.proj"); // The package spec details what packages to restore var packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation { FrameworkName = i, }).ToList()) { Dependencies = new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange( libraryIdentity.Name, new VersionRange( minVersion: libraryIdentity.Version, includeMinVersion: true, maxVersion: libraryIdentity.Version, includeMaxVersion: true), LibraryDependencyTarget.Package), SuppressParent = LibraryIncludeFlags.All, AutoReferenced = true, IncludeType = LibraryIncludeFlags.None, Type = LibraryDependencyType.Build } }, RestoreMetadata = new ProjectRestoreMetadata { ProjectPath = projectFullPath, ProjectName = projectName, ProjectStyle = ProjectStyle.PackageReference, ProjectUniqueName = projectFullPath, OutputPath = projectDirectory.FullName, OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(), ConfigFilePaths = settings.GetConfigFilePaths(), PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings), Sources = SettingsUtility.GetEnabledSources(settings).ToList(), FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList() }, FilePath = projectFullPath, Name = projectName, }; var dependencyGraphSpec = new DependencyGraphSpec(); dependencyGraphSpec.AddProject(packageSpec); dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName); IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec); var restoreArgs = new RestoreArgs { AllowNoOp = false, CacheContext = sourceCacheContext, #pragma warning disable CS0618 // Type or member is obsolete CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false)), #pragma warning restore CS0618 // Type or member is obsolete Log = logger, }; // Create requests from the arguments var requests = requestProvider.CreateRequests(restoreArgs).Result; // Restore the package without generating extra files return(RestoreRunner.RunWithoutCommit(requests, restoreArgs)); } finally { LocalResourceUtils.DeleteDirectoryTree(projectDirectory.FullName, new List <string>()); } } }