/// <summary>
/// Create a restore context.
/// </summary>
private static RestoreArgs GetRestoreContext(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
bool forceRestore)
{
var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings));
foreach (var source in sources)
{
caching.AddSourceRepository(source);
}
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
AllowNoOp = !forceRestore,
CachingSourceProvider = caching
};
return(restoreContext);
}
/// <summary>
/// Create a restore context.
/// </summary>
private static RestoreArgs GetRestoreContext(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
ISettings settings,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
string userPackagesPath)
{
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile, settings);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
SourceRepositories = sources.ToList(),
GlobalPackagesFolder = userPackagesPath // Optional, this will load from settings if null
};
return(restoreContext);
}
private async Task <RestoreTargetGraph?> RestoreProjectAsync(IEnumerable <NuGetReference> packages, IEnumerable <TargetFrameworkMoniker> tfms, CancellationToken token)
{
var tfmInfo = tfms.Select(tfm => new TargetFrameworkInformation {
FrameworkName = NuGetFramework.Parse(tfm.ToFullString())
}).ToList();
// Create a project in a unique and temporary directory
var path = Path.Combine(Path.GetTempPath(), "dotnet-ua", "restores", Guid.NewGuid().ToString(), "project.txt");
var spec = new PackageSpec(tfmInfo)
{
Dependencies = packages.Select(i => new LibraryDependency
{
LibraryRange = new LibraryRange(i.Name, new VersionRange(i.GetNuGetVersion()), LibraryDependencyTarget.Package),
}).ToList(),
RestoreMetadata = new()
{
ProjectPath = path,
ProjectName = Path.GetFileNameWithoutExtension(path),
ProjectStyle = ProjectStyle.PackageReference,
ProjectUniqueName = path,
OutputPath = Path.GetTempPath(),
OriginalTargetFrameworks = tfms.Select(tfm => tfm.ToFullString()).ToArray(),
ConfigFilePaths = _settings.GetConfigFilePaths(),
PackagesPath = SettingsUtility.GetGlobalPackagesFolder(_settings),
Sources = _packageSources.ToList(),
FallbackFolders = SettingsUtility.GetFallbackPackageFolders(_settings).ToList(),
},
FilePath = path,
Name = Path.GetFileNameWithoutExtension(path),
};
var dependencyGraphSpec = new DependencyGraphSpec();
dependencyGraphSpec.AddProject(spec);
dependencyGraphSpec.AddRestore(spec.RestoreMetadata.ProjectUniqueName);
var requestProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dependencyGraphSpec);
var restoreArgs = new RestoreArgs
{
AllowNoOp = true,
CacheContext = _context,
CachingSourceProvider = new CachingSourceProvider(new PackageSourceProvider(_settings)),
Log = new NuGetLogger(_logger),
};
// Create requests from the arguments
var requests = await requestProvider.CreateRequests(restoreArgs).ConfigureAwait(false);
// Restore the package without generating extra files
var result = await RestoreRunner.RunWithoutCommit(requests, restoreArgs).ConfigureAwait(false);
if (result.Count == 0)
{
return(null);
}
return(result[0].Result.RestoreGraphs.FirstOrDefault());
}
public void GetMessagesForProject_WithMultipleMessages_SelectedMessagesForCorrectProject()
{
// Arrange
var project1 = @"z:\src\solution\project1\project1.csproj";
var project2 = @"z:\src\solution\project2\project2.csproj";
var project1Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1001, "project1 error");
project1Error.ProjectPath = project1;
var project2Error = RestoreLogMessage.CreateError(NuGetLogCode.NU1002, "project2 error");
project2Error.ProjectPath = project2;
var solutionMessages = new List <IAssetsLogMessage>()
{
AssetsLogMessage.Create(project1Error),
AssetsLogMessage.Create(project2Error)
};
// Act
IReadOnlyList <IAssetsLogMessage> actual = DependencyGraphSpecRequestProvider.GetMessagesForProject(solutionMessages, project1);
// Assert
var actualError = Assert.Single(actual);
Assert.Equal(NuGetLogCode.NU1001, actualError.Code);
}
private async Task <RestoreTargetGraph> GenerateRestoreGraph(ILogger log, string projectName, string projectPath)
{
var dgFile = await VSProjectHelper.GenerateRestoreGraphFile(log, projectPath);
var dgProvider = new DependencyGraphSpecRequestProvider(new RestoreCommandProvidersCache(), dgFile);
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs();
restoreContext.CacheContext = cacheContext;
restoreContext.Log = new NuGet.Common.NullLogger();
restoreContext.PreLoadedRequestProviders.Add(dgProvider);
var request = (await dgProvider.CreateRequests(restoreContext)).Single();
var restoreRequest = request.Request;
var collectorLogger = new RestoreCollectorLogger(restoreRequest.Log, false);
var contextForProject = CreateRemoteWalkContext(restoreRequest, collectorLogger);
// Get external project references
// If the top level project already exists, update the package spec provided
// with the RestoreRequest spec.
var updatedExternalProjects = GetProjectReferences(restoreRequest, contextForProject);
// Load repositories
// the external project provider is specific to the current restore project
contextForProject.ProjectLibraryProviders.Add(new PackageSpecReferenceDependencyProvider(updatedExternalProjects, restoreRequest.Log));
var walker = new RemoteDependencyWalker(contextForProject);
var requestProject = request.Request.Project;
var projectRange = new LibraryRange()
{
Name = projectName,
VersionRange = new NuGet.Versioning.VersionRange(requestProject.Version),
TypeConstraint = LibraryDependencyTarget.Project | LibraryDependencyTarget.ExternalProject
};
var framework = requestProject.TargetFrameworks.First();
var graphs = new List <GraphNode <RemoteResolveResult> >
{
await walker.WalkAsync(
projectRange,
framework.FrameworkName,
null,
RuntimeGraph.Empty,
recursive : true)
};
return(RestoreTargetGraph.Create(graphs, contextForProject, restoreRequest.Log, framework.FrameworkName));
}
}
/// <summary>
/// Create a restore request for the specs. Restore only the first one.
/// </summary>
public static async Task <RestoreRequest> GetRequestAsync(
RestoreArgs restoreContext,
params PackageSpec[] projects)
{
var dgSpec = GetDGSpec(projects);
var dgProvider = new DependencyGraphSpecRequestProvider(
new RestoreCommandProvidersCache(),
dgSpec);
var requests = await dgProvider.CreateRequests(restoreContext);
return(requests.Single().Request);
}
/// <summary>
/// Create a restore args.
/// </summary>
private static RestoreArgs GetRestoreArgs(
DependencyGraphCacheContext context,
RestoreCommandProvidersCache providerCache,
SourceCacheContext sourceCacheContext,
IEnumerable <SourceRepository> sources,
DependencyGraphSpec dgFile,
Guid parentId,
bool forceRestore,
bool isRestoreOriginalAction,
bool restoreForceEvaluate,
IReadOnlyList <IAssetsLogMessage> additionalMessasges,
IRestoreProgressReporter progressReporter)
{
#pragma warning disable CS0618 // Type or member is obsolete
var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings, enablePackageSourcesChangedEvent: false));
#pragma warning restore CS0618 // Type or member is obsolete
foreach (var source in sources)
{
caching.AddSourceRepository(source);
}
var dgProvider = new DependencyGraphSpecRequestProvider(providerCache, dgFile);
var restoreContext = new RestoreArgs()
{
CacheContext = sourceCacheContext,
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
dgProvider
},
Log = context.Logger,
AllowNoOp = !forceRestore,
CachingSourceProvider = caching,
ParentId = parentId,
IsRestoreOriginalAction = isRestoreOriginalAction,
RestoreForceEvaluate = restoreForceEvaluate,
AdditionalMessages = additionalMessasges,
ProgressReporter = progressReporter,
};
return(restoreContext);
}
public static TestRestoreRequest CreateRestoreRequest(PackageSpec projectToRestore, IEnumerable <PackageSpec> packageSpecsClosure, SimpleTestPathContext pathContext, ILogger logger)
{
var sources = new List <PackageSource> {
new PackageSource(pathContext.PackageSource)
};
var dgSpec = new DependencyGraphSpec();
dgSpec.AddProject(projectToRestore);
dgSpec.AddRestore(projectToRestore.RestoreMetadata.ProjectUniqueName);
foreach (var spec in packageSpecsClosure)
{
dgSpec.AddProject(spec);
}
var externalClosure = DependencyGraphSpecRequestProvider.GetExternalClosure(dgSpec, projectToRestore.RestoreMetadata.ProjectUniqueName).ToList();
return(new TestRestoreRequest(projectToRestore, sources, pathContext.UserPackagesFolder, logger)
{
LockFilePath = Path.Combine(projectToRestore.FilePath, LockFileFormat.AssetsFileName),
DependencyGraphSpec = dgSpec,
ExternalProjects = externalClosure,
});
}
/// <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");
}
}
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);
