public async Task TestFolderNuGetProjectInstall()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyTestPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder();
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using(var packageStream = packageFileInfo.OpenRead())
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "lib/test.dll")));
using(var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(5, zipArchive.Entries.Count);
}
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath);
}
void CreateUninstallerWithPackagesFolder (string packagesDirectory)
{
packagesDirectory = packagesDirectory.ToNativePath ();
CreateProject ();
var resolver = new PackagePathResolver (packagesDirectory);
uninstaller = new NuGetPackageUninstaller (project, resolver);
}
public async Task <bool> InstallPackage(PackageIdentity identity)
{
await Download(identity);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
await InstallPackage(local.Identity);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
CopyDir.Copy(installedPath + @"\build", Destinationfolder);
}
return(true);
}
public async Task DownloadAndInstall(PackageIdentity identity)
{
//包源靠前的地址已经找到和安装了包的时候不要再继续下面的包源操作了
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var packageExtractionContext = new PackageExtractionContext(Logger);
packageExtractionContext.PackageSaveMode = PackageSaveMode.Defaultv3;
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
// PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
InstallPackage(packageToInstall);
}
}
}
catch (Exception ex)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "下载和安装nupkg包过程中出错", ex);
}
}
public bool IsPackageInstalled(LocalPackageInfo package)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
string source = "";
string f2 = "";
string filename = "";
string dir = "";
string target = "";
try
{
source = System.IO.Path.Combine(installedPath, f);
f2 = f.Substring(f.IndexOf("/", 4) + 1);
filename = System.IO.Path.GetFileName(f2);
dir = System.IO.Path.GetDirectoryName(f2);
target = System.IO.Path.Combine(Destinationfolder, dir, filename);
if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir));
}
if (!System.IO.File.Exists(source))
{
return(false);
}
if (!System.IO.File.Exists(target))
{
return(false);
}
var infoOld = new System.IO.FileInfo(source);
var infoNew = new System.IO.FileInfo(target);
if (infoNew.LastWriteTime != infoOld.LastWriteTime)
{
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(Project project, PackageIdentity identity, bool LoadDlls)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(PackagesInstallFolder,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
InstallPackage(TargetFolder, packageToInstall, LoadDlls);
}
}
return(result);
}
public NuspecReader GetNuspecReaderInPackagesInstallFolder(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
return(packageReader.NuspecReader);
}
public void UninstallPackage(PackageIdentity identity)
{
var package = getLocal(identity.Id);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
}
}
}
}
}
}
public FolderNuGetProject(string root)
{
if(root == null)
{
throw new ArgumentNullException("root");
}
Root = root;
PackagePathResolver = new PackagePathResolver(root);
PackageSaveMode = PackageSaveModes.Nupkg;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, root);
InternalMetadata.Add(NuGetProjectMetadataKeys.TargetFramework, NuGetFramework.AnyFramework);
}
private static async Task <IEnumerable <string> > CopySatelliteFilesAsync(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
await VerifyPackageSignatureAsync(packageReader.GetIdentity(), packageExtractionContext, packageReader, token);
var satelliteFilesCopied = Enumerable.Empty <string>();
var result = await PackageHelper.GetSatelliteFilesAsync(packageReader, packagePathResolver, token);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2
.Where(file => PackageHelper.IsPackageFile(file, packageSaveMode))
.ToList();
if (satelliteFiles.Count > 0)
{
var packageFileExtractor = new PackageFileExtractor(satelliteFiles, packageExtractionContext.XmlDocFileSaveMode);
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await packageReader.CopyFilesAsync(
runtimePackageDirectory,
satelliteFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token);
}
return(satelliteFilesCopied);
}
public RestoreAndUninstallNuGetPackageAction (
IMonoDevelopSolutionManager solutionManager,
IDotNetProject dotNetProject)
{
this.dotNetProject = dotNetProject;
nugetProject = solutionManager.GetNuGetProject (dotNetProject) as MSBuildNuGetProject;
packagePathResolver = new PackagePathResolver (nugetProject.GetPackagesFolderPath (solutionManager));
restoreAction = new RestoreNuGetPackagesInProjectAction (
dotNetProject.DotNetProject,
nugetProject,
solutionManager);
uninstallAction = new UninstallNuGetPackageAction (solutionManager, dotNetProject);
}
public async Task <List <PackageSearchItem> > GetLocal(Project project, PackageIdentity identity)
{
var result = new List <PackageSearchItem>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
result.Add(new PackageSearchItem(project, packageReader));
}
}
}
return(result);
}
private static IEnumerable <string> CopySatelliteFiles(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var satelliteFilesCopied = Enumerable.Empty <string>();
string runtimePackageDirectory;
var satelliteFiles = PackageHelper
.GetSatelliteFiles(packageReader, packagePathResolver, out runtimePackageDirectory)
.Where(file => PackageHelper.IsPackageFile(file, packageSaveMode))
.ToList();
if (satelliteFiles.Count > 0)
{
var packageFileExtractor = new PackageFileExtractor(satelliteFiles, packageExtractionContext.XmlDocFileSaveMode);
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = packageReader.CopyFiles(
runtimePackageDirectory,
satelliteFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token);
}
return(satelliteFilesCopied);
}
public static Tuple <string, IEnumerable <ZipFilePair> > GetInstalledSatelliteFiles(
PackageArchiveReader packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode)
{
var installedSatelliteFiles = Enumerable.Empty <ZipFilePair>();
string runtimePackageDirectory;
var satelliteFiles = GetSatelliteFiles(packageReader, packagePathResolver, out runtimePackageDirectory);
if (satelliteFiles.Any())
{
var satelliteFileEntries = packageReader.EnumeratePackageEntries(
satelliteFiles.Where(f => IsPackageFile(f, packageSaveMode)),
runtimePackageDirectory);
installedSatelliteFiles = satelliteFileEntries.Where(e => e.IsInstalled());
}
return(new Tuple <string, IEnumerable <ZipFilePair> >(runtimePackageDirectory, installedSatelliteFiles.ToList()));
}
/// <summary>
/// This returns all the installed package files (does not include satellite files)
/// </summary>
public static IEnumerable <ZipFilePair> GetInstalledPackageFiles(
PackageArchiveReader packageReader,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode)
{
var installedPackageFiles = Enumerable.Empty <ZipFilePair>();
var packageDirectory = packagePathResolver.GetInstalledPath(packageIdentity);
if (!string.IsNullOrEmpty(packageDirectory))
{
var packageFiles = packageReader.GetPackageFiles(packageSaveMode);
var entries = packageReader.EnumeratePackageEntries(packageFiles, packageDirectory);
installedPackageFiles = entries.Where(e => e.IsInstalled());
}
return(installedPackageFiles.ToList());
}
/// <summary>
/// This returns all the installed package files (does not include satellite files)
/// </summary>
public static async Task <IEnumerable <ZipFilePair> > GetInstalledPackageFilesAsync(
PackageArchiveReader packageReader,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
CancellationToken cancellationToken)
{
var installedPackageFiles = Enumerable.Empty <ZipFilePair>();
var packageDirectory = packagePathResolver.GetInstalledPath(packageIdentity);
if (!string.IsNullOrEmpty(packageDirectory))
{
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, cancellationToken);
var entries = packageReader.EnumeratePackageEntries(packageFiles, packageDirectory);
installedPackageFiles = entries.Where(e => e.IsInstalled());
}
return(installedPackageFiles.ToList());
}
public static async Task <Tuple <string, IEnumerable <ZipFilePair> > > GetInstalledSatelliteFilesAsync(
PackageArchiveReader packageReader,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
CancellationToken cancellationToken)
{
var installedSatelliteFiles = Enumerable.Empty <ZipFilePair>();
var result = await GetSatelliteFilesAsync(packageReader, packagePathResolver, cancellationToken);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
if (satelliteFiles.Any())
{
var satelliteFileEntries = packageReader.EnumeratePackageEntries(
satelliteFiles.Where(f => IsPackageFile(f, packageSaveMode)),
runtimePackageDirectory);
installedSatelliteFiles = satelliteFileEntries.Where(e => e.IsInstalled());
}
return(new Tuple <string, IEnumerable <ZipFilePair> >(runtimePackageDirectory, installedSatelliteFiles.ToList()));
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
await Download(packageToInstall);
await InstallPackage(packageToInstall);
}
}
return(result);
}
public static async Task <IEnumerable <string> > CopySatelliteFilesAsync(
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
var satelliteFilesCopied = Enumerable.Empty <string>();
var nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageReader = new PackageArchiveReader(nupkgFilePath))
{
return(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
}
return(satelliteFilesCopied);
}
public bool InstallPackage(string TargetFolder, PackageIdentity identity, bool LoadDlls)
{
bool ret = true;
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(TargetFolder, installedPath, f, LoadDlls);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(TargetFolder, installedPath, f, LoadDlls);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
InstallPackage(TargetFolder, local.Identity, LoadDlls);
}
}
}
catch (Exception ex)
{
ret = false;
Log.Error(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(TargetFolder, filename);
CopyIfNewer(f, target);
}
}
}
return(ret);
}
public async Task TestPacManUninstallPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var packageIdentity = NoDependencyLibPackages[0];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
// Main Act
var uninstallationContext = new UninstallationContext();
await nuGetPackageManager.UninstallPackageAsync(msBuildNuGetProject, packageIdentity.Id,
uninstallationContext, testNuGetProjectContext, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(!File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
public static IEnumerable<string> GetPackageLookupPaths(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packageIdentity.Version == null)
{
throw new ArgumentNullException(nameof(packageIdentity) + ".Version");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
var packageId = packageIdentity.Id;
var version = packageIdentity.Version;
var root = packagePathResolver.Root;
// Files created by the path resolver. This would take into account the non-side-by-side scenario
// and we do not need to match this for id and version.
var packageFileName = packagePathResolver.GetPackageFileName(packageIdentity);
var manifestFileName = Path.ChangeExtension(packageFileName, PackagingCoreConstants.NuspecExtension);
var filesMatchingFullName = GetPackageFiles(root, packageFileName)
.Concat(GetPackageFiles(root, manifestFileName));
if (version != null
&& version.Version.Revision < 1)
{
// If the build or revision number is not set, we need to look for combinations of the format
// * Foo.1.2.nupkg
// * Foo.1.2.3.nupkg
// * Foo.1.2.0.nupkg
// * Foo.1.2.0.0.nupkg
// To achieve this, we would look for files named 1.2*.nupkg if both build and revision are 0 and
// 1.2.3*.nupkg if only the revision is set to 0.
var partialName = version.Version.Build < 1 ?
String.Join(".", packageId, version.Version.Major, version.Version.Minor) :
String.Join(".", packageId, version.Version.Major, version.Version.Minor, version.Version.Build);
var partialManifestName = partialName + "*" + PackagingCoreConstants.NuspecExtension;
partialName += "*" + PackagingCoreConstants.NupkgExtension;
// Partial names would result is gathering package with matching major and minor but different build and revision.
// Attempt to match the version in the path to the version we're interested in.
var partialNameMatches = GetPackageFiles(root, partialName).Where(path => FileNameMatchesPattern(packageIdentity, path));
var partialManifestNameMatches = GetPackageFiles(root, partialManifestName).Where(
path => FileNameMatchesPattern(packageIdentity, path));
return Enumerable.Concat(filesMatchingFullName, partialNameMatches).Concat(partialManifestNameMatches);
}
return filesMatchingFullName;
}
public async Task TestPacManInstallLowerSpecificVersionOfDependencyPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext(DependencyBehavior.Highest);
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var packageIdentity0 = PackageWithDependents[0];
var dependentPackage = PackageWithDependents[2];
var latestVersion = await NuGetPackageManager.GetLatestVersionAsync(packageIdentity0.Id, resolutionContext,
sourceRepositoryProvider.GetRepositories().First(), token);
var packageLatest = new PackageIdentity(packageIdentity0.Id, latestVersion);
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, dependentPackage,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageLatest, projectAInstalled[0].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest)));
Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage)));
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity0,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity);
Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage)));
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public static string GetInstalledPackageFilePath(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver)
{
var packageLookupPaths = GetPackageLookupPaths(packageIdentity, packagePathResolver);
// TODO: Not handling nuspec-only scenarios
foreach (var packageLookupPath in packageLookupPaths)
{
if (packageLookupPath.EndsWith(PackagingCoreConstants.NupkgExtension, StringComparison.OrdinalIgnoreCase) &&
File.Exists(packageLookupPath))
{
// This is an installed package lookup path which matches the packageIdentity for the given packagePathResolver
return(packageLookupPath);
}
}
return(null);
}
public static async Task<IEnumerable<string>> ExtractPackageAsync(
PackageReaderBase packageReader,
Stream packageStream,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
PackageSaveModes packageSaveMode,
CancellationToken token)
{
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
// TODO: Need to handle PackageSaveMode
// TODO: Support overwriting files also?
var filesAdded = new List<string>();
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
packageIdentity = nuspecReader.GetIdentity();
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentity));
var packageDirectory = packageDirectoryInfo.FullName;
foreach (var file in packageReader.GetFiles().Where(file => PackageHelper.IsPackageFile(file, packageSaveMode)))
{
token.ThrowIfCancellationRequested();
var targetPath = Path.Combine(packageDirectory, file);
Directory.CreateDirectory(Path.GetDirectoryName(targetPath));
using (var sourceStream = packageReader.GetStream(file))
{
using (var targetStream = new FileStream(targetPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 1024, useAsync: true))
{
await sourceStream.CopyToAsync(targetStream);
}
}
filesAdded.Add(file);
}
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentity));
if (packageSaveMode.HasFlag(PackageSaveModes.Nupkg))
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it
if (packageStream.Position != 0)
{
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
packageStream.Position = 0;
}
filesAdded.Add(await PackageHelper.CreatePackageFile(nupkgFilePath, packageStream, token));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext == null || packageExtractionContext.CopySatelliteFiles)
{
PackageIdentity runtimeIdentity;
string packageLanguage;
var isSatellitePackage = PackageHelper.IsSatellitePackage(nuspecReader, out runtimeIdentity, out packageLanguage);
// Short-circuit this if the package is not a satellite package.
if (isSatellitePackage)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(packageIdentity, packagePathResolver, packageSaveMode, token));
}
}
return filesAdded;
}
public InfinniFolderNuGetProject(string root, PackagePathResolver packagePathResolver) : base(root, packagePathResolver)
{
SetSupportedTargetFramework();
}
public static async Task <IEnumerable <string> > ExtractPackageAsync(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
token.ThrowIfCancellationRequested();
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var filesAdded = new List <string>();
var packageIdentityFromNuspec = await packageReader.GetIdentityAsync(token);
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentityFromNuspec));
var packageDirectory = packageDirectoryInfo.FullName;
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, token);
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(await packageReader.CopyFilesAsync(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
if (packageSaveMode.HasFlag(PackageSaveMode.Nupkg))
{
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
var filePath = await packageReader.CopyNupkgAsync(nupkgFilePath, token);
if (!string.IsNullOrEmpty(filePath))
{
filesAdded.Add(filePath);
}
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
return(filesAdded);
}
public async Task TestFolderNuGetProjectDeletePackage()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyContentPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder();
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = packageFileInfo.OpenRead())
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var unNormalizedPackageIdentity = new PackageIdentity(packageIdentity.Id,
new NuGetVersion(packageIdentity.Version + ".0"));
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "Content/Scripts/test1.js")));
using (var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(6, zipArchive.Entries.Count);
}
Assert.True(folderNuGetProject.PackageExists(packageIdentity));
var packageDirectoryPath = folderNuGetProject.GetInstalledPath(unNormalizedPackageIdentity);
Assert.True(!String.IsNullOrEmpty(packageDirectoryPath));
Assert.True(Directory.Exists(packageDirectoryPath));
// Main Act
await folderNuGetProject.DeletePackage(packageIdentity, testNuGetProjectContext, CancellationToken.None);
// Assert
Assert.False(folderNuGetProject.PackageExists(unNormalizedPackageIdentity));
// Check that the package directories are deleted
Assert.False(Directory.Exists(packageDirectoryPath));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath);
}
public static bool GetSatelliteFiles(Stream packageStream, PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
out string language, out string runtimePackageDirectory, out IEnumerable <ZipArchiveEntry> satelliteFiles)
{
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
PackageIdentity runtimePackageIdentity = null;
string packageLanguage = null;
if (PackageHelper.IsSatellitePackage(nuspecReader, out runtimePackageIdentity, out packageLanguage))
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
string runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(runtimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
// Existence of the package file is the validation that the package exists
var libItemGroups = packageReader.GetLibItems();
List <ZipArchiveEntry> satelliteFileEntries = new List <ZipArchiveEntry>();
foreach (var libItemGroup in libItemGroups)
{
var satelliteFilesInGroup = libItemGroup.Items.Where(item => Path.GetDirectoryName(item).Split(Path.DirectorySeparatorChar)
.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));
foreach (var satelliteFile in satelliteFilesInGroup)
{
var zipArchiveEntry = zipArchive.GetEntry(satelliteFile);
if (zipArchiveEntry != null)
{
satelliteFileEntries.Add(zipArchiveEntry);
}
}
}
if (satelliteFileEntries.Count > 0)
{
language = packageLanguage;
satelliteFiles = satelliteFileEntries;
return(true);
}
}
}
language = null;
runtimePackageDirectory = null;
satelliteFiles = null;
return(false);
}
public static async Task <IEnumerable <string> > CopySatelliteFilesAsync(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode, CancellationToken token)
{
IEnumerable <string> satelliteFilesCopied = Enumerable.Empty <string>();
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
string nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageStream = File.OpenRead(nupkgFilePath))
{
string language;
string runtimePackageDirectory;
IEnumerable <ZipArchiveEntry> satelliteFiles;
if (PackageHelper.GetSatelliteFiles(packageStream, packageIdentity, packagePathResolver, out language, out runtimePackageDirectory, out satelliteFiles))
{
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await PackageHelper.CreatePackageFiles(satelliteFiles, runtimePackageDirectory, packageSaveMode, token);
}
}
}
return(satelliteFilesCopied);
}
public static async Task <IEnumerable <string> > ExtractPackageAsync(Stream packageStream, PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
PackageSaveModes packageSaveMode,
CancellationToken token)
{
List <string> filesAdded = new List <string>();
if (packageStream == null)
{
throw new ArgumentNullException("packageStream");
}
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
// TODO: Need to handle PackageSaveMode
// TODO: Support overwriting files also?
long nupkgStartPosition = packageStream.Position;
var zipArchive = new ZipArchive(packageStream);
// default to non-legacy paths
bool useLegacyPaths = packageExtractionContext == null ? false : packageExtractionContext.UseLegacyPackageInstallPath;
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
NuGetVersion packageVersionFromNuspec = nuspecReader.GetVersion();
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(new PackageIdentity(packageIdentity.Id, packageVersionFromNuspec), useLegacyPaths));
string packageDirectory = packageDirectoryInfo.FullName;
filesAdded.AddRange(await PackageHelper.CreatePackageFiles(zipArchive.Entries, packageDirectory, packageSaveMode, token));
string nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentity));
if (packageSaveMode.HasFlag(PackageSaveModes.Nupkg))
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it to the nupkgStartPosition
packageStream.Seek(nupkgStartPosition, SeekOrigin.Begin);
filesAdded.Add(await PackageHelper.CreatePackageFile(nupkgFilePath, packageStream, token));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext == null || packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(packageIdentity, packagePathResolver, packageSaveMode, token));
}
return(filesAdded);
}
public static async Task<IEnumerable<string>> ExtractPackageAsync(
Stream packageStream,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
PackageSaveModes packageSaveMode,
CancellationToken token)
{
var filesAdded = new List<string>();
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
// TODO: Need to handle PackageSaveMode
// TODO: Support overwriting files also?
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
packageIdentity = nuspecReader.GetIdentity();
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentity));
var packageDirectory = packageDirectoryInfo.FullName;
filesAdded.AddRange(await PackageHelper.CreatePackageFiles(zipArchive.Entries, packageDirectory, packageSaveMode, token));
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentity));
if (packageSaveMode.HasFlag(PackageSaveModes.Nupkg))
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it
packageStream.Seek(0, SeekOrigin.Begin);
filesAdded.Add(await PackageHelper.CreatePackageFile(nupkgFilePath, packageStream, token));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext == null
|| packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(packageIdentity, packagePathResolver, packageSaveMode, token));
}
return filesAdded;
}
public NuGetPackageUninstaller (IDotNetProject project, PackagePathResolver packagePathResolver)
{
this.project = project;
this.packagePathResolver = packagePathResolver;
}
public async Task UninstallPackage(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
bool failed = true;
try
{
await PackageExtractor.ExtractPackageAsync(installedPath,
packageReader,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
failed = false;
}
catch (Exception)
{
}
if (failed)
{
try
{
await Download(identity);
installedPath = packagePathResolver.GetInstalledPath(identity);
packageReader = new PackageFolderReader(installedPath);
failed = false;
}
catch (Exception)
{
throw;
}
}
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
}
}
}
}
}
}
/// <summary>
/// This returns all the installed package files (does not include satellite files)
/// </summary>
/// <param name="packageIdentity"></param>
/// <param name="packagePathResolver"></param>
/// <param name="packageDirectory"></param>
/// <param name="packageSaveMode"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task<IEnumerable<ZipFilePair>> GetInstalledPackageFiles(Stream packageStream,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode,
CancellationToken token)
{
var installedPackageFiles = new List<ZipFilePair>();
var packageDirectory = packagePathResolver.GetInstalledPath(packageIdentity);
if (!String.IsNullOrEmpty(packageDirectory))
{
var zipArchive = new ZipArchive(packageStream);
var packageFiles = await GetPackageFiles(zipArchive.Entries, packageDirectory, packageSaveMode, token);
installedPackageFiles.AddRange(GetInstalledPackageFiles(packageFiles));
}
return installedPackageFiles;
}
public static async Task <IEnumerable <string> > ExtractPackageAsync(
string source,
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token,
Guid parentId = default(Guid))
{
if (packageReader == null)
{
throw new ArgumentNullException(nameof(packageReader));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
token.ThrowIfCancellationRequested();
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var extractionId = Guid.NewGuid();
var filesAdded = new List <string>();
using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId(parentId))
{
var packageIdentityFromNuspec = await packageReader.GetIdentityAsync(token);
try
{
telemetry.StartIntervalMeasure();
await VerifyPackageSignatureAsync(
source,
telemetry.OperationId,
packageIdentityFromNuspec,
packageExtractionContext,
packageReader,
token);
telemetry.EndIntervalMeasure(PackagingConstants.PackageVerifyDurationName);
}
catch (SignatureException)
{
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Failed,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
throw;
}
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentityFromNuspec));
var packageDirectory = packageDirectoryInfo.FullName;
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, token);
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(await packageReader.CopyFilesAsync(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
if (packageSaveMode.HasFlag(PackageSaveMode.Nupkg))
{
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
var filePath = await packageReader.CopyNupkgAsync(nupkgFilePath, token);
if (!string.IsNullOrEmpty(filePath))
{
filesAdded.Add(filePath);
}
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Succeeded,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
return(filesAdded);
}
}
public static async Task<Tuple<string, IEnumerable<ZipFilePair>>> GetInstalledSatelliteFiles(Stream packageStream,
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode,
CancellationToken token)
{
var installedSatelliteFiles = new List<ZipFilePair>();
string language;
string runtimePackageDirectory;
IEnumerable<ZipArchiveEntry> satelliteFileEntries;
if (GetSatelliteFiles(packageStream, packageIdentity, packagePathResolver, out language, out runtimePackageDirectory, out satelliteFileEntries))
{
var satelliteFiles = await GetPackageFiles(satelliteFileEntries, runtimePackageDirectory, packageSaveMode, token);
installedSatelliteFiles.AddRange(GetInstalledPackageFiles(satelliteFiles));
}
return new Tuple<string, IEnumerable<ZipFilePair>>(runtimePackageDirectory, installedSatelliteFiles);
}
public static IEnumerable <string> GetPackageLookupPaths(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver)
{
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packageIdentity.Version == null)
{
throw new ArgumentNullException("packageIdentity.Version");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
var packageId = packageIdentity.Id;
var version = packageIdentity.Version;
var root = packagePathResolver.Root;
// Files created by the path resolver. This would take into account the non-side-by-side scenario
// and we do not need to match this for id and version.
var packageFileName = packagePathResolver.GetPackageFileName(packageIdentity);
var manifestFileName = Path.ChangeExtension(packageFileName, PackagingCoreConstants.NuspecExtension);
var filesMatchingFullName = Enumerable.Concat(
GetPackageFiles(root, packageFileName),
GetPackageFiles(root, manifestFileName));
if (version != null &&
version.Version.Revision < 1)
{
// If the build or revision number is not set, we need to look for combinations of the format
// * Foo.1.2.nupkg
// * Foo.1.2.3.nupkg
// * Foo.1.2.0.nupkg
// * Foo.1.2.0.0.nupkg
// To achieve this, we would look for files named 1.2*.nupkg if both build and revision are 0 and
// 1.2.3*.nupkg if only the revision is set to 0.
var partialName = version.Version.Build < 1 ?
String.Join(".", packageId, version.Version.Major, version.Version.Minor) :
String.Join(".", packageId, version.Version.Major, version.Version.Minor, version.Version.Build);
var partialManifestName = partialName + "*" + PackagingCoreConstants.NuspecExtension;
partialName += "*" + PackagingCoreConstants.NupkgExtension;
// Partial names would result is gathering package with matching major and minor but different build and revision.
// Attempt to match the version in the path to the version we're interested in.
var partialNameMatches = GetPackageFiles(root, partialName).Where(path => FileNameMatchesPattern(packageIdentity, path));
var partialManifestNameMatches = GetPackageFiles(root, partialManifestName).Where(
path => FileNameMatchesPattern(packageIdentity, path));
return(Enumerable.Concat(filesMatchingFullName, partialNameMatches).Concat(partialManifestNameMatches));
}
return(filesMatchingFullName);
}
public static bool GetSatelliteFiles(Stream packageStream, PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
out string language, out string runtimePackageDirectory, out IEnumerable<ZipArchiveEntry> satelliteFiles)
{
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
PackageIdentity runtimePackageIdentity = null;
string packageLanguage = null;
if (IsSatellitePackage(nuspecReader, out runtimePackageIdentity, out packageLanguage))
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
var runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(runtimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
// Existence of the package file is the validation that the package exists
var libItemGroups = packageReader.GetLibItems();
var satelliteFileEntries = new List<ZipArchiveEntry>();
foreach (var libItemGroup in libItemGroups)
{
var satelliteFilesInGroup = libItemGroup.Items.Where(item => Path.GetDirectoryName(item).Split(Path.DirectorySeparatorChar)
.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));
foreach (var satelliteFile in satelliteFilesInGroup)
{
var zipArchiveEntry = zipArchive.GetEntry(satelliteFile);
if (zipArchiveEntry != null)
{
satelliteFileEntries.Add(zipArchiveEntry);
}
}
}
if (satelliteFileEntries.Count > 0)
{
language = packageLanguage;
satelliteFiles = satelliteFileEntries;
return true;
}
}
}
language = null;
runtimePackageDirectory = null;
satelliteFiles = null;
return false;
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, OpenRPAPackageManagerLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, OpenRPAPackageManagerLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
// PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
}
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
InstallPackage(packageToInstall);
}
}
return(result);
}
public static IEnumerable <string> ExtractPackage(
PackageReaderBase packageReader,
Stream packageStream,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var nupkgStartPosition = packageStream.Position;
var filesAdded = new List <string>();
var packageIdentityFromNuspec = packageReader.GetIdentity();
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentityFromNuspec));
var packageDirectory = packageDirectoryInfo.FullName;
var packageFiles = packageReader.GetPackageFiles(packageSaveMode);
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(packageReader.CopyFiles(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
if (packageSaveMode.HasFlag(PackageSaveMode.Nupkg))
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it to the nupkgStartPosition
if (packageStream.Position != 0)
{
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
packageStream.Position = 0;
}
filesAdded.Add(packageStream.CopyToFile(nupkgFilePath));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(CopySatelliteFiles(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
return(filesAdded);
}
public async Task TestPacManUninstallPackageOnMultipleProjects()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = NoDependencyLibPackages[0];
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
var projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, projectAInstalled.Count);
Assert.Equal(1, projectBInstalled.Count);
// Main Act
var uninstallationContext = new UninstallationContext();
await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity.Id,
uninstallationContext, testNuGetProjectContext, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, projectAInstalled.Count);
Assert.Equal(1, projectBInstalled.Count);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public static IEnumerable <string> ExtractPackage(
Stream packageStream,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var filesAdded = new List <string>();
var nupkgStartPosition = packageStream.Position;
using (var packageReader = new PackageArchiveReader(packageStream, leaveStreamOpen: true))
{
var packageIdentityFromNuspec = packageReader.GetIdentity();
var installPath = packagePathResolver.GetInstallPath(packageIdentityFromNuspec);
var packageDirectoryInfo = Directory.CreateDirectory(installPath);
var packageDirectory = packageDirectoryInfo.FullName;
var packageFiles = packageReader.GetPackageFiles(packageSaveMode);
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
var sourceNuspecFile = packageFiles.Single(p => PackageHelper.IsManifest(p));
var targetNuspecPath = Path.Combine(
packageDirectory,
packagePathResolver.GetManifestFileName(packageIdentityFromNuspec));
// Extract the .nuspec file with a well known file name.
filesAdded.Add(packageReader.ExtractFile(
sourceNuspecFile,
targetNuspecPath,
packageExtractionContext.Logger));
packageFiles = packageFiles.Except(new[] { sourceNuspecFile });
}
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(packageReader.CopyFiles(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
if ((packageSaveMode & PackageSaveMode.Nupkg) == PackageSaveMode.Nupkg)
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it to the nupkgStartPosition
packageStream.Seek(nupkgStartPosition, SeekOrigin.Begin);
var nupkgFilePath = Path.Combine(
packageDirectory,
packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
filesAdded.Add(packageStream.CopyToFile(nupkgFilePath));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(CopySatelliteFiles(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
}
return(filesAdded);
}
public static string GetInstalledPackageFilePath(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver)
{
var packageLookupPaths = GetPackageLookupPaths(packageIdentity, packagePathResolver);
if (packageLookupPaths.Any())
{
// TODO: Not handling nuspec-only scenarios
foreach (var packageLookupPath in packageLookupPaths)
{
if (packageLookupPath.EndsWith(PackagingCoreConstants.NupkgExtension, StringComparison.OrdinalIgnoreCase)
&& File.Exists(packageLookupPath))
{
// This is an installed package lookup path which matches the packageIdentity for the given packagePathResolver
return packageLookupPath;
}
}
}
return null;
}
public async Task TestPacManInstallPackageWhichUsesExistingDependency()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var packageIdentity0 = PackageWithDependents[0];
var packageIdentity1 = PackageWithDependents[1];
var packageIdentity2 = PackageWithDependents[2];
var packageIdentity3 = PackageWithDependents[3];
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(3, projectAInstalled.Count);
Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity2, projectAInstalled[2].PackageIdentity);
Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity);
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public async Task TestPacManOpenReadmeFile()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var testNuGetProjectContext = new TestNuGetProjectContext();
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext);
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var packageIdentity = new PackageIdentity("elmah", new NuGetVersion("1.2.2"));
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
// Set the direct install on the execution context of INuGetProjectContext before installing a package
testNuGetProjectContext.TestExecutionContext = new TestExecutionContext(packageIdentity);
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
Assert.Equal(1, testNuGetProjectContext.TestExecutionContext.FilesOpened.Count);
Assert.True(String.Equals(Path.Combine(packagePathResolver.GetInstallPath(packageIdentity), "ReadMe.txt"),
testNuGetProjectContext.TestExecutionContext.FilesOpened.First(), StringComparison.OrdinalIgnoreCase));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
private void ExecuteInitScripts()
{
// Fix for Bug 1426 Disallow ExecuteInitScripts from being executed concurrently by multiple threads.
lock (_initScriptsLock)
{
if (!_solutionManager.IsSolutionOpen)
{
return;
}
Debug.Assert(_settings != null);
if (_settings == null)
{
return;
}
try
{
// invoke init.ps1 files in the order of package dependency.
// if A -> B, we invoke B's init.ps1 before A's.
IEnumerable<NuGetProject> projects = _solutionManager.GetNuGetProjects();
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager);
List<PackageIdentity> sortedPackages = new List<PackageIdentity>();
foreach (NuGetProject project in projects)
{
// Skip project K projects.
if (project is NuGet.ProjectManagement.Projects.ProjectKNuGetProjectBase)
{
continue;
}
IEnumerable<PackageReference> installedRefs = project.GetInstalledPackagesAsync(CancellationToken.None).Result;
if (installedRefs != null && installedRefs.Any())
{
IEnumerable<PackageIdentity> installedPackages = packageManager.GetInstalledPackagesInDependencyOrder(project, new EmptyNuGetProjectContext(), CancellationToken.None).Result;
sortedPackages.AddRange(installedPackages);
}
}
// Get the path to the Packages folder.
string packagesFolderPath = packageManager.PackagesFolderSourceRepository.PackageSource.Source;
foreach (var package in sortedPackages)
{
PackagePathResolver packagePathResolver = new PackagePathResolver(packagesFolderPath);
string pathToPackage = packagePathResolver.GetInstalledPath(package);
string toolsPath = Path.Combine(pathToPackage, "tools");
AddPathToEnvironment(toolsPath);
Runspace.ExecuteScript(toolsPath, PowerShellScripts.Init, package);
}
}
catch (Exception ex)
{
// When Packages folder is not present, NuGetResolverInputException will be thrown
// as resolving DependencyInfo requires the presence of Packages folder.
if (ex.InnerException is NuGetResolverInputException)
{
// Silently fail.
}
else
{
// if execution of Init scripts fails, do not let it crash our console
ReportError(ex);
}
ExceptionHelper.WriteToActivityLog(ex);
}
}
}
public async Task TestPacManReinstallPackages()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var folderNuGetProject = msBuildNuGetProject.FolderNuGetProject;
var packageIdentity = MorePackageWithDependents[3]; // Microsoft.Net.Http.2.2.22
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(3, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[2].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[2].TargetFramework);
Assert.Equal(MorePackageWithDependents[0], packagesInPackagesConfig[1].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework);
Assert.Equal(MorePackageWithDependents[2], packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
var installedPackageIdentities = (await msBuildNuGetProject.GetInstalledPackagesAsync(token))
.Select(pr => pr.PackageIdentity);
// Act
var packageActions = (await nuGetPackageManager.PreviewReinstallPackagesAsync(installedPackageIdentities, msBuildNuGetProject,
new ResolutionContext(DependencyBehavior.Highest), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(),
null, token)).ToList();
// Assert
var singlePackageSource = sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source;
Assert.Equal(6, packageActions.Count);
Assert.True(MorePackageWithDependents[3].Equals(packageActions[0].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Uninstall, packageActions[0].NuGetProjectActionType);
Assert.True(MorePackageWithDependents[2].Equals(packageActions[1].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Uninstall, packageActions[1].NuGetProjectActionType);
Assert.True(MorePackageWithDependents[0].Equals(packageActions[2].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Uninstall, packageActions[2].NuGetProjectActionType);
Assert.True(MorePackageWithDependents[0].Equals(packageActions[3].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[3].NuGetProjectActionType);
Assert.Equal(singlePackageSource, packageActions[3].SourceRepository.PackageSource.Source);
Assert.True(MorePackageWithDependents[2].Equals(packageActions[4].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[4].NuGetProjectActionType);
Assert.Equal(singlePackageSource, packageActions[4].SourceRepository.PackageSource.Source);
Assert.True(MorePackageWithDependents[3].Equals(packageActions[5].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[5].NuGetProjectActionType);
Assert.Equal(singlePackageSource, packageActions[5].SourceRepository.PackageSource.Source);
// Main Act
await nuGetPackageManager.ExecuteNuGetProjectActionsAsync(msBuildNuGetProject, packageActions, new TestNuGetProjectContext(), token);
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(3, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[2].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[2].TargetFramework);
Assert.Equal(MorePackageWithDependents[0], packagesInPackagesConfig[1].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework);
Assert.Equal(MorePackageWithDependents[2], packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
Assert.True(File.Exists(folderNuGetProject.GetInstalledPackageFilePath(packageIdentity)));
Assert.True(File.Exists(folderNuGetProject.GetInstalledPackageFilePath(MorePackageWithDependents[0])));
Assert.True(File.Exists(folderNuGetProject.GetInstalledPackageFilePath(MorePackageWithDependents[2])));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
public static async Task <IEnumerable <string> > ExtractPackageAsync(
string source,
PackageReaderBase packageReader,
Stream packageStream,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token,
Guid parentId = default(Guid))
{
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var extractionId = Guid.NewGuid();
var nupkgStartPosition = packageStream.Position;
var filesAdded = new List <string>();
using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId(parentId))
{
var packageIdentityFromNuspec = await packageReader.GetIdentityAsync(token);
try
{
telemetry.StartIntervalMeasure();
await VerifyPackageSignatureAsync(
source,
telemetry.OperationId,
packageIdentityFromNuspec,
packageExtractionContext,
packageReader,
token);
telemetry.EndIntervalMeasure(PackagingConstants.PackageVerifyDurationName);
}
catch (SignatureException)
{
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Failed,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
throw;
}
var packageDirectoryInfo = Directory.CreateDirectory(packagePathResolver.GetInstallPath(packageIdentityFromNuspec));
var packageDirectory = packageDirectoryInfo.FullName;
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, token);
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(await packageReader.CopyFilesAsync(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
var nupkgFilePath = Path.Combine(packageDirectory, packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
if (packageSaveMode.HasFlag(PackageSaveMode.Nupkg))
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it to the nupkgStartPosition
if (packageStream.Position != 0)
{
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
packageStream.Position = 0;
}
filesAdded.Add(packageStream.CopyToFile(nupkgFilePath));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Succeeded,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
return(filesAdded);
}
}
public async Task TestPacManUninstallWithRemoveDependenciesWithVDependency()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var packageIdentity0 = PackageWithDependents[0];
var packageIdentity1 = PackageWithDependents[1];
var packageIdentity2 = PackageWithDependents[2];
var packageIdentity3 = PackageWithDependents[3];
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity2, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(3, projectAInstalled.Count);
Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity2, projectAInstalled[2].PackageIdentity);
Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity);
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3)));
// Main Act
Exception exception = null;
try
{
var uninstallationContext = new UninstallationContext(removeDependencies: true);
await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity2.Id,
uninstallationContext, testNuGetProjectContext, token);
}
catch (InvalidOperationException ex)
{
exception = ex;
}
catch (AggregateException ex)
{
exception = ExceptionUtility.Unwrap(ex);
}
Assert.NotNull(exception);
Assert.True(exception is InvalidOperationException);
Assert.Equal("Unable to uninstall 'jQuery.1.6.4' because 'jQuery.UI.Combined.1.11.2' depends on it.",
exception.Message);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public static async Task <IEnumerable <string> > ExtractPackageAsync(
string source,
Stream packageStream,
PackagePathResolver packagePathResolver,
PackageExtractionContext packageExtractionContext,
CancellationToken token,
Guid parentId = default(Guid))
{
if (packageStream == null)
{
throw new ArgumentNullException(nameof(packageStream));
}
if (!packageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable);
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
if (packageExtractionContext == null)
{
throw new ArgumentNullException(nameof(packageExtractionContext));
}
var packageSaveMode = packageExtractionContext.PackageSaveMode;
var filesAdded = new List <string>();
var nupkgStartPosition = packageStream.Position;
using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId(parentId))
{
using (var packageReader = new PackageArchiveReader(packageStream, leaveStreamOpen: true))
{
var packageIdentityFromNuspec = await packageReader.GetIdentityAsync(CancellationToken.None);
var installPath = packagePathResolver.GetInstallPath(packageIdentityFromNuspec);
var packageDirectoryInfo = Directory.CreateDirectory(installPath);
var packageDirectory = packageDirectoryInfo.FullName;
try
{
telemetry.StartIntervalMeasure();
await VerifyPackageSignatureAsync(
source,
telemetry.OperationId,
packageIdentityFromNuspec,
packageExtractionContext,
packageReader,
token);
telemetry.EndIntervalMeasure(PackagingConstants.PackageVerifyDurationName);
}
catch (SignatureException)
{
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Failed,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
throw;
}
var packageFiles = await packageReader.GetPackageFilesAsync(packageSaveMode, token);
if ((packageSaveMode & PackageSaveMode.Nuspec) == PackageSaveMode.Nuspec)
{
var sourceNuspecFile = packageFiles.Single(p => PackageHelper.IsManifest(p));
var targetNuspecPath = Path.Combine(
packageDirectory,
packagePathResolver.GetManifestFileName(packageIdentityFromNuspec));
// Extract the .nuspec file with a well known file name.
filesAdded.Add(packageReader.ExtractFile(
sourceNuspecFile,
targetNuspecPath,
packageExtractionContext.Logger));
packageFiles = packageFiles.Except(new[] { sourceNuspecFile });
}
var packageFileExtractor = new PackageFileExtractor(packageFiles, packageExtractionContext.XmlDocFileSaveMode);
filesAdded.AddRange(await packageReader.CopyFilesAsync(
packageDirectory,
packageFiles,
packageFileExtractor.ExtractPackageFile,
packageExtractionContext.Logger,
token));
if ((packageSaveMode & PackageSaveMode.Nupkg) == PackageSaveMode.Nupkg)
{
// During package extraction, nupkg is the last file to be created
// Since all the packages are already created, the package stream is likely positioned at its end
// Reset it to the nupkgStartPosition
packageStream.Seek(nupkgStartPosition, SeekOrigin.Begin);
var nupkgFilePath = Path.Combine(
packageDirectory,
packagePathResolver.GetPackageFileName(packageIdentityFromNuspec));
filesAdded.Add(packageStream.CopyToFile(nupkgFilePath));
}
// Now, copy satellite files unless requested to not copy them
if (packageExtractionContext.CopySatelliteFiles)
{
filesAdded.AddRange(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
telemetry.TelemetryEvent = new PackageExtractionTelemetryEvent(
packageExtractionContext.PackageSaveMode,
NuGetOperationStatus.Succeeded,
ExtractionSource.NuGetFolderProject,
packageIdentityFromNuspec);
}
return(filesAdded);
}
}
public async Task Download(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
if (identity.HasVersion && !string.IsNullOrEmpty(installedPath))
{
var idstring = identity.Id + "." + identity.Version;
if (installedPath.Contains(idstring))
{
return;
}
}
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageWithoutDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
var packageToInstall = availablePackages.Where(p => p.Id == identity.Id).FirstOrDefault();
if (packageToInstall == null)
{
throw new Exception("Failed finding package " + identitystring(identity));
}
// var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
var frameworkReducer = new FrameworkReducer();
// PackageReaderBase packageReader;
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
//if (installedPath == null)
//{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
// }
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
}
return;
}
public static async Task<IEnumerable<string>> CopySatelliteFilesAsync(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode, CancellationToken token)
{
var satelliteFilesCopied = Enumerable.Empty<string>();
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
var nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageStream = File.OpenRead(nupkgFilePath))
{
string language;
string runtimePackageDirectory;
IEnumerable<ZipArchiveEntry> satelliteFiles;
if (PackageHelper.GetSatelliteFiles(packageStream, packageIdentity, packagePathResolver, out language, out runtimePackageDirectory, out satelliteFiles))
{
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await PackageHelper.CreatePackageFiles(satelliteFiles, runtimePackageDirectory, packageSaveMode, token);
}
}
}
return satelliteFilesCopied;
}
