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;
}
