public void ValidateBasicCacheMissCounters()
{
AbsolutePath.TryCreate(Context.PathTable, ReadonlyRoot, out var readonlyRootPath);
var readonlyRootDir = DirectoryArtifact.CreateWithZeroPartialSealId(readonlyRootPath);
var childDir = DirectoryArtifact.CreateWithZeroPartialSealId(CreateUniqueDirectory(ReadonlyRoot));
// Enumerate /readonlyroot and /readonlyroot/childDir
Process enumeratorPip = CreateAndSchedulePipBuilder(new Operation[]
{
Operation.EnumerateDir(childDir),
Operation.WriteFile(CreateOutputFileArtifact())
}).Process;
Process writerPip = CreateAndSchedulePipBuilder(new Operation[]
{
Operation.WriteFile(CreateOutputFileArtifact())
}).Process;
ScheduleRunResult result1 = RunScheduler();
result1.AssertCacheMiss(enumeratorPip.PipId, writerPip.PipId);
result1.AssertNumWeakFingerprintMisses(2);
// Create /childDir/nestedFile, causing strong fingerprint miss
FileArtifact nestedFile = CreateSourceFile(ArtifactToString(childDir));
ScheduleRunResult result2 = RunScheduler();
result2.AssertCacheHit(writerPip.PipId);
// Weak fingerprint hit on both pips
result2.AssertNumWeakFingerprintMisses(0);
// Strong fingerprint miss on enumeratorPip
result2.AssertCacheMiss(enumeratorPip.PipId);
result2.AssertNumStrongFingerprintMisses(1);
}
public void PreserveOutputsWithTrustLevelModification()
{
Configuration.Sandbox.UnsafeSandboxConfigurationMutable.PreserveOutputs = PreserveOutputsMode.Enabled;
Configuration.Sandbox.UnsafeSandboxConfigurationMutable.PreserveOutputsTrustLevel = 3;
var input = CreateSourceFile();
var outputPreservedA = CreateOutputFileArtifact(Path.Combine(ObjectRoot, @"nested\out\filePreservedA"));
var builderA = CreatePipBuilder(new Operation[]
{
Operation.ReadFile(input),
Operation.WriteFile(outputPreservedA, CONTENT),
});
// processA won't perserve outputs
builderA.Options |= Process.Options.AllowPreserveOutputs;
builderA.PreserveOutputsTrustLevel = 2;
var processAndOutputsA = SchedulePipBuilder(builderA);
RunSchedulerAndGetOutputContents(outputPreservedA, false, processAndOutputsA.Process.PipId);
XAssert.AreEqual(CONTENT, File.ReadAllText(ArtifactToString(outputPreservedA)));
// after decreasing global preserve output trust level to 1, process A will not be scheduled
Configuration.Sandbox.UnsafeSandboxConfigurationMutable.PreserveOutputsTrustLevel = 1;
ScheduleRunResult result = RunScheduler();
if (Configuration.Schedule.IncrementalScheduling)
{
result.AssertNotScheduled(processAndOutputsA.Process.PipId);
}
else
{
result.AssertCacheHit(processAndOutputsA.Process.PipId);
}
XAssert.AreEqual(CONTENT, File.ReadAllText(ArtifactToString(outputPreservedA)));
// once we change back global TL to 3, process A will be scheduled again
Configuration.Sandbox.UnsafeSandboxConfigurationMutable.PreserveOutputsTrustLevel = 3;
result = RunScheduler();
if (Configuration.Schedule.IncrementalScheduling)
{
result.AssertScheduled(processAndOutputsA.Process.PipId);
}
else
{
result.AssertCacheMiss(processAndOutputsA.Process.PipId);
}
XAssert.AreEqual(CONTENT, File.ReadAllText(ArtifactToString(outputPreservedA)));
}
public void ValidateCachingRewrittenFiles()
{
// Three pips sharing the same file as input and rewriting it.
// Each pip has a unique src file that is modified to trigger that individual pip to re-run.
// When a pip is run, it reads in the shared file, then appends one line of random output.
// The random output triggers the subsequent, dependent pips to re-run.
var srcA = CreateSourceFile();
var rewrittenFile = CreateOutputFileArtifact();
var paoA = CreateAndSchedulePipBuilder(new Operation[]
{
Operation.ReadFile(srcA),
Operation.WriteFile(rewrittenFile), /* unique output on every pip run */
Operation.WriteFile(rewrittenFile, System.Environment.NewLine)
});
Process pipA = paoA.Process;
var srcB = CreateSourceFile();
var pipBuilderB = CreatePipBuilder(new Operation[]
{
Operation.ReadFile(srcB),
Operation.WriteFile(rewrittenFile, doNotInfer: true), /* unique output on every pip run */
Operation.WriteFile(rewrittenFile, System.Environment.NewLine, doNotInfer: true)
});
pipBuilderB.AddRewrittenFileInPlace(paoA.ProcessOutputs.GetOutputFile(rewrittenFile.Path));
var paoB = SchedulePipBuilder(pipBuilderB);
Process pipB = paoB.Process;
var srcC = CreateSourceFile();
var pipBuilderC = CreatePipBuilder(new Operation[]
{
Operation.ReadFile(srcC),
Operation.WriteFile(rewrittenFile, doNotInfer: true), /* unique output on every pip run */
Operation.WriteFile(rewrittenFile, System.Environment.NewLine, doNotInfer: true)
});
pipBuilderC.AddRewrittenFileInPlace(paoB.ProcessOutputs.GetOutputFile(rewrittenFile.Path));
Process pipC = SchedulePipBuilder(pipBuilderC).Process;
RunScheduler().AssertSuccess();
// Modify input to pipA to trigger re-run, cache miss on all three
File.AppendAllText(ArtifactToString(srcA), "srcA");
ScheduleRunResult resultA = RunScheduler().AssertSuccess();
resultA.AssertCacheMiss(pipA.PipId);
resultA.AssertCacheMiss(pipB.PipId);
resultA.AssertCacheMiss(pipC.PipId);
// Store results of file to check cache replay
var outRunA = File.ReadAllLines(ArtifactToString(rewrittenFile));
XAssert.AreEqual(3, outRunA.Length); /* exactly one line of output per pip */
// Modify input to pipB to trigger re-run, cache miss on B and C
File.AppendAllText(ArtifactToString(srcB), "srcB");
ScheduleRunResult resultB = RunScheduler().AssertSuccess();
resultB.AssertCacheHit(pipA.PipId);
resultB.AssertCacheMiss(pipB.PipId);
resultB.AssertCacheMiss(pipC.PipId);
// Check cache hit from resultB replayed version of file written only by pipA
var outRunB = File.ReadAllLines(ArtifactToString(rewrittenFile));
XAssert.AreEqual(3, outRunB.Length); /* exactly one line of output per pip */
XAssert.AreEqual(outRunA[0], outRunB[0]);
XAssert.AreNotEqual(outRunA[1], outRunB[1]);
XAssert.AreNotEqual(outRunA[2], outRunB[2]);
// Modify input to pipC to trigger re-run, cache miss on only C
File.AppendAllText(ArtifactToString(srcC), "srcC");
ScheduleRunResult resultC = RunScheduler().AssertSuccess();
resultC.AssertCacheHit(pipA.PipId);
resultC.AssertCacheHit(pipB.PipId);
resultC.AssertCacheMiss(pipC.PipId);
// Check cache hit from resultC replayed version of file run written only by pipA and pipB
var outRunC = File.ReadAllLines(ArtifactToString(rewrittenFile));
XAssert.AreEqual(outRunA.Length, 3); /* exactly one line of output per pip */
XAssert.AreEqual(outRunB[0], outRunC[0]);
XAssert.AreEqual(outRunB[1], outRunC[1]);
XAssert.AreNotEqual(outRunB[2], outRunC[2]);
}