public async Task ExceptionsShouldNotBlockProcessing()
{
int callbackCount = 0;
var queue = new ActionQueue(degreeOfParallelism: 2);
try
{
await queue.ForEachAsync <int>(
Enumerable.Range(1, 5),
async (element, index) =>
{
Interlocked.Increment(ref callbackCount);
await Task.Yield();
throw new Exception($"Failing item '{element}'.");
}).WithTimeoutAsync(timeout: TimeSpan.FromSeconds(5));
Assert.True(false, "ForEachAsync should fail.");
}
catch (TimeoutException)
{
Assert.True(false, "ForEachAsync got stuck");
}
catch (Exception e)
{
Assert.Equal(5, callbackCount);
Assert.Contains("Failing item ", e.ToString());
}
}
/// <summary>
/// Takes a list of sealed directories, searches their contents for special manifest files, parses each of them to obtain
/// a list of files to materialize, and finally requests from BuildXL's ApiServer to materialize them.
/// </summary>
private async Task <IIpcResult> RegisterManifestInternalAsync(ConfiguredCommand conf)
{
m_counters.IncrementCounter(MaterializationDaemonCounter.RegisterManifestRequestCount);
var directoryPaths = Directory.GetValues(conf.Config).ToArray();
var directoryIds = DirectoryId.GetValues(conf.Config).ToArray();
var directoryFilters = DirectoryContentFilter.GetValues(conf.Config).ToArray();
if (directoryPaths.Length != directoryIds.Length || directoryPaths.Length != directoryFilters.Length)
{
return(new IpcResult(
IpcResultStatus.GenericError,
I($"Directory counts don't match: #directories = {directoryPaths.Length}, #directoryIds = {directoryIds.Length}, #directoryFilters = {directoryFilters.Length}")));
}
if (ApiClient == null)
{
return(new IpcResult(IpcResultStatus.GenericError, "ApiClient is not initialized"));
}
var possibleFilters = InitializeFilters(directoryFilters);
if (!possibleFilters.Succeeded)
{
return(new IpcResult(IpcResultStatus.ExecutionError, possibleFilters.Failure.Describe()));
}
var initializedFilters = possibleFilters.Result;
var possibleManifestFiles = await GetUniqueFilteredDirectoryContentAsync(directoryPaths, directoryIds, initializedFilters);
if (!possibleManifestFiles.Succeeded)
{
return(new IpcResult(IpcResultStatus.ExecutionError, possibleManifestFiles.Failure.Describe()));
}
var manifestFiles = possibleManifestFiles.Result;
var sw = Stopwatch.StartNew();
List <string> filesToMaterialize = null;
try
{
// ensure that the manifest files are actually present on disk
using (m_counters.StartStopwatch(MaterializationDaemonCounter.RegisterManifestFileMaterializationDuration))
{
await m_actionQueue.ForEachAsync(
manifestFiles,
async (manifest, i) =>
{
m_counters.AddToCounter(MaterializationDaemonCounter.RegisterManifestFileMaterializationQueueDuration, sw.ElapsedMilliseconds);
await MaterializeFileAsync(manifest.Artifact, manifest.FileName, ignoreMaterializationFailures: false);
});
}
Possible <List <string> > possibleFiles;
using (m_counters.StartStopwatch(MaterializationDaemonCounter.ManifestParsingOuterDuration))
{
m_counters.AddToCounter(MaterializationDaemonCounter.ManifestParsingTotalFiles, possibleManifestFiles.Result.Count);
possibleFiles = await ParseManifestFilesAsync(manifestFiles);
if (!possibleFiles.Succeeded)
{
return(new IpcResult(IpcResultStatus.ExecutionError, possibleFiles.Failure.Describe()));
}
m_counters.AddToCounter(MaterializationDaemonCounter.ManifestParsingReferencedTotalFiles, possibleFiles.Result.Count);
}
filesToMaterialize = possibleFiles.Result;
sw = Stopwatch.StartNew();
using (m_counters.StartStopwatch(MaterializationDaemonCounter.RegisterManifestReferencedFileMaterializationDuration))
{
await m_actionQueue.ForEachAsync(
filesToMaterialize,
async (file, i) =>
{
// Since these file paths are not real build artifacts (i.e., just strings constructed by a parser),
// they might not be "known" to BuildXL, and because of that, BuildXL won't be able to materialize them.
// Manifests are known to contain references to files that are not produced during a build, so we are
// ignoring materialization failures for such files. We are doing this so we won't fail IPC pips and
// a build could succeed.
// If there are real materialization errors (e.g., cache failure), the daemon relies on BuildXL logging
// the appropriate error events and failing the build.
m_counters.AddToCounter(MaterializationDaemonCounter.RegisterManifestReferencedFileMaterializationQueueDuration, sw.ElapsedMilliseconds);
await MaterializeFileAsync(FileArtifact.Invalid, file, ignoreMaterializationFailures: true);
});
}
}
catch (Exception e)
{
return(new IpcResult(
IpcResultStatus.GenericError,
e.ToStringDemystified()));
}
// Note: we are not claiming here that all the files in filesToMaterialize were materialized cause we are ignoring materialization failures.
// The real materialization status will be logged during execution of the Finalize command.
return(IpcResult.Success(
$"Processed paths ({filesToMaterialize.Count}):{Environment.NewLine}{string.Join(Environment.NewLine, filesToMaterialize)}"));
}
