private async Task <IEnumerable <string> > Install(
DownloadResource downloadResource,
PackageIdentity package,
PackagePathResolver pathResolver,
PackageExtractionContext extractionContext,
FrameworkReducer reducer,
NuGetFramework framework,
string packagesPath,
ILogger logger)
{
var packageResult = await downloadResource.GetDownloadResourceResultAsync(
package,
new PackageDownloadContext(cache),
packagesPath,
logger,
CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
packageResult.PackageSource,
packageResult.PackageStream,
pathResolver, extractionContext,
CancellationToken.None);
var libItems = await packageResult.PackageReader.GetLibItemsAsync(CancellationToken.None);
var nearest = reducer.GetNearest(framework, libItems.Select(a => a.TargetFramework));
var selected = libItems.Where(a => a.TargetFramework.Equals(nearest)).SelectMany(a => a.Items);
return(selected.Where(a => Path.GetExtension(a) == ".dll")
.Select(a => Path.Combine(pathResolver.GetInstalledPath(package), a)));
}
/// <summary>
/// Download the specified packageId from the NuGet feed.
/// </summary>
/// <param name="packageId">PackageIdentity to download.</param>
/// <returns>Path to the downloaded package.</returns>
public virtual async Task <string> DownloadPackageAsync(PackageIdentity packageId)
{
string downloadPath = Path.Combine(this.downloadFolder, $"{this.feedName}.zip");
PackageDownloadContext packageDownloadContext = new PackageDownloadContext(
this.sourceCacheContext,
this.downloadFolder,
true);
DownloadResource downloadResource = await this.sourceRepository.GetResourceAsync <DownloadResource>();
using (DownloadResourceResult downloadResourceResult = await downloadResource.GetDownloadResourceResultAsync(
packageId,
packageDownloadContext,
globalPackagesFolder: string.Empty,
logger: this.nuGetLogger,
token: CancellationToken.None))
{
if (downloadResourceResult.Status != DownloadResourceResultStatus.Available)
{
throw new Exception("Download of NuGet package failed. DownloadResult Status: {downloadResourceResult.Status}");
}
using (FileStream fileStream = File.Create(downloadPath))
{
downloadResourceResult.PackageStream.CopyTo(fileStream);
}
}
return(downloadPath);
}
public async Task <IPackageContent> DownloadAsync(SourceRepository repository, IPackageSearchMetadata package, CancellationToken cancellationToken)
{
Ensure.NotNull(repository, "repository");
Ensure.NotNull(package, "package");
DownloadResource download = await repository.GetResourceAsync <DownloadResource>();
if (download == null)
{
throw Ensure.Exception.InvalidOperation($"Unnable to resolve '{nameof(DownloadResource)}'.");
}
using (var sourceCacheContext = new SourceCacheContext())
{
var context = new PackageDownloadContext(sourceCacheContext, Path.GetTempPath(), true);
var result = await download.GetDownloadResourceResultAsync(package.Identity, context, String.Empty, nuGetLog, cancellationToken);
if (result.Status == DownloadResourceResultStatus.Cancelled)
{
throw new OperationCanceledException();
}
else if (result.Status == DownloadResourceResultStatus.NotFound)
{
throw Ensure.Exception.InvalidOperation($"Package '{package.Identity.Id}-v{package.Identity.Version}' not found");
}
return(new NuGetPackageContent(new PackageArchiveReader(result.PackageStream), log, frameworkFilter));
}
}
public async Task <bool> MirrorAsync(PackageIdentity identity, CancellationToken token)
{
// Publish the package itself.
var publishPackage = true;
if (!_overwriteExisting)
{
publishPackage = !(await _existenceChecker.PackageExistsAsync(identity, token));
}
if (publishPackage)
{
var downloadResult = await _sourceDownloadResource.GetDownloadResourceResultAsync(
identity,
_settings,
_logger,
token);
using (downloadResult)
{
if (downloadResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"The NuGet package '{identity}' is not available on the source.");
}
await _packagePusher.PushAsync(downloadResult.PackageStream, token);
}
}
// Publish the symbols package.
var publishSymbolsPackage = _includeSymbols;
if (!_overwriteExisting)
{
publishSymbolsPackage = !(await _existenceChecker.SymbolsPackageExistsAsync(identity, token));
}
if (publishSymbolsPackage)
{
publishSymbolsPackage = await _symbolsPackageDownloader.ProcessAsync(
identity,
async streamResult =>
{
if (!streamResult.IsAvailable)
{
// The package has no symbols package.
return(false);
}
await _packagePusher.PushAsync(streamResult.Stream, token);
return(true);
},
token);
}
return(publishPackage || publishSymbolsPackage);
}
public static async Task <DownloadResourceResult> GetDownloadResourceResult(string depsFolder, SourceCacheContext cache, SourceRepository repository, DownloadResource resource, string packageId, NuGetVersion packageVersion)
{
return(await resource.GetDownloadResourceResultAsync(
new SourcePackageDependencyInfo(packageId, packageVersion, null, true, repository),
new PackageDownloadContext(cache),
depsFolder,
NuGet.Common.NullLogger.Instance,
CancellationToken.None));
}
private async Task <Type> RetrieveTypeAsync()
{
bool isBetaPackage = _nugetPackageName.EndsWith(_betaSuffix);
(string searchName, bool isSpecificVersion) = GetSearchablePackageName(_nugetPackageName, isBetaPackage);
IEnumerable <IPackageSearchMetadata> searchMetadata = await _packageMetadataResource.GetMetadataAsync(
searchName,
isBetaPackage,
false,
_nugetLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new InvalidOperationException($"Package {_nugetPackageName} not found");
}
var packageInfo = searchMetadata
.Cast <PackageSearchMetadata>()
.OrderByDescending(p => p.Version)
.First(i => !isSpecificVersion || i.Identity.ToString() == _nugetPackageName);
var downloadResult = await _downloadResource.GetDownloadResourceResultAsync(
packageInfo.Identity,
_packageDownloadContext,
null,
_nugetLogger,
CancellationToken.None);
if (downloadResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Nuget package {_nugetPackageName} of version {packageInfo.Version} is not available for download");
}
var pathResolver = new PackagePathResolver(_downloadDirectory);
var extractContext = new PackageExtractionContext(_nugetLogger);
var extractedFiles = PackageExtractor.ExtractPackage(downloadResult.PackageStream, pathResolver, extractContext, CancellationToken.None);
var dllFiles = extractedFiles.Where(f => Path.GetExtension(f).ToLower() == _dllExtension);
if (!dllFiles.Any())
{
throw new InvalidOperationException($"Dll files not found in {_packageDownloadContext.DirectDownloadDirectory}");
}
var assembly = Assembly.LoadFile(dllFiles.First());
var type = assembly.GetType(_processingTypeName);
if (type == null)
{
throw new InvalidOperationException($"Type {_processingTypeName} not found among {assembly.ExportedTypes.Select(t => t.FullName).ToList().ToJson()}");
}
return(type);
}
private async Task DownloadNugetPackage(DownloadResource nugetClient, DiscoveryContext context, AddinMetadata package)
{
var packageFileName = Path.Combine(context.PackagesFolder, $"{package.Name}.{package.NuGetPackageVersion}.nupkg");
if (!File.Exists(packageFileName))
{
// Delete prior versions of this package
foreach (var f in Directory.EnumerateFiles(context.PackagesFolder, $"{package.Name}.*.nupkg"))
{
var expectedSplitLength = package.Name.Split('.').Length + package.NuGetPackageVersion.Split('.').Length;
var fileName = Path.GetFileNameWithoutExtension(f);
if (fileName.Split('.').Length == expectedSplitLength)
{
File.Delete(f);
}
}
// Download the latest version of the package
using var sourceCacheContext = new SourceCacheContext()
{
NoCache = true
};
var downloadContext = new PackageDownloadContext(sourceCacheContext, Path.GetTempPath(), true);
var packageIdentity = new PackageIdentity(package.Name, new NuGet.Versioning.NuGetVersion(package.NuGetPackageVersion));
using var result = await nugetClient.GetDownloadResourceResultAsync(packageIdentity, downloadContext, string.Empty, NullLogger.Instance, CancellationToken.None).ConfigureAwait(false);
switch (result.Status)
{
case DownloadResourceResultStatus.Cancelled:
throw new OperationCanceledException();
case DownloadResourceResultStatus.NotFound:
throw new Exception($"Package '{package.Name} {package.NuGetPackageVersion}' not found");
default:
{
await using var fileStream = File.OpenWrite(packageFileName);
await result.PackageStream.CopyToAsync(fileStream).ConfigureAwait(false);
break;
}
}
}
}
public async Task <IEnumerable <string> > DownloadPackageAndDependenciesAsync(string packageId, string version, string nuGetDir)
{
List <string> dllsToCopy = new List <string>();
NuGetVersion packageVersion = NuGetVersion.Parse(version);
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = _sourceRepositoryProvider.GetRepositories();
HashSet <SourcePackageDependencyInfo> availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(
new PackageIdentity(packageId, packageVersion),
_nuGetFramework, cacheContext, _logger, repositories, availablePackages);
PackageResolverContext resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
_sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
_logger);
PackageResolver resolver = new PackageResolver();
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
PackagePathResolver packagePathResolver = new PackagePathResolver(nuGetDir);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(_settings, _logger), _logger);
FrameworkReducer frameworkReducer = new FrameworkReducer();
foreach (SourcePackageDependencyInfo packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(_settings),
_logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
IEnumerable <FrameworkSpecificGroup> libItems = packageReader.GetLibItems();
NuGetFramework nearest = frameworkReducer.GetNearest(_nuGetFramework, libItems.Select(x => x.TargetFramework));
IEnumerable <string> items = libItems.Where(x => x.TargetFramework.Equals(nearest)).SelectMany(x => x.Items).Where(x => Path.GetExtension(x) == ".dll");
foreach (var item in items)
{
dllsToCopy.Add(Path.Combine(installedPath, item));
}
}
}
return(dllsToCopy);
}
/// <summary>
/// Installs packages on any project that targets the dotnet v4. The packages are added to the packages folder
/// and the packages.config file and the .csproj file is updated.
/// </summary>
/// <param name="packageId">The package to install</param>
/// <param name="projectTargetVersion">The version of .net framework that the project targets.</param>
/// <returns>A completed task of the package installation</returns>
internal async Task InstallPackagesOnDotNetV4FrameworkProjects(string packageId, string projectTargetVersion)
{
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
Logger logger = new Logger(this.messageLogger);
IEnumerable <SourceRepository> repositories = this.SourceRepositoryProvider.GetRepositories();
HashSet <SourcePackageDependencyInfo> availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
NuGetFramework nuGetFramework = NuGetFramework.ParseFolder(projectTargetVersion?.Split('=')[1]);
NuGetVersion packageVersion = await GetPackageLatestNugetVersionAsync(packageId, this.SourceRepository, nuGetFramework.DotNetFrameworkName);
//get all the package dependencies
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositories, availablePackages);
PackageResolverContext resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
this.SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
logger);
PackageResolver resolver = new PackageResolver();
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
PackagePathResolver packagePathResolver = new PackagePathResolver(this.RootPath);
ClientPolicyContext clientPolicyContext = ClientPolicyContext.GetClientPolicy(this.DefaultSettings, logger);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
clientPolicyContext,
logger);
foreach (SourcePackageDependencyInfo packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
DownloadResourceResult downloadResult = null;
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(this.DefaultSettings),
logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
///update the packages.config file
await UpdatePackagesConfigFile(packageToInstall, packageReader, downloadResult, nuGetFramework);
UpdateProjectFile(packageReader, installedPath, packageToInstall, nuGetFramework);
}
}
}
private async Task <PluginPackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath pluginRepositoryPath)
{
var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion);
ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString());
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var packageMetaDataList = new List <PluginPackage>();
using (var cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false);
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId,
nugetFramework,
cacheContext,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (dependencyInfo == null)
{
continue;
}
availablePackages.AddRange(dependencyInfo);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
try
{
SourcePackageDependencyInfo packageToInstall = resolver
.Resolve(resolverContext, CancellationToken.None).Select(p =>
availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)))
.FirstOrDefault();
var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader;
if (installedPath == null && packageToInstall != null)
{
DownloadResource downloadResource = await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false);
var packageMetaData = new PluginPackage
{
Name = identity.Id,
Version = identity.Version.OriginalVersion,
RepositoryPath = pluginRepositoryPath,
};
foreach (FrameworkSpecificGroup contentItem in await packageReader.GetContentItemsAsync(CancellationToken.None).ConfigureAwait(false))
{
packageMetaData.Plugins.AddRange(contentItem.Items);
}
var packageFileExtractor = new PackageFileExtractor(
packageMetaData.Plugins,
XmlDocFileSaveMode.None);
await packageReader.CopyFilesAsync(
packageMetaData.PluginPath.ToString(),
packageMetaData.Plugins,
packageFileExtractor.ExtractPackageFile,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.GetChildDirectoryWithName("content").ChildrenFilesPath)
{
File.Copy(file.ToString(), Path.Join(packageMetaData.PluginPath.ToString(), file.FileName), overwrite: true);
}
packageMetaData.Plugins.Clear();
foreach (IAbsoluteFilePath file in packageMetaData.PluginPath.ChildrenFilesPath)
{
packageMetaData.Plugins.Add(file.GetRelativePathFrom(packageMetaData.PluginPath).ToString());
}
Directory.Delete(packageMetaData.PluginPath.GetChildDirectoryWithName("content").ToString(), recursive: true);
packageMetaDataList.Add(packageMetaData);
}
catch (NuGetResolverConstraintException exception)
{
string foo = exception.Message;
}
}
return(packageMetaDataList.FirstOrDefault());
}
public async Task Post([FromBody] WebHookEvent webHookEvent)
{
TraceInfo($"POST PackageAdded Started");
string packageId = null;
string packageVersion = null;
try
{
if (webHookEvent?.PayloadType == "PackageAddedWebHookEventPayloadV1")
{
if (webHookEvent.Payload?.PackageType == "NuGet")
{
PackageAddedWebHookEventPayloadV1 payload = webHookEvent.Payload;
packageId = payload.PackageIdentifier;
packageVersion = payload.PackageVersion;
Uri sourceFeedUrl = new Uri(payload.FeedUrl);
if (ShouldMirrorPackage(sourceFeedUrl, packageId, packageVersion))
{
TraceInfo($"Downloading package {packageId} {packageVersion}");
DownloadResource downloadResource = await GetDownloadResource(sourceFeedUrl);
PackageIdentity id = new PackageIdentity(packageId, new NuGetVersion(packageVersion));
using (DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
id,
s_settings,
new NullLogger(),
CancellationToken.None))
{
if (downloadResult.Status == DownloadResourceResultStatus.Available)
{
await PushPackage(downloadResult, sourceFeedUrl);
TraceInfo($"Successfully pushed package {packageId} {packageVersion}");
}
else
{
string message = $"The package {packageId} {packageVersion} was not available.";
TraceError(message);
throw new Exception(message);
}
}
}
else
{
TraceInfo($"Package didn't match any filters {packageId} {packageVersion}");
}
}
else
{
TraceInfo($"Non NuGet package added: {webHookEvent.Payload?.PackageType}");
}
}
else
{
TraceError($"Not a valid PayloadType: {webHookEvent?.PayloadType}");
}
}
catch (Exception e)
{
TraceError($"An unhandled exception occurred handling package {packageId} {packageVersion} : {e}");
throw;
}
finally
{
TraceInfo($"POST PackageAdded Complete");
}
}
private async Task <TemplatePackage> GetLatestTemplatePackage(string packageId, string frameworkVersion, IAbsoluteDirectoryPath templateRepositoryPath)
{
ISettings settings = Settings.LoadSpecificSettings(root: null, this.appEnvironment.NuGetConfigFilePath.ToString());
var nugetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (SourceRepository sourceRepository in repositories)
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>().ConfigureAwait(false);
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId,
nugetFramework,
cacheContext,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (dependencyInfo == null)
{
continue;
}
availablePackages.AddRange(dependencyInfo);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
SourcePackageDependencyInfo packageToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)))
.FirstOrDefault();
var packagePathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
PackageReaderBase packageReader;
if (installedPath == null && packageToInstall != null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).ConfigureAwait(false);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None).ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
PackageIdentity identity = await packageReader.GetIdentityAsync(CancellationToken.None).ConfigureAwait(false);
var templatePackageMetaData = new TemplatePackage
{
PackageId = identity.Id,
Version = identity.Version.OriginalVersion,
TemplateRepositoryPath = templateRepositoryPath.ToString(),
};
foreach (FrameworkSpecificGroup contentItem in packageReader.GetContentItems())
{
foreach (string item in contentItem.Items)
{
templatePackageMetaData.Templates.Add(new Template {
NestedFilePath = item
});
}
}
var packageFileExtractor = new PackageFileExtractor(
templatePackageMetaData.Templates.Select(template => template.NestedFilePath),
XmlDocFileSaveMode.None);
await packageReader.CopyFilesAsync(
templatePackageMetaData.InstalltionPath,
templatePackageMetaData.Templates.Select(template => template.NestedFilePath),
packageFileExtractor.ExtractPackageFile,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
return(templatePackageMetaData);
}
}