private IList <PackageSource> GetSources(ISettings settings)
{
ThreadHelper.ThrowIfNotOnUIThread();
var sources = MSBuildStringUtility.Split(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.RestoreSources)).AsEnumerable();
if (ShouldReadFromSettings(sources))
{
sources = SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
}
else
{
sources = VSRestoreSettingsUtilities.HandleClear(sources);
}
// Add additional sources
sources = sources.Concat(MSBuildStringUtility.Split(GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.RestoreAdditionalProjectSources)));
return(sources.Select(e => new PackageSource(UriUtility.GetAbsolutePathFromFile(ProjectFullPath, e))).ToList());
}
#pragma warning disable CS8618 // Non-nullable field is uninitialized.
public NuGetViewModel()
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
{
try {
var settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = settings.GetConfigFilePaths();
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e) {
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public OneDasPackageManager(IExtensionFactory extensionFactory, IOptions <OneDasOptions> options, ILoggerFactory loggerFactory)
{
JObject jobject;
VersionRange versionRange;
_extensionFactory = extensionFactory;
_options = options.Value;
// settings
_settings = new Settings(_options.NugetDirectoryPath);
_settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>()
{
new SettingValue("NuGet", "https://api.nuget.org/v3/index.json", false)
});
_settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>()
{
new SettingValue("MyGet (CI)", "https://www.myget.org/F/onedas/api/v3/index.json", false)
});
if (!File.Exists(_options.NugetProjectFilePath))
{
jobject = new JObject();
versionRange = new VersionRange(new NuGetVersion("2.0.3"));
JsonConfigUtility.AddFramework(jobject, FrameworkConstants.CommonFrameworks.NetStandard20);
JsonConfigUtility.AddDependency(jobject, new PackageDependency("NETStandard.Library", versionRange));
jobject.Add("runtimes", new JObject(new JProperty(_options.RestoreRuntimeId, new JObject())));
File.WriteAllText(_options.NugetProjectFilePath, jobject.ToString(Formatting.Indented));
}
_project = new OneDasNugetProject(_options.NugetProjectFilePath);
_projectContext = new OneDasNuGetProjectContext(loggerFactory.CreateLogger("Nuget"));
_sourceRepositoryProvider = this.CreateSourceRepositoryProvider();
_packageManager = this.CreateNuGetPackageManager(_sourceRepositoryProvider);
this.PackageSourceSet = SettingsUtility.GetEnabledSources(_settings).ToList();
}
public NugetPackage(ILogger logger, NugetManager manager)
{
_manager = manager;
_logger = logger;
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException)
{
// create default settings using a non-existent config file
settings = new Settings(nameof(NugetPackage));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings);
var sources = SettingsUtility.GetEnabledSources(settings);
_packageSources = _manager.AdditionalSources.Select(p => new PackageSource(p.source, p.name)).Concat(sources).ToList();
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance,
nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3());
_sourceRepositories = _packageSources.Select(s => new SourceRepository(s, providers)).ToList();
}
catch (Exception e)
{
_logger?.LogError(e.Message + e.StackTrace);
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public NuGetViewModel(ITelemetryProvider telemetryProvider)
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
{
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException ex)
{
telemetryProvider.ReportError(ex);
// create default settings using a non-existent config file
settings = new Settings(nameof(RoslynPad));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance, nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
_sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(sourceProvider);
}
catch (Exception e)
{
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public override async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context)
{
PackageSpec packageSpec = null;
if (context == null || !context.PackageSpecCache.TryGetValue(MSBuildProjectPath, out packageSpec))
{
packageSpec = JsonPackageSpecReader.GetPackageSpec(ProjectName, JsonConfigPath);
if (packageSpec == null)
{
throw new InvalidOperationException(
string.Format(Strings.ProjectNotLoaded_RestoreFailed, ProjectName));
}
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.OutputPath = await GetBaseIntermediatePathAsync();
metadata.ProjectPath = MSBuildProjectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = MSBuildProjectPath;
// Reload the target framework from csproj and update the target framework in packageSpec for restore
await UpdateInternalTargetFrameworkAsync();
if (TryGetInternalFramework(out var internalTargetFramework))
{
// Ensure the project json has only one target framework
if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1)
{
var replaceTargetFramework = new TargetFrameworkInformation();
replaceTargetFramework.FrameworkName = internalTargetFramework as NuGetFramework;
packageSpec.TargetFrameworks[0] = replaceTargetFramework;
}
}
var references = (await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(context.Logger, CancellationToken.None))
.ToList();
if (references != null && references.Count > 0)
{
// Add msbuild reference groups for each TFM in the project
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
foreach (var reference in references)
{
// This reference applies to all frameworks
// Include/exclude flags may be applied later when merged with project.json
// Add the reference for all TFM groups, there are no conditional project
// references in UWP. There should also be just one TFM.
foreach (var frameworkInfo in metadata.TargetFrameworks)
{
frameworkInfo.ProjectReferences.Add(reference);
}
}
}
// Write restore settings to the package spec.
// For project.json these properties may not come from the project file.
var settings = context?.Settings ?? NullSettings.Instance;
packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList();
packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList();
packageSpec.RestoreMetadata.ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).AsList();
context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec);
}
return(new[] { packageSpec });
}
public async Task GetPackageSpecsAsync_ReadSettingsWithFullPaths(string restorePackagesPath, string sources, string fallbackFolders)
{
// Arrange
using (var testDirectory = TestDirectory.Create())
{
var projectAdapter = CreateProjectAdapter(testDirectory);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestorePackagesPath)
.Returns(restorePackagesPath);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestoreSources)
.Returns(sources);
Mock.Get(projectAdapter)
.SetupGet(x => x.RestoreFallbackFolders)
.Returns(fallbackFolders);
var projectServices = new TestProjectSystemServices();
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
var settings = NullSettings.Instance;
var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
// Act
var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext);
// Assert
Assert.NotNull(packageSpecs);
var actualRestoreSpec = packageSpecs.Single();
SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec);
// Assert packagespath
Assert.Equal(restorePackagesPath != null ? restorePackagesPath : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath);
// assert sources
var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source);
var expectedSources = sources != null?MSBuildStringUtility.Split(sources) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t)));
// assert fallbackfolders
var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders;
var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders) : SettingsUtility.GetFallbackPackageFolders(settings);
Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t)));
// Verify
Mock.Get(projectAdapter)
.Verify(x => x.RestorePackagesPath, Times.Once);
Mock.Get(projectAdapter)
.Verify(x => x.RestoreSources, Times.Once);
Mock.Get(projectAdapter)
.Verify(x => x.RestoreFallbackFolders, Times.Once);
}
}
/// <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;
}
}
}
public static async Task <(RestoreRequest, RestoreResult)> Restore(ILogger logger, string packageName, VersionRange versionRange)
{
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(null);
var packageSourceProvider = new PackageSourceProvider(settings);
var installPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var assemblies = new List <string>();
var projectPath = Path.Combine("XenkoNugetResolver.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(packageName, versionRange, LibraryDependencyTarget.Package),
}
},
TargetFrameworks =
{
new TargetFrameworkInformation
{
FrameworkName = NuGetFramework.Parse("net48"),
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.Combine(Path.GetTempPath(), $"XenkoNugetResolver-{packageName}-{versionRange.MinVersion.ToString()}"),
OriginalTargetFrameworks = new[] { "net48" },
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
};
// remove all remote sources, so we don't have to worry about connectivity issues
// we are only restoring local dev packages anyway
for (int i = 0; i < spec.RestoreMetadata.Sources.Count; i++)
{
var s = spec.RestoreMetadata.Sources[i];
if (s.IsLocal == false)
{
spec.RestoreMetadata.Sources.RemoveAt(i);
i--;
}
}
using (var context = new SourceCacheContext())
{
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 = logger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the packages
for (int tryCount = 0; tryCount < 2; ++tryCount)
{
try
{
var results = await RestoreRunner.RunWithoutCommit(requests, restoreArgs);
// Commit results so that noop cache works next time
foreach (var result in results)
{
await result.Result.CommitAsync(logger, CancellationToken.None);
}
var mainResult = results.First();
return(mainResult.SummaryRequest.Request, mainResult.Result);
}
catch (Exception e) when(e is UnauthorizedAccessException || e is IOException)
{
// If we have an unauthorized access exception, it means assemblies are locked by running Xenko process
// During first try, kill some known harmless processes, and try again
if (tryCount == 1)
{
throw;
}
foreach (var process in new[] { "Xenko.ConnectionRouter" }.SelectMany(Process.GetProcessesByName))
{
try
{
if (process.Id != Process.GetCurrentProcess().Id)
{
process.Kill();
process.WaitForExit();
}
}
catch (Exception)
{
}
}
}
}
throw new InvalidOperationException("Unreachable code");
}
}
/// <summary>
/// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json).
/// </summary>
/// <param name="projectPath">The full path to the project.</param>
/// <param name="id">The ID of the package.</param>
/// <param name="version">The version of the package.</param>
/// <param name="settings">The NuGet settings to use.</param>
/// <param name="logger">An <see cref="ILogger"/> to use for logging.</param>
/// <returns></returns>
public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(string projectPath, string id, string version, ISettings settings, ILogger logger)
{
using (SourceCacheContext sourceCacheContext = new SourceCacheContext
{
IgnoreFailedSources = true,
})
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i,
}).ToList())
{
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
SuppressParent = LibraryIncludeFlags.All,
AutoReferenced = true,
IncludeType = LibraryIncludeFlags.None,
Type = LibraryDependencyType.Build
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings)),
Log = logger,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
return(RestoreRunner.RunWithoutCommit(requests, restoreArgs));
}
}
/// <summary>
/// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json).
/// </summary>
/// <param name="libraryIdentity">The <see cref="LibraryIdentity"/> of the package.</param>
/// <param name="settings">The NuGet settings to use.</param>
/// <param name="logger">An <see cref="ILogger"/> to use for logging.</param>
/// <returns></returns>
public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(LibraryIdentity libraryIdentity, ISettings settings, ILogger logger)
{
using (var sourceCacheContext = new SourceCacheContext
{
IgnoreFailedSources = true,
})
{
var projectDirectory = Path.Combine(NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), Guid.NewGuid().ToString("N"));
var projectName = Guid.NewGuid().ToString("N");
var projectFullPath = Path.Combine(projectDirectory, $"{projectName}.proj");
// Iterate through TargetFrameworks to generate Lists required for packageSpec
var frameworks = new List <TargetFrameworkInformation>(TargetFrameworks.Count);
var originalTargetFrameworks = new List <string>(TargetFrameworks.Count);
foreach (var tf in TargetFrameworks)
{
frameworks.Add(new TargetFrameworkInformation
{
FrameworkName = tf
});
originalTargetFrameworks.Add(tf.ToString());
}
// The package spec details what packages to restore
var packageSpec = new PackageSpec(frameworks)
{
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(
libraryIdentity.Name,
new VersionRange(
minVersion: libraryIdentity.Version,
includeMinVersion: true,
maxVersion: libraryIdentity.Version,
includeMaxVersion: true),
LibraryDependencyTarget.Package),
SuppressParent = LibraryIncludeFlags.All,
AutoReferenced = true,
IncludeType = LibraryIncludeFlags.None,
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectFullPath,
ProjectName = projectName,
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectFullPath,
OutputPath = projectDirectory,
OriginalTargetFrameworks = originalTargetFrameworks,
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).AsList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
FilePath = projectFullPath,
Name = projectName,
};
var dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
var restoreArgs = new RestoreArgs
{
AllowNoOp = false,
CacheContext = sourceCacheContext,
#pragma warning disable CS0618 // Type or member is obsolete
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false)),
#pragma warning restore CS0618 // Type or member is obsolete
Log = logger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
return(RestoreRunner.RunWithoutCommit(requests, restoreArgs));
}
}
private RestoreTargetGraph GetRestoreTargetGraph(List <PackageReference> packages, string projectPath, List <NuGetFramework> targetFrameworks, SourceCacheContext sourceCacheContext)
{
// The package spec details what packages to restore
PackageSpec packageSpec = new PackageSpec(targetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i
}).ToList())
{
//Dependencies = new List<LibraryDependency>
//{
// new LibraryDependency
// {
// LibraryRange = new LibraryRange(id, new VersionRange(NuGetVersion.Parse(version)), LibraryDependencyTarget.Package),
// SuppressParent = LibraryIncludeFlags.All,
// AutoReferenced = true,
// IncludeType = LibraryIncludeFlags.None,
// Type = LibraryDependencyType.Build
// }
//},
Dependencies = packages.Select(i => new LibraryDependency
{
LibraryRange = new LibraryRange(i.PackageId, new VersionRange(i.PackageVersion), LibraryDependencyTarget.Package),
//SuppressParent = LibraryIncludeFlags.All,
//AutoReferenced = true,
//IncludeType = LibraryIncludeFlags.None,
//Type = LibraryDependencyType.
}).ToList(),
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = targetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = SettingsUtility.GetConfigFilePaths(_nugetSettings).ToList(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
Sources = SettingsUtility.GetEnabledSources(_nugetSettings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(_nugetSettings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(projectPath),
};
DependencyGraphSpec dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
RestoreArgs restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(_nugetSettings)),
Log = NullLogger.Instance,
};
// Create requests from the arguments
IReadOnlyList <RestoreSummaryRequest> requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
RestoreResultPair restoreResult = RestoreRunner.RunWithoutCommit(requests, restoreArgs).Result.FirstOrDefault();
RestoreTargetGraph restoreTargetGraph = restoreResult?.Result.RestoreGraphs.FirstOrDefault();
return(restoreTargetGraph);
}
public static (RestoreRequest, RestoreResult) Restore(ILogger logger, NuGetFramework nugetFramework, string runtimeIdentifier, string packageName, VersionRange versionRange, string settingsRoot = null)
{
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(settingsRoot);
var assemblies = new List <string>();
var projectPath = Path.Combine("StrideNugetResolver.json");
var spec = new PackageSpec()
{
// Make sure this package never collides with a dependency
Name = Path.GetFileNameWithoutExtension(projectPath),
FilePath = projectPath,
Dependencies = new List <LibraryDependency>()
{
new LibraryDependency
{
LibraryRange = new LibraryRange(packageName, versionRange, LibraryDependencyTarget.Package),
}
},
TargetFrameworks =
{
new TargetFrameworkInformation
{
FrameworkName = nugetFramework,
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(projectPath),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = projectPath,
OutputPath = Path.Combine(Path.GetTempPath(), $"StrideNugetResolver-{packageName}-{versionRange.MinVersion.ToString()}-{nugetFramework.GetShortFolderName()}-{runtimeIdentifier}"),
OriginalTargetFrameworks = new[] { nugetFramework.GetShortFolderName() },
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
RuntimeGraph = new RuntimeGraph(new[] { new RuntimeDescription(runtimeIdentifier) })
};
using (var context = new SourceCacheContext())
{
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 = logger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the packages
for (int tryCount = 0; tryCount < 2; ++tryCount)
{
try
{
var results = RestoreRunner.RunWithoutCommit(requests, restoreArgs).Result;
// Commit results so that noop cache works next time
foreach (var result in results)
{
result.Result.CommitAsync(logger, CancellationToken.None).Wait();
}
var mainResult = results.First();
return(mainResult.SummaryRequest.Request, mainResult.Result);
}
catch (Exception e) when(e is UnauthorizedAccessException || e is IOException || ((e is AggregateException ae) && ae.InnerExceptions.Any(e2 => e2 is UnauthorizedAccessException || e2 is IOException)))
{
// If we have an unauthorized access exception, it means assemblies are locked by running Stride process
// During first try, kill some known harmless processes, and try again
if (tryCount == 1)
{
throw;
}
foreach (var process in new[] { "Stride.ConnectionRouter" }.SelectMany(Process.GetProcessesByName))
{
try
{
if (process.Id != Process.GetCurrentProcess().Id)
{
process.Kill();
process.WaitForExit();
}
}
catch { }
}
}
}
Debug.Fail("Unreachable code");
return(default);
private async Task <ImmutableArray <SemanticVersion> > GetAllVersionsFromApiInternalAsync(
NuGetPackageId packageId,
string?nuGetSource,
string?nugetConfig,
bool allowPreRelease,
HttpClient httpClient,
ILogger logger,
CancellationToken cancellationToken)
{
ISettings?settings = null;
if (!string.IsNullOrWhiteSpace(nugetConfig))
{
var fileInfo = new FileInfo(nugetConfig);
settings = Settings.LoadSpecificSettings(fileInfo.Directory !.FullName, fileInfo.Name);
}
string?currentDirectory = Directory.GetCurrentDirectory();
settings ??= Settings.LoadDefaultSettings(
currentDirectory,
configFileName: null,
new XPlatMachineWideSetting());
var sources = SettingsUtility.GetEnabledSources(settings).ToArray();
var cache = new SourceCacheContext();
NuGet.Common.ILogger nugetLogger = GetLogger(logger);
var semanticVersions = new HashSet <SemanticVersion>();
foreach (var packageSource in sources)
{
if (!string.IsNullOrWhiteSpace(nuGetSource) &&
!packageSource.Name.Equals(nuGetSource, StringComparison.OrdinalIgnoreCase))
{
continue;
}
SourceRepository repository;
if (packageSource.IsHttp)
{
bool isV3Feed;
if (packageSource.ProtocolVersion == 3)
{
isV3Feed = true;
}
else
{
isV3Feed = await IsV3Feed(packageSource, httpClient, HttpMethod.Head, cancellationToken);
}
repository = isV3Feed
? Repository.Factory.GetCoreV3(packageSource.SourceUri.ToString())
: Repository.Factory.GetCoreV2(packageSource);
}
else
{
repository = Repository.Factory.GetCoreV2(packageSource);
}
if (sources.Length == 1 && sources[0].Credentials is { })
/// <summary>
/// Restores a package by querying, downloading, and unzipping it without generating any other files (like project.assets.json).
/// </summary>
/// <param name="libraryIdentity">The <see cref="LibraryIdentity"/> of the package.</param>
/// <param name="settings">The NuGet settings to use.</param>
/// <param name="logger">An <see cref="ILogger"/> to use for logging.</param>
/// <returns></returns>
public static Task <IReadOnlyList <RestoreResultPair> > RunWithoutCommit(LibraryIdentity libraryIdentity, ISettings settings, ILogger logger)
{
using (var sourceCacheContext = new SourceCacheContext
{
IgnoreFailedSources = true,
})
{
var projectPath = Path.Combine(Path.GetTempPath(), TempProjectName);
// The package spec details what packages to restore
var packageSpec = new PackageSpec(TargetFrameworks.Select(i => new TargetFrameworkInformation
{
FrameworkName = i,
}).ToList())
{
Dependencies = new List <LibraryDependency>
{
new LibraryDependency
{
LibraryRange = new LibraryRange(
libraryIdentity.Name,
new VersionRange(
minVersion: libraryIdentity.Version,
includeMinVersion: true,
maxVersion: libraryIdentity.Version,
includeMaxVersion: true),
LibraryDependencyTarget.Package),
SuppressParent = LibraryIncludeFlags.All,
AutoReferenced = true,
IncludeType = LibraryIncludeFlags.None,
Type = LibraryDependencyType.Build
}
},
RestoreMetadata = new ProjectRestoreMetadata
{
ProjectPath = projectPath,
ProjectName = Path.GetFileNameWithoutExtension(TempProjectName),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = TempProjectName,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = TargetFrameworks.Select(i => i.ToString()).ToList(),
ConfigFilePaths = settings.GetConfigFilePaths(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings),
Sources = SettingsUtility.GetEnabledSources(settings).ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList()
},
FilePath = projectPath,
Name = Path.GetFileNameWithoutExtension(TempProjectName),
};
var dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(packageSpec);
dependencyGraphSpec.AddRestore(packageSpec.RestoreMetadata.ProjectUniqueName);
IPreLoadedRestoreRequestProvider requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
var restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = sourceCacheContext,
#pragma warning disable CS0618 // Type or member is obsolete
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(settings, enablePackageSourcesChangedEvent: false)),
#pragma warning restore CS0618 // Type or member is obsolete
Log = logger,
};
// Create requests from the arguments
var requests = requestProvider.CreateRequests(restoreArgs).Result;
// Restore the package without generating extra files
return(RestoreRunner.RunWithoutCommit(requests, restoreArgs));
}
}
