/// <summary>
/// Installation path of <paramref name="package"/>
/// </summary>
/// <param name="id">Id of package to query.</param>
/// <param name="version">Version of package to query.</param>
/// <returns>The installation path if installed, null otherwise.</returns>
public string GetInstalledPath(string id, PackageVersion version)
{
// Xenko 2.x still installs in GamePackages
if (IsPackageV2(id, version))
{
return(PathResolverV2.GetInstallPath(new PackageIdentity(id, version.ToNuGetVersion())));
}
return(InstalledPathResolver.GetPackageDirectory(id, version.ToNuGetVersion()));
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, IEnumerable <string> targetFrameworks, ProgressReport progress)
{
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var identity = new PackageIdentity(packageId, version.ToNuGetVersion());
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
true,
true,
VersionConstraints.None);
var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray();
var projectContext = new EmptyNuGetProjectContext()
{
ActionType = NuGetActionType.Install,
PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger),
};
ActivityCorrelationId.StartNew();
{
var installPath = SettingsUtility.GetGlobalPackagesFolder(settings);
// In case it's a package without any TFM (i.e. Visual Studio plugin), we still need to specify one
if (!targetFrameworks.Any())
{
targetFrameworks = new string[] { "net6.0" }
}
;
// Old version expects to be installed in GamePackages
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null)
{
installPath = oldRootDirectory;
}
var projectPath = Path.Combine("StrideLauncher.json");
var spec = new PackageSpec()
{
Name = Path.GetFileNameWithoutExtension(projectPath), // make sure this package never collides with a dependency
FilePath = projectPath,
Dependencies = new List <LibraryDependency>()
{
new LibraryDependency
{
LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package),
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.Combine(Path.GetTempPath(), $"StrideLauncher-{packageId}-{version.ToString()}"),
OriginalTargetFrameworks = targetFrameworks.ToList(),
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = installPath,
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
};
foreach (var targetFramework in targetFrameworks)
{
spec.TargetFrameworks.Add(new TargetFrameworkInformation {
FrameworkName = NuGetFramework.Parse(targetFramework)
});
}
using (var context = new SourceCacheContext {
MaxAge = DateTimeOffset.UtcNow
})
{
context.IgnoreFailedSources = true;
var dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(spec);
dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
var restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = context,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)),
Log = NativeLogger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
foreach (var request in requests)
{
// Limit concurrency to avoid timeout
request.Request.MaxDegreeOfConcurrency = 4;
var command = new RestoreCommand(request.Request);
// Act
var result = await command.ExecuteAsync();
if (!result.Success)
{
throw new InvalidOperationException($"Could not restore package {packageId}");
}
foreach (var install in result.RestoreGraphs.Last().Install)
{
var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version);
if (package != null)
{
var packagePath = Path.Combine(installPath, package.Path);
OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath));
}
}
}
}
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0))
{
UpdateTargetsHelper();
}
}
// Load the recently installed package
var installedPackages = GetPackagesInstalled(new[] { packageId });
return(installedPackages.FirstOrDefault(p => p.Version == version));
}
finally
{
currentProgressReport = null;
}
}
}
/// <summary>
/// Installation path of <paramref name="package"/>
/// </summary>
/// <param name="id">Id of package to query.</param>
/// <param name="version">Version of package to query.</param>
/// <returns>The installation path if installed, null otherwise.</returns>
public string GetInstalledPath(string id, PackageVersion version)
{
return(InstalledPathResolver.GetPackageDirectory(id, version.ToNuGetVersion()));
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress)
{
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var identity = new PackageIdentity(packageId, version.ToNuGetVersion());
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
true,
true,
VersionConstraints.None);
var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray();
var projectContext = new EmptyNuGetProjectContext()
{
ActionType = NuGetActionType.Install,
PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.Skip, null, NativeLogger),
};
ActivityCorrelationId.StartNew();
{
var installPath = SettingsUtility.GetGlobalPackagesFolder(settings);
// Old version expects to be installed in GamePackages
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0) && oldRootDirectory != null)
{
installPath = oldRootDirectory;
}
var specPath = Path.Combine("TestProject", "project.json");
var spec = new PackageSpec()
{
Name = "TestProject", // make sure this package never collides with a dependency
FilePath = specPath,
Dependencies = new List <LibraryDependency>()
{
new LibraryDependency
{
LibraryRange = new LibraryRange(packageId, new VersionRange(version.ToNuGetVersion()), LibraryDependencyTarget.Package),
}
},
TargetFrameworks =
{
new TargetFrameworkInformation
{
FrameworkName = NuGetFramework.Parse("net472"),
}
},
};
using (var context = new SourceCacheContext())
{
context.IgnoreFailedSources = true;
var provider = RestoreCommandProviders.Create(installPath, new List <string>(), sourceRepositoryProvider.GetRepositories(), context, new LocalPackageFileCache(), NativeLogger);
var request = new RestoreRequest(spec, provider, context, null, NativeLogger)
{
//RequestedRuntimes = { "win7-d3d11" },
ProjectStyle = ProjectStyle.DotnetCliTool,
};
var command = new RestoreCommand(request);
// Act
var result = await command.ExecuteAsync();
if (!result.Success)
{
throw new InvalidOperationException($"Could not restore package {packageId}");
}
foreach (var install in result.RestoreGraphs.Last().Install)
{
var package = result.LockFile.Libraries.FirstOrDefault(x => x.Name == install.Library.Name && x.Version == install.Library.Version);
if (package != null)
{
var packagePath = Path.Combine(installPath, package.Path);
OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(install.Library.Name, install.Library.Version.ToPackageVersion()), packagePath));
}
}
}
if (packageId == "Xenko" && version < new PackageVersion(3, 0, 0, 0))
{
UpdateTargetsHelper();
}
}
// Load the recently installed package
var installedPackages = GetPackagesInstalled(new[] { packageId });
return(installedPackages.FirstOrDefault(p => p.Version == version));
}
finally
{
currentProgressReport = null;
}
}
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress)
{
// Xenko 2.x still installs in GamePackages
var currentManager = IsPackageV2(packageId, version) ? managerV2 : manager;
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var identity = new PackageIdentity(packageId, version.ToNuGetVersion());
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
true,
true,
VersionConstraints.None);
var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray();
var projectContext = new EmptyNuGetProjectContext()
{
ActionType = NuGetActionType.Install,
PackageExtractionContext = new PackageExtractionContext(NativeLogger),
};
ActivityCorrelationId.StartNew();
{
// Equivalent to:
// await manager.InstallPackageAsync(manager.PackagesFolderNuGetProject,
// identity, resolutionContext, projectContext, repositories,
// Array.Empty<SourceRepository>(), // This is a list of secondary source respositories, probably empty
// CancellationToken.None);
using (var sourceCacheContext = new SourceCacheContext())
{
var nuGetProject = currentManager.PackagesFolderNuGetProject;
var packageIdentity = identity;
var nuGetProjectContext = projectContext;
var primarySources = repositories;
var secondarySources = Array.Empty <SourceRepository>();
var token = CancellationToken.None;
var downloadContext = new PackageDownloadContext(sourceCacheContext);
// Step-1 : Call PreviewInstallPackageAsync to get all the nuGetProjectActions
var nuGetProjectActions = await currentManager.PreviewInstallPackageAsync(nuGetProject, packageIdentity, resolutionContext,
nuGetProjectContext, primarySources, secondarySources, token);
// Notify that installations started.
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion());
OnPackageInstalling(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath));
}
}
NuGetPackageManager.SetDirectInstall(packageIdentity, nuGetProjectContext);
// Step-2 : Execute all the nuGetProjectActions
if (IsPackageV2(packageId, version))
{
await currentManager.ExecuteNuGetProjectActionsAsync(
nuGetProject,
nuGetProjectActions,
nuGetProjectContext,
downloadContext,
token);
}
else
{
// Download and install package in the global cache (can't use NuGetPackageManager anymore since it is designed for V2)
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(primarySources, packageIdentity, downloadContext, InstallPath, NativeLogger, token))
{
if (downloadResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Could not download package {packageIdentity}");
}
using (var installResult = await GlobalPackagesFolderUtility.AddPackageAsync(packageIdentity, downloadResult.PackageStream, InstallPath, NativeLogger, token))
{
if (installResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Could not install package {packageIdentity}");
}
}
}
}
}
}
NuGetPackageManager.ClearDirectInstall(nuGetProjectContext);
// Notify that installations completed.
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion());
OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath));
}
}
}
}
// Load the recently installed package
var installedPackages = GetPackagesInstalled(new[] { packageId });
return(installedPackages.FirstOrDefault(p => p.Version == version));
}
finally
{
currentProgressReport = null;
}
}
}
