public static async Task ExecuteInitPs1ScriptsAsync(
BuildIntegratedNuGetProject project,
IEnumerable <PackageIdentity> packages,
FallbackPackagePathResolver pathResolver,
INuGetProjectContext projectContext)
{
// Find all dependencies in sorted order
var sortedPackages = await BuildIntegratedProjectUtility.GetOrderedProjectPackageDependencies(project);
// Keep track of the packages that need to be executed.
var packagesToExecute = new HashSet <PackageIdentity>(packages, PackageIdentity.Comparer);
// Use the ordered packages to run init.ps1 for the specified packages.
foreach (var package in sortedPackages)
{
if (packagesToExecute.Remove(package))
{
var packageInstallPath = pathResolver.GetPackageDirectory(package.Id, package.Version);
if (packageInstallPath == null)
{
continue;
}
await project.ExecuteInitScriptAsync(
package,
packageInstallPath,
projectContext,
throwOnFailure : false);
}
}
}
/// <summary>
/// Initialize a new instance of <see cref="NugetStore"/>.
/// </summary>
/// <param name="oldRootDirectory">The location of the Nuget store.</param>
public NugetStore(string oldRootDirectory)
{
// Used only for versions before 3.0
this.oldRootDirectory = oldRootDirectory;
settings = NuGet.Configuration.Settings.LoadDefaultSettings(null);
// Add dev source
CheckPackageSource("Xenko", DefaultPackageSource);
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext.UserPackageFolder, oldRootDirectory != null ? pathContext.FallbackPackageFolders.Concat(new[] { oldRootDirectory }) : pathContext.FallbackPackageFolders);
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);
}
public void FallbackPackagePathResolver_MissingPackageWithFallbacks()
{
// Arrange
using (var mockBaseDirectory = TestDirectory.Create())
{
var userFolder = Path.Combine(mockBaseDirectory, "global");
var fallbackFolders = new List <string>()
{
Path.Combine(mockBaseDirectory, "fallback1"),
Path.Combine(mockBaseDirectory, "fallback2"),
};
Directory.CreateDirectory(userFolder);
foreach (var fallback in fallbackFolders)
{
Directory.CreateDirectory(fallback);
}
var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders);
// Act
var path = resolver.GetPackageDirectory("a", "1.0.0");
// Assert
Assert.Null(path);
}
}
public ScriptDependencyContext ReadDependencyContext(string pathToAssetsFile)
{
var lockFile = GetLockFile(pathToAssetsFile);
// Since we execute "dotnet restore -r [rid]" we get two targets in the lock file.
// The second target is the one containing the runtime deps for the given RID.
var target = GetLockFileTarget(lockFile);
var targetLibraries = target.Libraries;
var packageFolders = lockFile.PackageFolders.Select(lfi => lfi.Path).ToArray();
var userPackageFolder = packageFolders.First();
var fallbackFolders = packageFolders.Skip(1);
var packagePathResolver = new FallbackPackagePathResolver(userPackageFolder, fallbackFolders);
List <ScriptDependency> scriptDependencies = new List <ScriptDependency>();
foreach (var targetLibrary in targetLibraries)
{
var scriptDependency = CreateScriptDependency(targetLibrary.Name, targetLibrary.Version.ToString(), packageFolders, packagePathResolver, targetLibrary);
if (scriptDependency.CompileTimeDependencyPaths.Any() ||
scriptDependency.NativeAssetPaths.Any() ||
scriptDependency.RuntimeDependencyPaths.Any() ||
scriptDependency.ScriptPaths.Any())
{
scriptDependencies.Add(scriptDependency);
}
}
return(new ScriptDependencyContext(scriptDependencies.ToArray()));
}
public static void UpdatePackageReferenceMetadata(
PackageSpec packageSpec,
FallbackPackagePathResolver pathResolver,
PackageIdentity package)
{
var info = pathResolver.GetPackageInfo(package.Id, package.Version);
var nuspecFilePath = info?.PathResolver.GetManifestFilePath(package.Id, package.Version);
var nuspecReader = new NuspecReader(nuspecFilePath);
var developmentDependency = nuspecReader.GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in packageSpec.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(dep => dep.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase));
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Runtime;
}
}
}
}
/// <summary>
/// Attempts to find a NuGet package if it is already installed.
/// </summary>
private static bool TryGetMSBuildSdkPackageInfo(FallbackPackagePathResolver fallbackPackagePathResolver, string id, NuGetVersion version, out string installedPath, out string installedVersion)
{
// Find the package
var packageInfo = fallbackPackagePathResolver.GetPackageInfo(id, version);
if (packageInfo == null)
{
installedPath = null;
installedVersion = null;
return(false);
}
// Get the installed path and add the expected "Sdk" folder. Windows file systems are not case sensitive
installedPath = Path.Combine(packageInfo.PathResolver.GetInstallPath(packageInfo.Id, packageInfo.Version), "Sdk");
if (!NuGet.Common.RuntimeEnvironmentHelper.IsWindows && !Directory.Exists(installedPath))
{
// Fall back to lower case "sdk" folder in case the file system is case sensitive
installedPath = Path.Combine(packageInfo.PathResolver.GetInstallPath(packageInfo.Id, packageInfo.Version), "sdk");
}
installedVersion = packageInfo.Version.ToString();
return(true);
}
private async Task <IVsPathContext> GetPathContextFromAssetsFileAsync(
NuGetProject nuGetProject, CancellationToken token)
{
// It's possible that this project isn't a build integrated NuGet project at all. That is, this project may
// be a packages.config project.
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
if (buildIntegratedProject == null)
{
return(null);
}
// It's possible the lock file doesn't exist or it's an older format that doesn't have the package folders
// property persisted.
var lockFile = await _getLockFileOrNullAsync(buildIntegratedProject);
if (lockFile == null ||
lockFile.PackageFolders == null ||
lockFile.PackageFolders.Count == 0)
{
return(null);
}
// The user packages folder is always the first package folder. Subsequent package folders are always
// fallback package folders.
var packageFolders = lockFile
.PackageFolders
.Select(lockFileItem => lockFileItem.Path)
.ToList();
var userPackageFolder = packageFolders[0];
var fallbackPackageFolders = packageFolders.Skip(1);
if (lockFile.Libraries == null ||
lockFile.Libraries.Count == 0)
{
return(new VsPathContext(userPackageFolder, fallbackPackageFolders));
}
var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
var trie = new PathLookupTrie <string>();
foreach (var pid in lockFile
.Libraries
.Where(l => l.Type == LibraryType.Package)
.Select(l => new PackageIdentity(l.Name, l.Version)))
{
var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version);
if (packageInstallPath != null)
{
trie[packageInstallPath] = packageInstallPath;
}
}
return(new VsIndexedPathContext(
userPackageFolder,
fallbackPackageFolders,
trie));
}
/// <summary>
/// Initialize a new instance of <see cref="NugetStore"/>.
/// </summary>
/// <param name="oldRootDirectory">The location of the Nuget store.</param>
public NugetStore(string oldRootDirectory)
{
// Used only for versions before 3.0
this.oldRootDirectory = oldRootDirectory;
settings = NuGet.Configuration.Settings.LoadDefaultSettings(null);
// Remove obsolete sources
RemoveDeletedSources(settings, "Xenko Dev");
// Note the space: we want to keep "Stride Dev" but not "Stride Dev {PATH}\bin\packages" anymore
RemoveSources(settings, "Stride Dev ");
settings.SaveToDisk();
InstallPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var pathContext = NuGetPathContext.Create(settings);
InstalledPathResolver = new FallbackPackagePathResolver(pathContext.UserPackageFolder, oldRootDirectory != null ? pathContext.FallbackPackageFolders.Concat(new[] { oldRootDirectory }) : pathContext.FallbackPackageFolders);
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);
}
private string GetCommandFilePath(
IEnumerable <string> packageFolders,
LockFileTargetLibrary toolLibrary,
LockFileItem runtimeAssembly)
{
var packageFoldersCount = packageFolders.Count();
var userPackageFolder = packageFoldersCount == 1 ? string.Empty : packageFolders.First();
var fallbackPackageFolders = packageFoldersCount > 1 ? packageFolders.Skip(1) : packageFolders;
var packageDirectory = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders)
.GetPackageDirectory(toolLibrary.Name, toolLibrary.Version);
if (packageDirectory == null)
{
throw new GracefulException(string.Format(
LocalizableStrings.CommandAssembliesNotFound,
toolLibrary.Name));
}
var filePath = Path.Combine(
packageDirectory,
PathUtility.GetPathWithDirectorySeparator(runtimeAssembly.Path));
return(filePath);
}
private string GetPackageInstalledPath(PackageIdentity packageIdentity)
{
var nugetPaths = NuGetPathContext.Create(Settings);
var fallbackResolver = new FallbackPackagePathResolver(nugetPaths);
// Verify the package exists and return the path. Return null otherwise.
return(fallbackResolver.GetPackageDirectory(packageIdentity.Id, packageIdentity.Version));
}
private async Task <IVsPathContext> GetPathContextFromAssetsFileAsync(
NuGetProject nuGetProject, CancellationToken token)
{
// It's possible that this project isn't a build integrated NuGet project at all. That is, this project may
// be a packages.config project.
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
if (buildIntegratedProject == null)
{
return(null);
}
var lockFile = await _getLockFileOrNullAsync(buildIntegratedProject);
if ((lockFile?.PackageFolders?.Count ?? 0) == 0)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_LockFileError));
}
// The user packages folder is always the first package folder. Subsequent package folders are always
// fallback package folders.
var packageFolders = lockFile
.PackageFolders
.Select(lockFileItem => lockFileItem.Path)
.ToList();
var userPackageFolder = packageFolders[0];
var fallbackPackageFolders = packageFolders.Skip(1);
if (lockFile.Libraries == null ||
lockFile.Libraries.Count == 0)
{
return(new VsPathContext(userPackageFolder, fallbackPackageFolders));
}
var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
var trie = new PathLookupTrie <string>();
foreach (var pid in lockFile
.Libraries
.Where(l => l.Type == LibraryType.Package)
.Select(l => new PackageIdentity(l.Name, l.Version)))
{
var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version);
if (string.IsNullOrEmpty(packageInstallPath))
{
throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid));
}
trie[packageInstallPath] = packageInstallPath;
}
return(new VsIndexedPathContext(
userPackageFolder,
fallbackPackageFolders,
trie));
}
public IEnumerable <IVsPackageMetadata> GetInstalledPackages()
{
var packages = new HashSet <IVsPackageMetadata>(new VsPackageMetadataComparer());
return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
// Calls may occur in the template wizard before the solution is actually created,
// in that case return no projects
if (_solutionManager != null &&
!string.IsNullOrEmpty(_solutionManager.SolutionDirectory))
{
InitializePackageManagerAndPackageFolderPath();
foreach (var project in (await _solutionManager.GetNuGetProjectsAsync()))
{
FallbackPackagePathResolver pathResolver = null;
var buildIntegratedProject = project as BuildIntegratedNuGetProject;
if (buildIntegratedProject != null)
{
pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject);
}
var installedPackages = await project.GetInstalledPackagesAsync(CancellationToken.None);
foreach (var package in installedPackages)
{
var identity = package.PackageIdentity;
if (!identity.HasVersion)
{
// Currently we are not supporting floating versions
// because of that we will skip this package
continue;
}
// find packages using the solution level packages folder
string installPath;
if (buildIntegratedProject != null)
{
installPath = pathResolver.GetPackageDirectory(identity.Id, identity.Version);
}
else
{
installPath = _packageManager
.PackagesFolderNuGetProject
.GetInstalledPath(identity);
}
var metadata = new VsPackageMetadata(package.PackageIdentity, installPath);
packages.Add(metadata);
}
}
}
return packages;
}));
}
private ScriptDependency CreateScriptDependency(string name, string version, FallbackPackagePathResolver packagePathResolver, LockFileTargetLibrary targetLibrary)
{
var runtimeDependencyPaths = GetRuntimeDependencyPaths(packagePathResolver, targetLibrary);
var compileTimeDependencyPaths = GetCompileTimeDependencyPaths(packagePathResolver, targetLibrary);
var nativeAssetPaths = GetNativeAssetPaths(packagePathResolver, targetLibrary);
var scriptPaths = GetScriptPaths(packagePathResolver, targetLibrary);
return(new ScriptDependency(name, version, runtimeDependencyPaths, nativeAssetPaths, compileTimeDependencyPaths.ToArray(), scriptPaths));
}
public async Task FallbackPackagePathResolver_FindPackageInFallbackFolder2SkipMissingHashes()
{
// Arrange
using (var mockBaseDirectory = TestDirectory.Create())
{
var userFolder = Path.Combine(mockBaseDirectory, "global");
var fallbackFolders = new List <string>()
{
Path.Combine(mockBaseDirectory, "fallback1"),
Path.Combine(mockBaseDirectory, "fallback2"),
};
Directory.CreateDirectory(userFolder);
foreach (var fallback in fallbackFolders)
{
Directory.CreateDirectory(fallback);
}
var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg;
var targetFolder = fallbackFolders[1];
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
userFolder,
saveMode,
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
fallbackFolders[0],
saveMode,
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
fallbackFolders[1],
saveMode,
new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
// Remove hashes from the first two folders
foreach (var root in new[] { userFolder, fallbackFolders[0] })
{
var localResolver = new VersionFolderPathResolver(root);
File.Delete(localResolver.GetHashPath("a", NuGetVersion.Parse("1.0.0")));
}
var expected = Path.Combine(targetFolder, "a", "1.0.0");
var resolver = new FallbackPackagePathResolver(userFolder, fallbackFolders);
// Act
var path = resolver.GetPackageDirectory("a", "1.0.0");
// Assert
Assert.Equal(expected, path);
}
}
/// <summary>
/// No solution manager provided so only global packages cache will be considered.
/// </summary>
public PackageManagementPathResolver()
{
var settings = SettingsLoader.LoadDefaultSettings();
var pathContext = NuGetPathContext.Create(settings);
pathResolver = new FallbackPackagePathResolver(pathContext);
globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
folderNuGetProject = new FolderNuGetProject(pathContext.UserPackageFolder);
}
async Task CollectPackagesForBuildIntegratedProjectAsync(
BuildIntegratedNuGetProject project,
ISet <PackageIdentity> finishedPackages,
IList <PackageItem> installedPackages,
CancellationToken token)
{
token.ThrowIfCancellationRequested();
var lockFile = await getLockFileOrNullAsync(project);
if (lockFile == null)
{
return;
}
if (lockFile.Libraries == null ||
lockFile.Libraries.Count == 0)
{
return;
}
FallbackPackagePathResolver fppr;
if ((lockFile?.PackageFolders?.Count ?? 0) != 0)
{
// The user packages folder is always the first package folder. Subsequent package folders are always
// fallback package folders.
var packageFolders = lockFile
.PackageFolders
.Select(lockFileItem => lockFileItem.Path);
var userPackageFolder = packageFolders.First();
var fallbackPackageFolders = packageFolders.Skip(1);
fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
}
else
{
var pathContext = NuGetPathContext.Create(settings);
fppr = new FallbackPackagePathResolver(pathContext);
}
foreach (var package in BuildIntegratedProjectUtility.GetOrderedLockFilePackageDependencies(lockFile))
{
if (!finishedPackages.Contains(package))
{
var installPath = fppr.GetPackageDirectory(package.Id, package.Version);
if (!string.IsNullOrEmpty(installPath))
{
installedPackages.Add(new PackageItem(package, installPath));
finishedPackages.Add(package);
}
}
}
}
public async Task RunToolWithCreateConfigVerifySuccess()
{
using (var testContext = new SleetTestContext())
{
var dir = Path.Combine(testContext.Root, "project");
Directory.CreateDirectory(dir);
var dotnetExe = GetDotnetPath();
var exeFile = new FileInfo(dotnetExe);
var nupkgsFolder = Path.Combine(exeFile.Directory.Parent.FullName, "artifacts", "nupkgs");
var sleetNupkg = LocalFolderUtility.GetPackagesV2(nupkgsFolder, "Sleet", NullLogger.Instance)
.OrderByDescending(e => e.Nuspec.GetVersion())
.First();
var sleetVersion = sleetNupkg.Nuspec.GetVersion().ToNormalizedString();
var result = await CmdRunner.RunAsync(dotnetExe, dir, "new classlib");
result.Success.Should().BeTrue();
var projectPath = Path.Combine(dir, "project.csproj");
var pathContext = NuGetPathContext.Create(dir);
var pathResolver = new FallbackPackagePathResolver(pathContext);
// Delete restore assets file
var toolInstallPath = Path.Combine(pathContext.UserPackageFolder, ".tools", "sleet");
Delete(new DirectoryInfo(toolInstallPath));
// Delete the tool package itself if it exists
var toolPackagePath = Path.Combine(pathContext.UserPackageFolder, "sleet", sleetVersion);
Delete(new DirectoryInfo(toolPackagePath));
// Add a reference to the tool
var xml = XDocument.Load(projectPath);
xml.Root.Add(new XElement(XName.Get("ItemGroup"),
new XElement(XName.Get("DotNetCliToolReference"),
new XAttribute("Include", "Sleet"),
new XAttribute("Version", sleetVersion))));
xml.Save(projectPath);
// Restore the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"restore --source {nupkgsFolder}");
result.Success.Should().BeTrue();
// Run the tool
result = await CmdRunner.RunAsync(dotnetExe, dir, $"sleet createconfig");
result.Success.Should().BeTrue();
File.Exists(Path.Combine(dir, "sleet.json")).Should().BeTrue();
}
}
public PackageManagementPathResolver(IMonoDevelopSolutionManager solutionManager)
{
var pathContext = NuGetPathContext.Create(solutionManager.Settings);
pathResolver = new FallbackPackagePathResolver(pathContext);
globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
string packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings);
folderNuGetProject = new FolderNuGetProject(packagesFolderPath);
}
private static string[] GetCompileTimeDependencyPaths(FallbackPackagePathResolver packagePathResolver, LockFileTargetLibrary targetLibrary)
{
var compileTimeDependencyPaths = new List <string>();
foreach (var lockFileItem in targetLibrary.CompileTimeAssemblies.Where(cta => !cta.Path.EndsWith("_._")))
{
var fullPath = ResolveFullPath(packagePathResolver, targetLibrary.Name, targetLibrary.Version.ToString(), lockFileItem.Path);
compileTimeDependencyPaths.Add(fullPath);
}
return(compileTimeDependencyPaths.ToArray());
}
private string[] GetNativeAssetPaths(FallbackPackagePathResolver packagePathResolver, LockFileTargetLibrary targetLibrary)
{
List <string> nativeAssetPaths = new List <string>();
foreach (var runtimeTarget in targetLibrary.NativeLibraries.Where(lfi => !lfi.Path.EndsWith("_._")))
{
var fullPath = ResolveFullPath(packagePathResolver, targetLibrary.Name, targetLibrary.Version.ToString(), runtimeTarget.Path);
nativeAssetPaths.Add(fullPath);
}
return(nativeAssetPaths.ToArray());
}
public PackageDependencyProvider(INuGetPathContext nugetPathContext, FrameworkReferenceResolver frameworkReferenceResolver)
{
if (nugetPathContext != null)
{
_packagePathResolver = new FallbackPackagePathResolver(nugetPathContext);
// This resolver is only used for building file names, so that base path is not required.
_versionFolderPathResolver = new VersionFolderPathResolver(path: null);
}
_frameworkReferenceResolver = frameworkReferenceResolver;
}
private async Task <IVsPathContext> GetPathContextFromProjectLockFileAsync(
string lockFilePath, CancellationToken token)
{
var lockFile = _getLockFileOrNull(lockFilePath);
if ((lockFile?.PackageFolders?.Count ?? 0) == 0)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_LockFileError));
}
// switch to a background thread to process packages data
await TaskScheduler.Default;
// The user packages folder is always the first package folder. Subsequent package folders are always
// fallback package folders.
var packageFolders = lockFile
.PackageFolders
.Select(lockFileItem => lockFileItem.Path)
.ToList();
var userPackageFolder = packageFolders[0];
var fallbackPackageFolders = packageFolders.Skip(1);
if (lockFile.Libraries == null ||
lockFile.Libraries.Count == 0)
{
return(new VsPathContext(userPackageFolder, fallbackPackageFolders));
}
var fppr = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
var trie = new PathLookupTrie <string>();
foreach (var pid in lockFile
.Libraries
.Where(l => l.Type == LibraryType.Package)
.Select(l => new PackageIdentity(l.Name, l.Version)))
{
var packageInstallPath = fppr.GetPackageDirectory(pid.Id, pid.Version);
if (string.IsNullOrEmpty(packageInstallPath))
{
throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid));
}
trie[packageInstallPath] = packageInstallPath;
}
return(new VsIndexedPathContext(
userPackageFolder,
fallbackPackageFolders,
trie));
}
/// <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 static string GetPackageDirectory(this LockFile lockFile, LockFileTargetLibrary library)
{
var packageFolders = lockFile.GetNormalizedPackageFolders();
var packageFoldersCount = packageFolders.Count();
var userPackageFolder = packageFoldersCount == 1 ? string.Empty : packageFolders.First();
var fallbackPackageFolders = packageFoldersCount > 1 ? packageFolders.Skip(1) : packageFolders;
var packageDirectory = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders)
.GetPackageDirectory(library.Name, library.Version);
return(packageDirectory);
}
private static string ResolvePackageFullPath(FallbackPackagePathResolver packagePathResolver, string name, string version)
{
var packageFolder = packagePathResolver.GetPackageDirectory(name, version);
if (packageFolder != null)
{
return(packageFolder);
}
string message = $@"The requested package ({name},{version}) was not found in the global Nuget cache(s).
. Try executing/publishing the script again with the '--no-cache' option";
throw new InvalidOperationException(message);
}
private static string ResolveFullPath(FallbackPackagePathResolver packagePathResolver, string name, string version, string referencePath)
{
var packageFolder = ResolvePackageFullPath(packagePathResolver, name, version);
var fullPath = Path.Combine(packageFolder, referencePath);
if (File.Exists(fullPath))
{
return(fullPath);
}
string message = $@"The requested dependency ({referencePath}) was not found in the global Nuget cache(s).
. Try executing/publishing the script again with the '--no-cache' option";
throw new InvalidOperationException(message);
}
public static void UpdatePackageReferenceMetadata(
LockFile lockFile,
FallbackPackagePathResolver pathResolver,
PackageIdentity package)
{
var info = pathResolver.GetPackageInfo(package.Id, package.Version);
if (info == null)
{
// don't do anything if package was not resolved on disk
return;
}
var nuspecFilePath = info.PathResolver.GetManifestFilePath(package.Id, package.Version);
var nuspecReader = new NuspecReader(nuspecFilePath);
var developmentDependency = nuspecReader.GetDevelopmentDependency();
if (developmentDependency)
{
foreach (var frameworkInfo in lockFile.PackageSpec.TargetFrameworks
.OrderBy(framework => framework.FrameworkName.ToString(),
StringComparer.Ordinal))
{
var dependency = frameworkInfo.Dependencies.First(dep => dep.Name.Equals(package.Id, StringComparison.OrdinalIgnoreCase));
if (dependency?.SuppressParent == LibraryIncludeFlagUtils.DefaultSuppressParent &&
dependency?.IncludeType == LibraryIncludeFlags.All)
{
var includeType = LibraryIncludeFlags.All & ~LibraryIncludeFlags.Compile;
dependency.SuppressParent = LibraryIncludeFlags.All;
dependency.IncludeType = includeType;
// update lock file target libraries
foreach (var target in lockFile.Targets
.Where(t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, frameworkInfo.FrameworkName)))
{
var targetLibrary = target.GetTargetLibrary(package.Id);
if (targetLibrary != null)
{
LockFileUtils.ExcludeItems(targetLibrary, includeType);
}
}
}
}
}
}
private string[] GetScriptPaths(FallbackPackagePathResolver packagePathResolver, LockFileTargetLibrary targetLibrary)
{
if (targetLibrary.ContentFiles.Count == 0)
{
return(Array.Empty <string>());
}
var packageFolder = ResolvePackageFullPath(packagePathResolver, targetLibrary.Name, targetLibrary.Version.ToString());
// Note that we can't use content files directly here since that only works for
// script packages directly referenced by the script and not script packages having
// dependencies to other script packages.
var files = _scriptFilesDependencyResolver.GetScriptFileDependencies(packageFolder);
return(files);
}
public async Task <bool> ExecuteInitScriptAsync(PackageIdentity identity)
{
var result = false;
// Reserve the key. We can remove if the package has not been restored.
if (TryMarkVisited(identity, PackageInitPS1State.NotFound))
{
var nugetPaths = NuGetPathContext.Create(Settings);
var fallbackResolver = new FallbackPackagePathResolver(nugetPaths);
var installPath = fallbackResolver.GetPackageDirectory(identity.Id, identity.Version);
if (!string.IsNullOrEmpty(installPath))
{
var scriptPath = Path.Combine(installPath, "tools", PowerShellScripts.Init);
if (File.Exists(scriptPath))
{
// Init.ps1 is present and will be executed.
InitScriptExecutions.TryUpdate(
identity,
PackageInitPS1State.FoundAndExecuted,
PackageInitPS1State.NotFound);
var request = new ScriptExecutionRequest(scriptPath, installPath, identity, project: null);
await ExecuteScriptCoreAsync(request);
result = true;
}
}
else
{
// Package is not restored. Do not cache the results.
PackageInitPS1State dummy;
InitScriptExecutions.TryRemove(identity, out dummy);
result = false;
}
}
else
{
// Key is already present. Simply access its value
result = (InitScriptExecutions[identity] == PackageInitPS1State.FoundAndExecuted);
}
return(result);
}
private async Task <(InstalledPackageResultStatus, IReadOnlyCollection <NuGetInstalledPackage>)> GetInstalledPackagesAsync(BuildIntegratedNuGetProject project, CancellationToken cancellationToken)
{
NuGetInstalledPackage ToNuGetInstalledPackage(PackageReference packageReference, FallbackPackagePathResolver pathResolver)
{
var id = packageReference.PackageIdentity.Id;
var versionRange = packageReference.AllowedVersions;
string requestedRange =
packageReference.AllowedVersions.OriginalString // most packages
?? packageReference.AllowedVersions.ToShortString();
string version = versionRange.MinVersion.OriginalVersion ?? versionRange.MinVersion.ToNormalizedString();
var installPath = pathResolver.GetPackageDirectory(id, version);
bool directDependency = true;
return(NuGetContractsFactory.CreateNuGetInstalledPackage(id, requestedRange, version, installPath, directDependency));
}
InstalledPackageResultStatus status;
IReadOnlyCollection <NuGetInstalledPackage> installedPackages;
var cacheContext = new DependencyGraphCacheContext();
var(packageSpecs, messages) = await project.GetPackageSpecsAndAdditionalMessagesAsync(cacheContext);
if (messages?.Any(m => m.Level == LogLevel.Error) == true)
{
// Although we know that the project will fail to restore, we may still know about some direct dependencies, so let's return the packages that we know about.
status = InstalledPackageResultStatus.ProjectInvalid;
}
else
{
status = InstalledPackageResultStatus.Successful;
}
var packageSpec = packageSpecs.Single(s => s.RestoreMetadata.ProjectStyle == ProjectModel.ProjectStyle.PackageReference || s.RestoreMetadata.ProjectStyle == ProjectModel.ProjectStyle.ProjectJson);
var packagesPath = VSRestoreSettingsUtilities.GetPackagesPath(_settings, packageSpec);
FallbackPackagePathResolver pathResolver = new FallbackPackagePathResolver(packagesPath, VSRestoreSettingsUtilities.GetFallbackFolders(_settings, packageSpec));
var packageReferences = await project.GetInstalledPackagesAsync(cancellationToken);
installedPackages = packageReferences.Select(p => ToNuGetInstalledPackage(p, pathResolver))
.ToList();
return(status, installedPackages);
}