private void CopyNupkgFilesToTarget(PackageArchiveReader nupkg, string destPath, IEnumerable <string> files)
{
var packageFileExtractor = new PackageFileExtractor(files,
PackageExtractionBehavior.XmlDocFileSaveMode);
nupkg.CopyFiles(destPath, files, packageFileExtractor.ExtractPackageFile, new TestCommandOutputLogger(),
CancellationToken.None);
}
private void CopyFlatlistOfFilesToTarget(PackageArchiveReader nupkg, string destination, IEnumerable <string> packageFiles)
{
var packageFileExtractor = new PackageFileExtractor(packageFiles,
PackageExtractionBehavior.XmlDocFileSaveMode);
var logger = new TestCommandOutputLogger();
var token = CancellationToken.None;
var filesCopied = new List <string>();
foreach (var packageFile in packageFiles)
{
token.ThrowIfCancellationRequested();
var entry = nupkg.GetEntry(packageFile);
var packageFileName = entry.FullName;
// An entry in a ZipArchive could start with a '/' based on how it is zipped
// Remove it if present
if (packageFileName.StartsWith("/", StringComparison.Ordinal))
{
packageFileName = packageFileName.Substring(1);
}
// Get only the name, without the path, since we are extracting to flat list
packageFileName = Path.GetFileName(packageFileName);
// ZipArchive always has forward slashes in them. By replacing them with DirectorySeparatorChar;
// in windows, we get the windows-style path
var normalizedPath = Uri.UnescapeDataString(packageFileName.Replace('/', Path.DirectorySeparatorChar));
var targetFilePath = Path.Combine(destination, normalizedPath);
if (!targetFilePath.StartsWith(destination, StringComparison.OrdinalIgnoreCase))
{
continue;
}
try
{
File.Delete(targetFilePath);
}
catch
{
// Do nothing
}
using (var stream = entry.Open())
{
var copiedFile = packageFileExtractor.ExtractPackageFile(packageFileName, targetFilePath, stream);
if (copiedFile != null)
{
entry.UpdateFileTimeFromEntry(copiedFile, logger);
entry.UpdateFilePermissionsFromEntry(copiedFile, logger);
filesCopied.Add(copiedFile);
}
}
}
}
public void Extract(Stream nupkgStream, string targetPath)
{
var tempHashPath = Path.Combine(targetPath, Path.GetRandomFileName());
var targetNuspec = Path.Combine(targetPath, Path.GetRandomFileName());
var targetNupkg = Path.Combine(targetPath, Path.GetRandomFileName());
targetNupkg = Path.ChangeExtension(targetNupkg, ".nupkg");
var hashPath = Path.Combine(targetPath, Path.GetRandomFileName());
using (var packageReader = new PackageArchiveReader(nupkgStream))
{
var nuspecFile = packageReader.GetNuspecFile();
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
packageReader.ExtractFile(nuspecFile, targetNuspec);
}
if ((packageSaveMode & PackageSaveMode.Files) == PackageSaveMode.Files)
{
var nupkgFileName = Path.GetFileName(targetNupkg);
var hashFileName = Path.GetFileName(hashPath);
var packageFiles = packageReader.GetFiles()
.Where(file => ShouldInclude(file, nupkgFileName, nuspecFile, hashFileName));
var packageFileExtractor = new PackageFileExtractor(
packageFiles,
XmlDocFileSaveMode.None);
packageReader.CopyFiles(
targetPath,
packageFiles,
packageFileExtractor.ExtractPackageFile,
CancellationToken.None);
}
string packageHash;
nupkgStream.Position = 0;
packageHash = Convert.ToBase64String(new CryptoHashProvider("SHA512").CalculateHash(nupkgStream));
File.WriteAllText(tempHashPath, packageHash);
}
}
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());
}
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);
}
}
