public PluginManagerViewModel( IPluginManager pluginManager, IUIServices uiServices, IPackageChooser packageChooser, IPackageDownloader packageDownloader) { if (pluginManager == null) { throw new ArgumentNullException("pluginManager"); } if (packageChooser == null) { throw new ArgumentNullException("packageChooser"); } if (uiServices == null) { throw new ArgumentNullException("uiServices"); } if (packageDownloader == null) { throw new ArgumentNullException("packageDownloader"); } _pluginManager = pluginManager; _uiServices = uiServices; _packageChooser = packageChooser; _packageDownloader = packageDownloader; DeleteCommand = new RelayCommand <PluginInfo>(DeleteCommandExecute, DeleteCommandCanExecute); AddCommand = new RelayCommand <string>(AddCommandExecute); }
/// <summary> /// Asynchronously gets a package downloader for a package identity. /// </summary> /// <param name="packageIdentity">A package identity.</param> /// <param name="cacheContext">A source cache context.</param> /// <param name="logger">A logger.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation. /// The task result (<see cref="Task{TResult}.Result" />) returns an <see cref="IPackageDownloader" />.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public override Task <IPackageDownloader> GetPackageDownloaderAsync( PackageIdentity packageIdentity, SourceCacheContext cacheContext, ILogger logger, CancellationToken cancellationToken) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (cacheContext == null) { throw new ArgumentNullException(nameof(cacheContext)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } cancellationToken.ThrowIfCancellationRequested(); var packageInfo = GetPackageInfo(packageIdentity.Id, packageIdentity.Version, cacheContext, logger); IPackageDownloader packageDownloader = null; if (packageInfo != null) { packageDownloader = new LocalPackageArchiveDownloader(packageInfo.Path, packageInfo.Identity, logger); } return(Task.FromResult(packageDownloader)); }
public DataServicePackageRepository(IHttpClient client, IPackageDownloader packageDownloader) { if (client == null) { throw new ArgumentNullException("client"); } if (packageDownloader == null) { throw new ArgumentNullException("packageDownloader"); } _httpClient = client; _httpClient.AcceptCompression = true; _packageDownloader = packageDownloader; if (EnvironmentUtility.RunningFromCommandLine || EnvironmentUtility.IsMonoRuntime) { _packageDownloader.SendingRequest += OnPackageDownloaderSendingRequest; } else { // weak event pattern #if NETFRAMEWORK SendingRequestEventManager.AddListener(_packageDownloader, this); #endif } }
public BootStrapperManager(ILogger logger, IPackageDownloader downloader, IPackageRunner runner, IPackageUnzipper unzipper, IPackageUploader uploader = null, IPackageZipper zipper = null) { this.downloader = downloader; this.runner = runner; this.unzipper = unzipper; this.uploader = uploader; this.zipper = zipper; }
public ValidationPackageFileService( ICoreFileStorageService fileStorageService, IPackageDownloader packageDownloader, ILogger <ValidationPackageFileService> logger) : base(fileStorageService) { _fileStorageService = fileStorageService ?? throw new ArgumentNullException(nameof(fileStorageService)); _packageDownloader = packageDownloader ?? throw new ArgumentNullException(nameof(packageDownloader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public static RestoreTargetGraph GetRestoreTargetGraph( string source, PackageIdentity identity, FileInfo packagePath, TestLogger logger) { var libraryRange = new LibraryRange { Name = identity.Id }; var libraryIdentity = new LibraryIdentity(identity.Id, identity.Version, LibraryType.Package); var dependencyProvider = new Mock <IRemoteDependencyProvider>(); IPackageDownloader packageDependency = null; dependencyProvider .Setup(x => x.GetPackageDownloaderAsync( It.IsAny <PackageIdentity>(), It.IsAny <SourceCacheContext>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>())) .Callback <PackageIdentity, SourceCacheContext, ILogger, CancellationToken>( (callbackIdentity, sourceCacheContext, callbackLogger, cancellationToken) => { packageDependency = new LocalPackageArchiveDownloader( source, packagePath.FullName, callbackIdentity, callbackLogger); }) .Returns(() => Task.FromResult(packageDependency)); var graph = RestoreTargetGraph.Create( new[] { new GraphNode <RemoteResolveResult>(libraryRange) { Item = new GraphItem <RemoteResolveResult>(libraryIdentity) { Data = new RemoteResolveResult { Match = new RemoteMatch { Library = libraryIdentity, Provider = dependencyProvider.Object } } } } }, new TestRemoteWalkContext(), logger, FrameworkConstants.CommonFrameworks.NetStandard16); return(graph); }
/// <summary> /// Instantiate's a new package signatures validator. /// </summary> /// <param name="httpClient">The HTTP client used to download packages.</param> /// <param name="validatorStateService">The service used to retrieve and persist this validator's state.</param> /// <param name="packageSigningStateService">The service used to retrieve and persist package signing state.</param> /// <param name="logger">The logger that should be used.</param> public SignatureValidationMessageHandler( IPackageDownloader packageDownloader, IValidatorStateService validatorStateService, ISignatureValidator signatureValidator, ILogger <SignatureValidationMessageHandler> logger) { _packageDownloader = packageDownloader ?? throw new ArgumentNullException(nameof(packageDownloader)); _validatorStateService = validatorStateService ?? throw new ArgumentNullException(nameof(validatorStateService)); _signatureValidator = signatureValidator ?? throw new ArgumentNullException(nameof(signatureValidator)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public LocalPackageFileUpdater1(IRemotePackageManager remotePackageManager, IFileSystemAccesor fileSystemAccesor, IPackageDownloader packageDownloader, IR2RestClient r2RestClient) { _remote = remotePackageManager; _file = fileSystemAccesor; _client = r2RestClient; _client.OnRetry += (s, e) => SetStatus(e); _downloadr = packageDownloader; _downloadr.StatusChanged += (s, e) => SetStatus(e); }
public MirrorService( Uri packageBaseAddress, IPackageService localPackages, IPackageDownloader downloader, IIndexingService indexer, ILogger <MirrorService> logger) { _packageBaseAddress = packageBaseAddress ?? throw new ArgumentNullException(nameof(packageBaseAddress)); _localPackages = localPackages ?? throw new ArgumentNullException(nameof(localPackages)); _downloader = downloader ?? throw new ArgumentNullException(nameof(downloader)); _indexer = indexer ?? throw new ArgumentNullException(nameof(indexer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public MirrorService( IPackageService localPackages, IPackageMetadataService upstreamFeed, IPackageDownloader downloader, IPackageIndexingService indexer, ILogger <MirrorService> logger) { _localPackages = localPackages ?? throw new ArgumentNullException(nameof(localPackages)); _upstreamFeed = upstreamFeed ?? throw new ArgumentNullException(nameof(upstreamFeed)); _downloader = downloader ?? throw new ArgumentNullException(nameof(downloader)); _indexer = indexer ?? throw new ArgumentNullException(nameof(indexer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public PackagePhysicalFileMetadata DownloadPackage( string packageId, IVersion version, string feedId, Uri feedUri, FeedType feedType, ICredentials feedCredentials, bool forcePackageDownload, int maxDownloadAttempts, TimeSpan downloadAttemptBackoff) { IPackageDownloader downloader = null; switch (feedType) { case FeedType.Maven: downloader = new MavenPackageDownloader(fileSystem, freeSpaceChecker); break; case FeedType.NuGet: downloader = new NuGetPackageDownloader(fileSystem, freeSpaceChecker); break; case FeedType.GitHub: downloader = new GitHubPackageDownloader(log, fileSystem, freeSpaceChecker); break; case FeedType.Helm: downloader = new HelmChartPackageDownloader(fileSystem); break; case FeedType.Docker: case FeedType.AwsElasticContainerRegistry: downloader = new DockerImagePackageDownloader(engine, fileSystem, commandLineRunner, variables); break; default: throw new NotImplementedException($"No Calamari downloader exists for feed type `{feedType}`."); } Log.Verbose($"Feed type provided `{feedType}` using {downloader.GetType().Name}"); return(downloader.DownloadPackage( packageId, version, feedId, feedUri, feedCredentials, forcePackageDownload, maxDownloadAttempts, downloadAttemptBackoff)); }
public D8PackageUploader(IFileSystemAccesor fileSystemAccesor, IFileArchiver fileArchiver, IPartSender partSender, IRemotePackageManager packageManager, IPackageDownloader packageDownloader) { _fileIO = fileSystemAccesor; _archivr = fileArchiver; _sendr = partSender; _pkgMgr = packageManager; _downloadr = packageDownloader; _sendr.StatusChanged += (s, statusText) => SetStatus(statusText); }
public MirrorService( INuGetClient client, IPackageCacheService localPackages, IPackageDownloader downloader, ILogger <MirrorService> logger, MirrorOptions options) { _startLock = new object(); _downloads = new Dictionary <PackageIdentity, Task>(); _localPackages = localPackages ?? throw new ArgumentNullException(nameof(localPackages)); _downloader = downloader ?? throw new ArgumentNullException(nameof(downloader)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); this._loggerAdapter = new NuGetLoggerAdapter <MirrorService>(_logger); _sourceRepository = client.GetRepository(options.UpstreamIndex); }
/// <summary> /// Asynchronously gets a package downloader for a package identity. /// </summary> /// <param name="packageIdentity">A package identity.</param> /// <param name="cacheContext">A source cache context.</param> /// <param name="logger">A logger.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation. /// The task result (<see cref="Task{TResult}.Result" />) returns an <see cref="IPackageDownloader" />.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public override Task <IPackageDownloader> GetPackageDownloaderAsync( PackageIdentity packageIdentity, SourceCacheContext cacheContext, ILogger logger, CancellationToken cancellationToken) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (cacheContext == null) { throw new ArgumentNullException(nameof(cacheContext)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } var stopwatch = Stopwatch.StartNew(); try { cancellationToken.ThrowIfCancellationRequested(); var packageInfo = GetPackageInfo(packageIdentity.Id, packageIdentity.Version, cacheContext, logger); IPackageDownloader packageDownloader = null; if (packageInfo != null) { packageDownloader = new LocalPackageArchiveDownloader(_source, packageInfo.Path, packageInfo.Identity, logger); } return(Task.FromResult(packageDownloader)); } finally { ProtocolDiagnostics.RaiseEvent(new ProtocolDiagnosticResourceEvent( _source, ResourceTypeName, ThisTypeName, nameof(GetPackageDownloaderAsync), stopwatch.Elapsed)); } }
public static PackagePhysicalFileMetadata DownloadPackage( string packageId, IVersion version, string feedId, Uri feedUri, FeedType feedType, ICredentials feedCredentials, bool forcePackageDownload, int maxDownloadAttempts, TimeSpan downloadAttemptBackoff) { IPackageDownloader downloader = null; switch (feedType) { case FeedType.Maven: downloader = new MavenPackageDownloader(); break; case FeedType.NuGet: downloader = new NuGetPackageDownloader(); break; case FeedType.GitHub: downloader = new GitHubPackageDownloader(); break; default: throw new NotImplementedException($"No Calamari downloader exists for feed type `{feedType}`."); } Log.Verbose($"Feed type provided `{feedType}` using {downloader.GetType().Name}"); return(downloader.DownloadPackage( packageId, version, feedId, feedUri, feedCredentials, forcePackageDownload, maxDownloadAttempts, downloadAttemptBackoff)); }
public void DownloadPackage( string packageId, IVersion version, string feedId, Uri feedUri, ICredentials feedCredentials, bool forcePackageDownload, int maxDownloadAttempts, TimeSpan downloadAttemptBackoff, out string downloadedTo, out string hash, out long size) { IPackageDownloader downloader = null; if (MavenPackageIdParser.TryGetMetadataFromPackageID(packageId, out var mavenMetadata)) { downloader = new MavenPackageDownloader(); } else if (NugetPackageIdParser.TryGetMetadataFromPackageID(packageId, out var nugetMetadata)) { downloader = new NuGetPackageDownloader(); } else { throw new NotImplementedException($"Package ID {packageId} is not recognised."); } downloader.DownloadPackage( packageId, version, feedId, feedUri, feedCredentials, forcePackageDownload, maxDownloadAttempts, downloadAttemptBackoff, out downloadedTo, out hash, out size); }
public static async Task Run( [ServiceBusTrigger("index", Connection = "ServiceBusConnectionString")] byte[] packageUrl, [Inject] IPackageDownloader downloader, [Inject] IPackageIndexingService indexer, ILogger log, CancellationToken cancellationToken) { var packageUri = new Uri(Encoding.Unicode.GetString(packageUrl)); using (var packageStream = await downloader.DownloadOrNullAsync(packageUri, cancellationToken)) { if (packageStream == null) { log.LogError("Could not find package at url {PackageUrl}", packageUri); return; } await indexer.IndexAsync(packageStream, cancellationToken); } }
/// <summary> /// Asynchronously gets a package downloader for a package identity. /// </summary> /// <param name="packageIdentity">A package identity.</param> /// <param name="cacheContext">A source cache context.</param> /// <param name="logger">A logger.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation. /// The task result (<see cref="Task{TResult}.Result" />) returns an <see cref="IPackageDownloader" />.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheContext" /> <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public override Task <IPackageDownloader> GetPackageDownloaderAsync( PackageIdentity packageIdentity, SourceCacheContext cacheContext, ILogger logger, CancellationToken cancellationToken) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (cacheContext == null) { throw new ArgumentNullException(nameof(cacheContext)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } cancellationToken.ThrowIfCancellationRequested(); var matchedVersion = GetVersion(packageIdentity.Id, packageIdentity.Version, cacheContext, logger); IPackageDownloader packageDependency = null; if (matchedVersion != null) { var packagePath = _resolver.GetPackageFilePath(packageIdentity.Id, matchedVersion); var matchedPackageIdentity = new PackageIdentity(packageIdentity.Id, matchedVersion); packageDependency = new LocalPackageArchiveDownloader(packagePath, matchedPackageIdentity, logger); } return(Task.FromResult(packageDependency)); }
public PackageHashCalculator(IPackageDownloader packageDownloader) { _packageDownloader = packageDownloader ?? throw new ArgumentNullException(nameof(packageDownloader)); }
public static IPackageRepository GetRemoteRepository(ChocolateyConfiguration configuration, ILogger nugetLogger, IPackageDownloader packageDownloader) { if (configuration.Features.ShowDownloadProgress) { packageDownloader.ProgressAvailable += (sender, e) => { // http://stackoverflow.com/a/888569/18475 Console.Write("\rProgress: {0} {1}%".format_with(e.Operation, e.PercentComplete.to_string()).PadRight(Console.WindowWidth)); if (e.PercentComplete == 100) { Console.WriteLine(""); } }; } IEnumerable <string> sources = configuration.Sources.Split(new[] { ";", "," }, StringSplitOptions.RemoveEmptyEntries); IList <IPackageRepository> repositories = new List <IPackageRepository>(); // ensure credentials can be grabbed from configuration HttpClient.DefaultCredentialProvider = new ChocolateyNugetCredentialProvider(configuration); HttpClient.DefaultCertificateProvider = new ChocolateyClientCertificateProvider(configuration); if (!string.IsNullOrWhiteSpace(configuration.Proxy.Location)) { "chocolatey".Log().Debug("Using proxy server '{0}'.".format_with(configuration.Proxy.Location)); var proxy = new WebProxy(configuration.Proxy.Location, true); if (!String.IsNullOrWhiteSpace(configuration.Proxy.User) && !String.IsNullOrWhiteSpace(configuration.Proxy.EncryptedPassword)) { proxy.Credentials = new NetworkCredential(configuration.Proxy.User, NugetEncryptionUtility.DecryptString(configuration.Proxy.EncryptedPassword)); } if (!string.IsNullOrWhiteSpace(configuration.Proxy.BypassList)) { "chocolatey".Log().Debug("Proxy has a bypass list of '{0}'.".format_with(configuration.Proxy.BypassList.escape_curly_braces())); proxy.BypassList = configuration.Proxy.BypassList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); } proxy.BypassProxyOnLocal = configuration.Proxy.BypassOnLocal; ProxyCache.Instance.Override(proxy); } var updatedSources = new StringBuilder(); foreach (var sourceValue in sources.or_empty_list_if_null()) { var source = sourceValue; var bypassProxy = false; if (configuration.MachineSources.Any(m => m.Name.is_equal_to(source) || m.Key.is_equal_to(source))) { try { var machineSource = configuration.MachineSources.FirstOrDefault(m => m.Key.is_equal_to(source)); if (machineSource == null) { machineSource = configuration.MachineSources.FirstOrDefault(m => m.Name.is_equal_to(source)); "chocolatey".Log().Debug("Switching source name {0} to actual source value '{1}'.".format_with(sourceValue, machineSource.Key.to_string())); source = machineSource.Key; } if (machineSource != null) { bypassProxy = machineSource.BypassProxy; if (bypassProxy) { "chocolatey".Log().Debug("Source '{0}' is configured to bypass proxies.".format_with(source)); } } } catch (Exception ex) { "chocolatey".Log().Warn("Attempted to use a source name {0} to get default source but failed:{1} {2}".format_with(sourceValue, System.Environment.NewLine, ex.Message)); } } updatedSources.AppendFormat("{0};", source); try { var uri = new Uri(source); if (uri.IsFile || uri.IsUnc) { repositories.Add(new ChocolateyLocalPackageRepository(uri.LocalPath) { Logger = nugetLogger }); } else { repositories.Add(new DataServicePackageRepository(new RedirectedHttpClient(uri, bypassProxy) { UserAgent = "Chocolatey Core" }, packageDownloader) { Logger = nugetLogger }); } } catch (Exception) { repositories.Add(new ChocolateyLocalPackageRepository(source) { Logger = nugetLogger }); } } if (updatedSources.Length != 0) { configuration.Sources = updatedSources.Remove(updatedSources.Length - 1, 1).to_string(); } //todo well that didn't work on failing repos... grrr var repository = new AggregateRepository(repositories) { IgnoreFailingRepositories = true, Logger = nugetLogger, ResolveDependenciesVertically = true }; return(repository); }
public static IPackageManager GetPackageManager(ChocolateyConfiguration configuration, ILogger nugetLogger, IPackageDownloader packageDownloader, Action <PackageOperationEventArgs> installSuccessAction, Action <PackageOperationEventArgs> uninstallSuccessAction, bool addUninstallHandler) { IFileSystem nugetPackagesFileSystem = GetNuGetFileSystem(configuration, nugetLogger); IPackagePathResolver pathResolver = GetPathResolver(configuration, nugetPackagesFileSystem); var packageManager = new PackageManager(GetRemoteRepository(configuration, nugetLogger, packageDownloader), pathResolver, nugetPackagesFileSystem, GetLocalRepository(pathResolver, nugetPackagesFileSystem, nugetLogger)) { DependencyVersion = DependencyVersion.Highest, Logger = nugetLogger, }; //NOTE DO NOT EVER use this method - packageManager.PackageInstalling += (s, e) => packageManager.PackageInstalled += (s, e) => { var pkg = e.Package; "chocolatey".Log().Info(ChocolateyLoggers.Important, "{0}{1} v{2}{3}{4}{5}".format_with( System.Environment.NewLine, pkg.Id, pkg.Version.to_string(), configuration.Force ? " (forced)" : string.Empty, pkg.IsApproved ? " [Approved]" : string.Empty, pkg.PackageTestResultStatus == "Failing" && pkg.IsDownloadCacheAvailable ? " - Likely broken for FOSS users (due to download location changes)" : pkg.PackageTestResultStatus == "Failing" ? " - Possibly broken" : string.Empty )); if (installSuccessAction != null) { installSuccessAction.Invoke(e); } }; if (addUninstallHandler) { // NOTE DO NOT EVER use this method, or endless loop - packageManager.PackageUninstalling += (s, e) => packageManager.PackageUninstalled += (s, e) => { IPackage pkg = packageManager.LocalRepository.FindPackage(e.Package.Id, e.Package.Version); if (pkg != null) { // install not actually removed, let's clean it up. This is a bug with nuget, where it reports it removed some package and did NOTHING // this is what happens when you are switching from AllowMultiple to just one and back var chocoPathResolver = packageManager.PathResolver as ChocolateyPackagePathResolver; if (chocoPathResolver != null) { chocoPathResolver.UseSideBySidePaths = !chocoPathResolver.UseSideBySidePaths; // an unfound package folder can cause an endless loop. // look for it and ignore it if doesn't line up with versioning if (nugetPackagesFileSystem.DirectoryExists(chocoPathResolver.GetInstallPath(pkg))) { //todo: This causes an issue with upgrades. // this causes this to be called again, which should then call the uninstallSuccessAction below packageManager.UninstallPackage(pkg, forceRemove: configuration.Force, removeDependencies: false); } chocoPathResolver.UseSideBySidePaths = configuration.AllowMultipleVersions; } } else { if (uninstallSuccessAction != null) { uninstallSuccessAction.Invoke(e); } } }; } return(packageManager); }
public NugetPreProcessor(INuGetScriptSettings settings, IPackageDownloader packageDownloader, IPackageSearcher packageSearcher) { _settings = settings; _packageDownloader = packageDownloader; _packageSearcher = packageSearcher; }
public async Task CopyPackagesToOriginalCaseAsync(IEnumerable <RestoreTargetGraph> graphs, CancellationToken token) { // Keep track of the packages we've already converted to original case. var converted = new HashSet <PackageIdentity>(); var originalCaseContext = GetPathContext(); var versionFolderPathResolver = new VersionFolderPathResolver(_request.PackagesDirectory, _request.IsLowercasePackagesDirectory); // Iterate over every package node. foreach (var graph in graphs) { var packages = graph .Flattened .Select(graphItem => graphItem.Data.Match) .Where(remoteMatch => remoteMatch.Library.Type == LibraryType.Package); foreach (var remoteMatch in packages) { var identity = GetPackageIdentity(remoteMatch); var hashPath = _pathResolver.GetNupkgMetadataPath(identity.Id, identity.Version); // No need to re-install the same package identity more than once or if it is // already installed. if (!converted.Add(identity) || File.Exists(hashPath)) { continue; } var localPackageSourceInfo = GetLocalPackageSourceInfo(remoteMatch); var packageIdentity = new PackageIdentity(remoteMatch.Library.Name, remoteMatch.Library.Version); IPackageDownloader packageDependency = null; if (string.IsNullOrEmpty(localPackageSourceInfo?.Package.ZipPath)) { packageDependency = await remoteMatch.Provider.GetPackageDownloaderAsync( packageIdentity, _request.CacheContext, _request.Log, token); } else { packageDependency = new LocalPackageArchiveDownloader( localPackageSourceInfo.Repository.RepositoryRoot, localPackageSourceInfo.Package.ZipPath, packageIdentity, _request.Log); } // Install the package. using (packageDependency) { var result = await PackageExtractor.InstallFromSourceAsync( identity, packageDependency, versionFolderPathResolver, originalCaseContext, token, ParentId); if (result) { _request.Log.LogMinimal(string.Format( CultureInfo.CurrentCulture, Strings.Log_ConvertedPackageToOriginalCase, identity)); } } } } }
public static async Task <bool> InstallFromSourceAsync( PackageIdentity packageIdentity, IPackageDownloader packageDownloader, VersionFolderPathResolver versionFolderPathResolver, PackageExtractionContext packageExtractionContext, CancellationToken token, Guid parentId = default(Guid)) { if (packageDownloader == null) { throw new ArgumentNullException(nameof(packageDownloader)); } if (packageExtractionContext == null) { throw new ArgumentNullException(nameof(packageExtractionContext)); } var logger = packageExtractionContext.Logger; using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId(parentId)) { var targetPath = versionFolderPathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version); var targetNuspec = versionFolderPathResolver.GetManifestFilePath(packageIdentity.Id, packageIdentity.Version); var targetNupkg = versionFolderPathResolver.GetPackageFilePath(packageIdentity.Id, packageIdentity.Version); var hashPath = versionFolderPathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version); logger.LogVerbose( $"Acquiring lock for the installation of {packageIdentity.Id} {packageIdentity.Version}"); // Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple // processes are extracting to the same destination simultaneously return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(targetNupkg, action : async cancellationToken => { // If this is the first process trying to install the target nupkg, go ahead // After this process successfully installs the package, all other processes // waiting on this lock don't need to install it again. if (!File.Exists(hashPath)) { logger.LogVerbose( $"Acquired lock for the installation of {packageIdentity.Id} {packageIdentity.Version}"); logger.LogMinimal(string.Format( CultureInfo.CurrentCulture, Strings.Log_InstallingPackage, packageIdentity.Id, packageIdentity.Version)); cancellationToken.ThrowIfCancellationRequested(); // We do not stop the package extraction after this point // based on CancellationToken, but things can still be stopped if the process is killed. if (Directory.Exists(targetPath)) { // If we had a broken restore, clean out the files first var info = new DirectoryInfo(targetPath); foreach (var file in info.GetFiles()) { file.Delete(); } foreach (var dir in info.GetDirectories()) { dir.Delete(true); } } else { Directory.CreateDirectory(targetPath); } var targetTempNupkg = Path.Combine(targetPath, Path.GetRandomFileName()); var tempHashPath = Path.Combine(targetPath, Path.GetRandomFileName()); var packageSaveMode = packageExtractionContext.PackageSaveMode; // Extract the nupkg var copiedNupkg = await packageDownloader.CopyNupkgFileToAsync(targetTempNupkg, cancellationToken); if (packageSaveMode.HasFlag(PackageSaveMode.Nuspec) || packageSaveMode.HasFlag(PackageSaveMode.Files)) { try { telemetry.StartIntervalMeasure(); await VerifyPackageSignatureAsync( packageDownloader.Source, telemetry.OperationId, packageIdentity, packageExtractionContext, packageDownloader.SignedPackageReader, token); telemetry.EndIntervalMeasure(PackagingConstants.PackageVerifyDurationName); } catch (SignatureException) { try { // Dispose of it now because it is holding a lock on the temporary .nupkg file. packageDownloader.Dispose(); DeleteTargetAndTempPaths(targetPath, targetTempNupkg); } catch (IOException ex) { logger.LogWarning(string.Format( CultureInfo.CurrentCulture, Strings.ErrorUnableToDeleteFile, targetTempNupkg, ex.Message)); } telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent( packageExtractionContext.PackageSaveMode, NuGetOperationStatus.Failed, ExtractionSource.RestoreCommand, packageIdentity); throw; } } if (packageSaveMode.HasFlag(PackageSaveMode.Nuspec)) { var nuspecFileNameFromReader = await packageDownloader.CoreReader.GetNuspecFileAsync(cancellationToken); var packageFiles = new[] { nuspecFileNameFromReader }; var packageFileExtractor = new PackageFileExtractor( packageFiles, XmlDocFileSaveMode.None); var packageDirectoryPath = Path.GetDirectoryName(targetNuspec); var extractedNuspecFilePath = (await packageDownloader.CoreReader.CopyFilesAsync( packageDirectoryPath, packageFiles, packageFileExtractor.ExtractPackageFile, logger, cancellationToken)) .SingleOrDefault(); // CopyFilesAsync(...) just extracts files to a directory. // We may have to fix up the casing of the .nuspec file name. if (!string.IsNullOrEmpty(extractedNuspecFilePath)) { if (PathUtility.IsFileSystemCaseInsensitive) { var nuspecFileName = Path.GetFileName(targetNuspec); var actualNuspecFileName = Path.GetFileName(extractedNuspecFilePath); if (!string.Equals(nuspecFileName, actualNuspecFileName, StringComparison.Ordinal)) { var tempNuspecFilePath = Path.Combine(packageDirectoryPath, Path.GetRandomFileName()); File.Move(extractedNuspecFilePath, tempNuspecFilePath); File.Move(tempNuspecFilePath, targetNuspec); } } else if (!File.Exists(targetNuspec)) { File.Move(extractedNuspecFilePath, targetNuspec); } } } if (packageSaveMode.HasFlag(PackageSaveMode.Files)) { var hashFileName = Path.GetFileName(hashPath); var packageFiles = (await packageDownloader.CoreReader.GetFilesAsync(cancellationToken)) .Where(file => ShouldInclude(file, hashFileName)); var packageFileExtractor = new PackageFileExtractor( packageFiles, packageExtractionContext.XmlDocFileSaveMode); await packageDownloader.CoreReader.CopyFilesAsync( targetPath, packageFiles, packageFileExtractor.ExtractPackageFile, logger, token); } var packageHash = await packageDownloader.GetPackageHashAsync("SHA512", cancellationToken); File.WriteAllText(tempHashPath, packageHash); // Now rename the tmp file if (packageExtractionContext.PackageSaveMode.HasFlag(PackageSaveMode.Nupkg)) { if (copiedNupkg) { // Dispose of it now because it is holding a lock on the temporary .nupkg file. packageDownloader.Dispose(); File.Move(targetTempNupkg, targetNupkg); } } else { try { File.Delete(targetTempNupkg); } catch (IOException ex) { logger.LogWarning(string.Format( CultureInfo.CurrentCulture, Strings.ErrorUnableToDeleteFile, targetTempNupkg, ex.Message)); } } // Note: PackageRepository relies on the hash file being written out as the // final operation as part of a package install to assume a package was fully installed. // Rename the tmp hash file File.Move(tempHashPath, hashPath); logger.LogVerbose($"Completed installation of {packageIdentity.Id} {packageIdentity.Version}"); telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent( packageExtractionContext.PackageSaveMode, NuGetOperationStatus.Succeeded, ExtractionSource.RestoreCommand, packageIdentity); return true; } else { logger.LogVerbose("Lock not required - Package already installed " + $"{packageIdentity.Id} {packageIdentity.Version}"); telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent( packageExtractionContext.PackageSaveMode, NuGetOperationStatus.NoOp, ExtractionSource.RestoreCommand, packageIdentity); return false; } }, token : token)); } }
public DefaultPackageResolver(IPackageDownloader downloader) { this.downloader = downloader; }