private PackageHelperTest(
TestDirectory testDirectory,
PackageArchiveReader reader,
TestPackagesCore.TempFile tempFile)
{
Reader = reader;
_testDirectory = testDirectory;
_tempFile = tempFile;
Resolver = new PackagePathResolver(_testDirectory.Path);
Root = testDirectory.Path;
}
public async Task GetInstalledSatelliteFilesAsync_ReturnsEmptyEnumerableForNoInstalledSatelliteFiles()
{
using (var test = PackageHelperTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
using (var testDirectory = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.2.3"));
var packagePathResolver = new PackagePathResolver(testDirectory.Path);
var packageFileInfo = await TestPackagesCore.GetRuntimePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var satellitePackageInfo = await TestPackagesCore.GetSatellitePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
language : "fr");
// Install runtime package
using (var packageReader = new PackageArchiveReader(File.OpenRead(packageFileInfo.FullName)))
using (var packageStream = File.OpenRead(packageFileInfo.FullName))
{
await PackageExtractor.ExtractPackageAsync(
test.Root,
packageReader,
packageStream,
packagePathResolver,
new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext : null,
logger : NullLogger.Instance),
CancellationToken.None);
}
using (var packageReader = new PackageArchiveReader(File.OpenRead(satellitePackageInfo.FullName)))
{
var result = await PackageHelper.GetInstalledSatelliteFilesAsync(
packageReader,
packagePathResolver,
PackageSaveMode.Defaultv3,
CancellationToken.None);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
var packageDirectoryName = $"{packageIdentity.Id}.{packageIdentity.Version.ToNormalizedString()}";
Assert.Equal(Path.Combine(testDirectory.Path, packageDirectoryName), runtimePackageDirectory);
Assert.Empty(satelliteFiles);
}
}
}
}
public void GetInstalledPackageFilePath_ReturnsNullIfFileDoesNotExist(bool useSideBySidePaths)
{
using (var testDirectory = TestDirectory.Create())
{
var target = new PackagePathResolver(testDirectory.Path, useSideBySidePaths);
var filePath = target.GetInstalledPackageFilePath(PackageIdentity);
Assert.Null(filePath);
}
}
public FolderNuGetProject(string root, PackagePathResolver packagePathResolver)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
Root = root;
PackagePathResolver = packagePathResolver;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, root);
InternalMetadata.Add(NuGetProjectMetadataKeys.TargetFramework, NuGetFramework.AnyFramework);
}
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);
}
public async Task InstallPackageAsync_WithSourceControlEnabled()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath
= Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testSourceControlManager = new TestSourceControlManager();
var testNuGetProjectContext = new TestNuGetProjectContext()
{
SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager)
};
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(
packageIdentity,
packageStream,
testNuGetProjectContext,
token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.Equal(5, testSourceControlManager.PendAddedFiles.Count);
Assert.True(testSourceControlManager.PendAddedFiles.Contains(nupkgFilePath));
var expectedEntries = new[]
{
"lib/test.dll",
"lib/net40/test40.dll",
"lib/net40/test40b.dll",
"lib/net45/test45.dll"
};
Assert.All(
expectedEntries.Select(e => Path.Combine(packageInstallPath, e.Replace('/', Path.DirectorySeparatorChar))),
item => Assert.Contains(item, testSourceControlManager.PendAddedFiles));
}
}
public async Task InstallPackageAsync_WithSourceControlDisabled()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
// Create a nuget.config file with source control disabled
File.WriteAllText(
Path.Combine(randomTestSourcePath, "nuget.config"),
@"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<solution>
<add key=""disableSourceControlIntegration"" value=""true"" />
</solution >
</configuration>");
var settings = new Settings(randomTestSourcePath);
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath
= Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testSourceControlManager = new TestSourceControlManager(settings);
var testNuGetProjectContext = new TestNuGetProjectContext()
{
SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager)
};
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(
packageIdentity,
packageStream,
testNuGetProjectContext,
token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.Equal(0, testSourceControlManager.PendAddedFiles.Count);
}
}
/// <summary>
/// Initialize NugetStore using <paramref name="rootDirectory"/> as location of the local copies,
/// and a configuration file <paramref name="configFile"/> as well as an override configuration
/// file <paramref name="overrideFile"/> where all settings of <paramref name="overrideFile"/> also
/// presents in <paramref name="configFile"/> take precedence.
/// </summary>
/// <param name="rootDirectory">The location of the Nuget store.</param>
public NugetStore(string rootDirectory, string configFile = DefaultConfig)
{
RootDirectory = rootDirectory ?? throw new ArgumentNullException(nameof(rootDirectory));
settings = NuGet.Configuration.Settings.LoadDefaultSettings(rootDirectory);
// Add dev source
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(DevSource));
CheckPackageSource("Xenko Dev", DevSource);
CheckPackageSource("Xenko", DefaultPackageSource);
// Override file does not exist, fallback to default config file
var configFileName = configFile;
var configFilePath = Path.Combine(rootDirectory, configFileName);
if (File.Exists(configFilePath))
{
localSettings = NuGet.Configuration.Settings.LoadDefaultSettings(rootDirectory, configFileName, machineWideSettings: null);
// Replicate packageSources in user config so that NuGet restore can find them as well
foreach (var x in localSettings.GetSettingValues("packageSources", true))
{
CheckPackageSource(x.Key, x.Value);
}
}
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext);
var packageSourceProvider = new PackageSourceProvider(settings);
var availableSources = packageSourceProvider.LoadPackageSources().Where(source => source.IsEnabled);
var packageSources = new List <PackageSource>();
packageSources.AddRange(availableSources);
PackageSources = packageSources;
// Setup source provider as a V3 only.
sourceRepositoryProvider = new NugetSourceRepositoryProvider(packageSourceProvider, this);
manager = new NuGetPackageManager(sourceRepositoryProvider, settings, InstallPath);
// Override PackagePathResolver
// Workaround for https://github.com/NuGet/Home/issues/6639
manager.PackagesFolderNuGetProject.GetType().GetProperty("PackagePathResolver", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(manager.PackagesFolderNuGetProject, new PackagePathResolverV3(InstallPath));
// Obsolete (Xenko 2.x support)
InstallPathV2 = Path.Combine(RootDirectory, DefaultGamePackagesDirectory);
managerV2 = new NuGetPackageManager(sourceRepositoryProvider, settings, InstallPathV2);
PathResolverV2 = new PackagePathResolver(InstallPathV2);
}
public void GetPackageFileName_ReturnsPackageFileName(bool useSideBySidePaths, string expected)
{
// Arrange
var target = new PackagePathResolver(
rootDirectory: InMemoryRootDirectory,
useSideBySidePaths: useSideBySidePaths);
// Act
var actual = target.GetPackageFileName(PackageIdentity);
// Assert
Assert.Equal(expected, actual);
}
/// <summary>
/// Create a packagets.config folder of nupkgs
/// </summary>
public static async Task CreateFolderFeedPackagesConfigAsync(string root, params string[] nupkgPaths)
{
var resolver = new PackagePathResolver(root);
var context = new PackageExtractionContext(NullLogger.Instance);
foreach (var path in nupkgPaths)
{
using (var stream = File.OpenRead(path))
{
await PackageExtractor.ExtractPackageAsync(stream, resolver, context, CancellationToken.None);
}
}
}
public NuGetPackageManager(string packagesDirectory)
{
m_AssemblyLoader = Assembly.Load;
Logger = new NullLogger();
PackagesDirectory = packagesDirectory;
m_Providers = new List <Lazy <INuGetResourceProvider> >();
m_Providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
const string nugetFile = "NuGet.Config";
if (!Directory.Exists(packagesDirectory))
{
Directory.CreateDirectory(packagesDirectory);
}
var nugetConfig = Path.Combine(packagesDirectory, nugetFile);
if (!File.Exists(nugetConfig))
{
var nl = Environment.NewLine;
File.WriteAllText(nugetConfig,
$"<?xml version=\"1.0\" encoding=\"utf-8\"?>{nl}"
+ $"<configuration>{nl}"
+ $" <packageSources>{nl}"
+ $" <add key=\"nuget.org\" value=\"https://api.nuget.org/v3/index.json\" protocolVersion=\"3\" />{nl}"
+ $" </packageSources>{nl}"
+ "</configuration>");
}
m_NugetSettings = Settings.LoadDefaultSettings(packagesDirectory, nugetFile, null);
m_FrameworkReducer = new FrameworkReducer();
var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
m_CurrentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
m_PackagePathResolver = new PackagePathResolver(packagesDirectory);
m_PackageResolver = new PackageResolver();
m_LoadedPackageAssemblies = new Dictionary <string, List <NuGetAssembly> >();
m_ResolveCache = new Dictionary <string, Assembly>();
m_IgnoredDependendencies = new HashSet <string>();
InstallAssemblyResolver();
}
/// <summary>
/// Initializes a new <see cref="FolderNuGetProject" /> class.
/// </summary>
/// <param name="root">The folder project root path.</param>
/// <param name="packagePathResolver">A package path resolver.</param>
/// <param name="targetFramework">Project target framework.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="root" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packagePathResolver" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="targetFramework" /> is <c>null</c>.</exception>
public FolderNuGetProject(string root, PackagePathResolver packagePathResolver, NuGetFramework targetFramework)
{
if (targetFramework == null)
{
throw new ArgumentNullException(nameof(targetFramework));
}
Root = root ?? throw new ArgumentNullException(nameof(root));
PackagePathResolver = packagePathResolver ?? throw new ArgumentNullException(nameof(packagePathResolver));
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, root);
InternalMetadata.Add(NuGetProjectMetadataKeys.TargetFramework, targetFramework);
_framework = targetFramework;
}
public ProjectConverter(ProjectConverterSettings converterSettings, ISettings nugetSettings)
{
_converterSettings = converterSettings ?? throw new ArgumentNullException(nameof(converterSettings));
_nugetSettings = nugetSettings ?? throw new ArgumentNullException(nameof(nugetSettings));
_repositoryPath = Path.GetFullPath(SettingsUtility.GetRepositoryPath(_nugetSettings)).Trim(Path.DirectorySeparatorChar);
_globalPackagesFolder = Path.GetFullPath(SettingsUtility.GetGlobalPackagesFolder(_nugetSettings)).Trim(Path.DirectorySeparatorChar);
PackagePathResolver = new PackagePathResolver(_repositoryPath);
VersionFolderPathResolver = new VersionFolderPathResolver(_globalPackagesFolder);
}
public NugetPackageInstaller(FileIO io)
{
var nugetSettings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(nugetSettings), Repository.Provider.GetCoreV3());
this.io = io;
this.nugetFramework = NuGetFramework.ParseFolder("netstandard2.0");
this.repositories = sourceRepositoryProvider.GetRepositories().ToList();
this.nugetCache = new SourceCacheContext();
this.packagePathResolver = new PackagePathResolver(io.GetFullFileSystemPath("packages"));
this.globalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(nugetSettings);
this.frameworkReducer = new FrameworkReducer();
this.clientPolicy = ClientPolicyContext.GetClientPolicy(nugetSettings, NuGet.Common.NullLogger.Instance);
}
/// <summary>
/// Initializes a new <see cref="FolderNuGetProject" /> class.
/// </summary>
/// <param name="root">The folder project root path.</param>
/// <param name="packagePathResolver">A package path resolver.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="root" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packagePathResolver" />
/// is <c>null</c>.</exception>
public FolderNuGetProject(string root, PackagePathResolver packagePathResolver)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
Initialize(root, packagePathResolver);
}
public static async Task InstallWithDependencies(string packageId, string version, string frameworkVersion, ILogger logger)
{
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var settings = Settings.LoadDefaultSettings(root: null);
var feed = new Uri("https://api.nuget.org/v3/index.json");
var repositoryList = new List <SourceRepository>();
repositoryList.Add(Repository.Factory.GetCoreV3(feed.AbsoluteUri, FeedType.HttpV3));
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositoryList, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
logger);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, logger),
logger);
//new PackageSignatureVerifier(
// signatureVerification.GetSignatureVerificationProviders()),
//SignedPackageVerifierSettings.GetDefault());
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
InstallPackages(packagePathResolver, packageToInstall, cacheContext, packageExtractionContext,
frameworkReducer, nuGetFramework, settings, logger);
}
}
}
public void GetInstalledPackageFilePath_ReturnsInstalledPackageFilePath(bool useSideBySidePaths, string expectedFileName)
{
using (var testDirectory = TestDirectory.Create())
{
var expectedFilePath = Path.Combine(testDirectory.Path, expectedFileName);
File.WriteAllText(expectedFilePath, string.Empty);
var target = new PackagePathResolver(testDirectory.Path, useSideBySidePaths);
var actualFilePath = target.GetInstalledPackageFilePath(PackageIdentity);
Assert.Equal(expectedFilePath, actualFilePath);
}
}
public void GetInstallPath_ReturnsInstallPath(bool useSideBySidePaths, string expected)
{
// Arrange
var target = new PackagePathResolver(
rootDirectory: InMemoryRootDirectory,
useSideBySidePaths: useSideBySidePaths);
expected = Path.Combine(InMemoryRootDirectory, expected);
// Act
var actual = target.GetInstallPath(PackageIdentity);
// Assert
Assert.Equal(expected, actual);
}
public NugetFolderProject(
IFileSystem fileSystem,
INuGetContentResolver contentResolver,
ICakeConfiguration config,
ICakeLog log,
PackagePathResolver pathResolver,
string root) : base(root, pathResolver)
{
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
_contentResolver = contentResolver ?? throw new ArgumentNullException(nameof(contentResolver));
_config = config ?? throw new ArgumentNullException(nameof(config));
_log = log ?? throw new ArgumentNullException(nameof(log));
_pathResolver = pathResolver ?? throw new ArgumentNullException(nameof(pathResolver));
_installedPackages = new HashSet <PackageIdentity>();
}
public void GetInstalledPackageFilePath_ThrowsForNullVersion()
{
using (var testDirectory = TestDirectory.Create())
{
var target = new PackagePathResolver(testDirectory.Path);
PackageIdentity nullVersionPackageIdentity = new PackageIdentity("PackageA", null);
// Act
var exception = Assert.Throws <ArgumentException>(paramName: "packageIdentity",
() => target.GetInstalledPackageFilePath(nullVersionPackageIdentity));
Assert.Contains("'Version' cannot be null.", exception.Message);
}
}
private void InitNuGet()
{
_nugetSettings = Settings.LoadDefaultSettings(root: null);
_nugetSourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings, Repository.Provider.GetCoreV3());
_nuGetFramework = NuGetFramework.ParseFolder("netstandard2.0");
_packagesDirectory = _fileSystemManager.BuildFilePath(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_fileSystemManager.CreateDirectory(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_packagePathResolver = new PackagePathResolver(_packagesDirectory);
_packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, NullLogger.Instance), NullLogger.Instance);
}
public async Task DeletePackage_DeletesPackage()
{
// Arrange
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyContentPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
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 = GetDownloadResourceResult(packageFileInfo))
{
// 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));
}
}
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);
}
private async Task PushPackageToFileSystem(Uri sourceUri,
string pathToPackage,
bool skipDuplicate,
ILogger log,
CancellationToken token)
{
var root = sourceUri.LocalPath;
PackageIdentity packageIdentity = null;
using (var reader = new PackageArchiveReader(pathToPackage))
{
packageIdentity = reader.GetIdentity();
}
if (IsV2LocalRepository(root))
{
var pathResolver = new PackagePathResolver(sourceUri.AbsolutePath, useSideBySidePaths: true);
var packageFileName = pathResolver.GetPackageFileName(packageIdentity);
var fullPath = Path.Combine(root, packageFileName);
File.Copy(pathToPackage, fullPath, overwrite: true);
//Indicate that SkipDuplicate is currently not supported in this scenario.
if (skipDuplicate)
{
log?.LogWarning(Strings.PushCommandSkipDuplicateNotImplemented);
}
}
else
{
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings, log),
log);
var context = new OfflineFeedAddContext(pathToPackage,
root,
log,
throwIfSourcePackageIsInvalid: true,
throwIfPackageExistsAndInvalid: !skipDuplicate,
throwIfPackageExists: !skipDuplicate,
extractionContext: packageExtractionContext);
await OfflineFeedUtility.AddPackageToSource(context, token);
}
}
/// <summary>
/// Create a packagets.config folder of nupkgs
/// </summary>
public static async Task CreateFolderFeedPackagesConfigAsync(string root, params string[] nupkgPaths)
{
var resolver = new PackagePathResolver(root);
var context = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
NullLogger.Instance,
signedPackageVerifier: null);
foreach (var path in nupkgPaths)
{
using (var stream = File.OpenRead(path))
{
await PackageExtractor.ExtractPackageAsync(stream, resolver, context, CancellationToken.None);
}
}
}
public static async Task InstallPackages(PackagePathResolver packagePathResolver, SourcePackageDependencyInfo packageToInstall, SourceCacheContext cacheContext,
PackageExtractionContext packageExtractionContext, FrameworkReducer frameworkReducer, NuGetFramework nuGetFramework, ISettings settings, ILogger logger)
{
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),
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);
}
var libItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(nuGetFramework,
frameworkItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
}
internal FolderNuGetProjectTest(bool useSideBySidePaths = true)
{
PackageIdentity = new PackageIdentity(id: "a", version: NuGetVersion.Parse("1.0.0"));
TestDirectory = TestDirectory.Create();
ProjectDirectory = Directory.CreateDirectory(Path.Combine(TestDirectory.Path, "project"));
Resolver = new PackagePathResolver(ProjectDirectory.FullName, useSideBySidePaths);
Project = new FolderNuGetProject(ProjectDirectory.FullName, Resolver);
var sourcePackageDirectoryPath = Path.Combine(TestDirectory.Path, "source");
Directory.CreateDirectory(sourcePackageDirectoryPath);
Package = TestPackagesGroupedByFolder.GetLegacyTestPackage(
sourcePackageDirectoryPath,
PackageIdentity.Id,
PackageIdentity.Version.ToNormalizedString());
}
public NuGetFolderProject(
IFileSystem fileSystem,
INuGetContentResolver contentResolver,
ICakeLog log,
PackagePathResolver pathResolver,
string root,
NuGetFramework targetFramework) : base(root, pathResolver)
{
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
_contentResolver = contentResolver ?? throw new ArgumentNullException(nameof(contentResolver));
_log = log ?? throw new ArgumentNullException(nameof(log));
_pathResolver = pathResolver ?? throw new ArgumentNullException(nameof(pathResolver));
_installedPackages = new HashSet <PackageIdentity>();
TargetFramework = targetFramework ?? throw new ArgumentNullException(nameof(targetFramework));
InternalMetadata[NuGetProjectMetadataKeys.TargetFramework] = TargetFramework;
}
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
var targetFramework = type == PackageType.Addin ? _currentFramework : NuGetFramework.AnyFramework;
var sourceRepositoryProvider = new NuGetSourceRepositoryProvider(_nugetSettings, _config, package);
var packageIdentity = GetPackageId(package, sourceRepositoryProvider, targetFramework, _nugetLogger);
if (packageIdentity == null)
{
return(Array.Empty <IFile>());
}
var packageRoot = path.MakeAbsolute(_environment).FullPath;
var pathResolver = new PackagePathResolver(packageRoot);
var nuGetProject = new NugetFolderProject(_fileSystem, _contentResolver, _config, _log, pathResolver, packageRoot, targetFramework);
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, _nugetSettings, packageRoot)
{
PackagesFolderNuGetProject = nuGetProject
};
var sourceRepositories = sourceRepositoryProvider.GetRepositories();
var includePrerelease = false;
if (package.Parameters.ContainsKey("prerelease"))
{
bool.TryParse(package.Parameters["prerelease"].FirstOrDefault() ?? bool.TrueString, out includePrerelease);
}
var resolutionContext = new ResolutionContext(DependencyBehavior.Lowest, includePrerelease, false, VersionConstraints.None);
var projectContext = new NuGetProjectContext(_log);
packageManager.InstallPackageAsync(nuGetProject, packageIdentity, resolutionContext, projectContext,
sourceRepositories, Array.Empty <SourceRepository>(),
CancellationToken.None).Wait();
return(nuGetProject.GetFiles(path, package, type));
}
public async Task GetInstalledPath_ReturnsInstalledPath()
{
// Arrange
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
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 = GetDownloadResourceResult(packageFileInfo))
{
// 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);
}
// Main Act
var installedPath = folderNuGetProject.GetInstalledPath(
new PackageIdentity(
packageIdentity.Id,
new NuGetVersion(packageIdentity.Version + ".0")));
// Assert
Assert.NotNull(installedPath);
Assert.True(Directory.Exists(installedPath));
Assert.True(string.Equals(packageInstallPath, installedPath));
}
}
