/// <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 packageReader = new PluginPackageReader(_plugin, packageIdentity, _packageSource.Source);
var packageDependency = new PluginPackageDownloader(_plugin, packageIdentity, packageReader, _packageSource.Source);
return(Task.FromResult <IPackageDownloader>(packageDependency));
}
/// <summary>
/// Asynchronously downloads a package.
/// </summary>
/// <param name="identity">The package identity.</param>
/// <param name="downloadContext">A package download context.</param>
/// <param name="globalPackagesFolder">The path to the global packages folder.</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
/// a <see cref="DownloadResourceResult" />.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="identity" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="downloadContext" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public async override Task <DownloadResourceResult> GetDownloadResourceResultAsync(
PackageIdentity identity,
PackageDownloadContext downloadContext,
string globalPackagesFolder,
ILogger logger,
CancellationToken cancellationToken)
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
if (downloadContext == null)
{
throw new ArgumentNullException(nameof(downloadContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
AddOrUpdateLogger(_plugin, logger);
await _utilities.DoOncePerPluginLifetimeAsync(
MessageMethod.SetLogLevel.ToString(),
() => SetLogLevelAsync(logger, cancellationToken),
cancellationToken);
var response = await _plugin.Connection.SendRequestAndReceiveResponseAsync <PrefetchPackageRequest, PrefetchPackageResponse>(
MessageMethod.PrefetchPackage,
new PrefetchPackageRequest(_packageSource.Source, identity.Id, identity.Version.ToNormalizedString()),
cancellationToken);
if (response != null)
{
if (response.ResponseCode == MessageResponseCode.Success)
{
var packageReader = new PluginPackageReader(_plugin, identity, _packageSource.Source);
return(new DownloadResourceResult(packageReader, _packageSource.Source));
}
if (response.ResponseCode == MessageResponseCode.NotFound)
{
return(new DownloadResourceResult(DownloadResourceResultStatus.NotFound));
}
}
throw new PluginException(
string.Format(CultureInfo.CurrentCulture,
Strings.Plugin_PackageDownloadFailed,
_plugin.Name,
$"{identity.Id}.{identity.Version.ToNormalizedString()}"));
}
private PluginPackageDownloaderTest(
PackageIdentity packageIdentity,
Mock <IPlugin> plugin,
PluginPackageReader packageReader,
PluginPackageDownloader downloader)
{
PackageIdentity = packageIdentity;
Plugin = plugin;
PackageReader = packageReader;
Downloader = downloader;
}
public void Constructor_ThrowsForNullOrEmptyPackageSourceRepository(string packageSourceRepository)
{
using (var packageReader = new PluginPackageReader(
Mock.Of <IPlugin>(),
_packageIdentity,
_packageSourceRepository))
{
var exception = Assert.Throws <ArgumentException>(
() => new PluginPackageDownloader(
Mock.Of <IPlugin>(),
_packageIdentity,
packageReader,
packageSourceRepository));
Assert.Equal("packageSourceRepository", exception.ParamName);
}
}
public void Constructor_ThrowsForNullPlugin()
{
using (var packageReader = new PluginPackageReader(
Mock.Of <IPlugin>(),
_packageIdentity,
_packageSourceRepository))
{
var exception = Assert.Throws <ArgumentNullException>(
() => new PluginPackageDownloader(
plugin: null,
packageIdentity: _packageIdentity,
packageReader: packageReader,
packageSourceRepository: _packageSourceRepository));
Assert.Equal("plugin", exception.ParamName);
}
}
internal static PluginPackageDownloaderTest Create()
{
var plugin = new Mock <IPlugin>(MockBehavior.Strict);
plugin.Setup(x => x.Dispose());
var packageReader = new PluginPackageReader(plugin.Object, _packageIdentity, _packageSourceRepository);
var downloader = new PluginPackageDownloader(
plugin.Object,
_packageIdentity,
packageReader,
_packageSourceRepository);
return(new PluginPackageDownloaderTest(
_packageIdentity,
plugin,
packageReader,
downloader));
}
/// <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 packageReader = new PluginPackageReader(_plugin, packageIdentity, _packageSource.Source);
var packageDependency = new PluginPackageDownloader(_plugin, packageIdentity, packageReader, _packageSource.Source);
return(Task.FromResult <IPackageDownloader>(packageDependency));
}
finally
{
ProtocolDiagnostics.RaiseEvent(new ProtocolDiagnosticResourceEvent(
_packageSource.Source,
ResourceTypeName,
ThisTypeName,
nameof(GetPackageDownloaderAsync),
stopwatch.Elapsed));
}
}
/// <summary>
/// Asynchronously gets dependency information for a specific package.
/// </summary>
/// <param name="id">A package id.</param>
/// <param name="version">A package version.</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="IEnumerable{NuGetVersion}" />.</returns>
/// <exception cref="ArgumentException">Thrown if <paramref name="id" />
/// is either <c>null</c> or an empty string.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="version" /> <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 async Task <FindPackageByIdDependencyInfo> GetDependencyInfoAsync(
string id,
NuGetVersion version,
SourceCacheContext cacheContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(Strings.ArgumentCannotBeNullOrEmpty, nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
var packageInfos = await EnsurePackagesAsync(id, cacheContext, logger, cancellationToken);
PackageInfo packageInfo;
if (packageInfos.TryGetValue(version, out packageInfo))
{
AddOrUpdateLogger(_plugin, logger);
await _utilities.DoOncePerPluginLifetimeAsync(
MessageMethod.SetLogLevel.ToString(),
() => SetLogLevelAsync(logger, cancellationToken),
cancellationToken);
var response = await _plugin.Connection.SendRequestAndReceiveResponseAsync <PrefetchPackageRequest, PrefetchPackageResponse>(
MessageMethod.PrefetchPackage,
new PrefetchPackageRequest(
_packageSource.Source,
packageInfo.Identity.Id,
packageInfo.Identity.Version.ToNormalizedString()),
cancellationToken);
if (response != null && response.ResponseCode == MessageResponseCode.Success)
{
using (var packageReader = new PluginPackageReader(_plugin, packageInfo.Identity, _packageSource.Source))
{
var nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken);
return(GetDependencyInfo(nuspecReader));
}
}
}
return(null);
}
