/// <summary>
/// Verifies that the file/directory output by a fragment exists in the resulting graph.
/// </summary>
/// <param name="graph">Resulting graph.</param>
/// <param name="fragmentOrigin">Graph fragment where the output originates.</param>
/// <param name="outputPath">Path to output file/directory.</param>
private void VerifyProducerExists(PipGraph graph, TestPipGraphFragment fragmentOrigin, AbsolutePath outputPath)
{
AbsolutePath remappedOutputPath = RemapFragmentPath(fragmentOrigin, outputPath);
var pipId = graph.TryGetProducer(FileArtifact.CreateOutputFile(remappedOutputPath));
if (!pipId.IsValid)
{
pipId = graph.TryGetProducer(DirectoryArtifact.CreateWithZeroPartialSealId(remappedOutputPath));
}
XAssert.IsTrue(pipId.IsValid, $"Producer of '{outputPath.ToString(fragmentOrigin.Context.PathTable)}' from fragment '{fragmentOrigin.ModuleName}' could not be found in the resulting graph");
}
/// <summary>
/// Verifies the resulting arguments after full graph construction.
/// </summary>
/// <param name="graph">Resulting graph.</param>
/// <param name="fragmentOrigin">Graph fragment where the arguments are constructed.</param>
/// <param name="outputInFragmentOrigin">Output file to identify pip.</param>
/// <param name="expectedArguments">Expected arguments.</param>
private void VerifyResultingArguments(PipGraph graph, TestPipGraphFragment fragmentOrigin, FileArtifact outputInFragmentOrigin, PipData expectedArguments)
{
var pipId = graph.TryGetProducer(FileArtifact.CreateOutputFile(RemapFragmentPath(fragmentOrigin, outputInFragmentOrigin)));
XAssert.IsTrue(pipId.IsValid);
Pip pip = graph.PipTable.HydratePip(pipId, PipQueryContext.PipGraphGetProducingPip);
XAssert.IsNotNull(pip);
PipData actualArguments = PipData.Invalid;
if (pip is Process process)
{
actualArguments = process.Arguments;
}
else if (pip is IpcPip ipcPip)
{
actualArguments = ipcPip.MessageBody;
}
else
{
XAssert.Fail("No arguments associated with pip");
}
string expected = expectedArguments.ToString(Context.PathTable).ToUpperInvariant();
string actual = actualArguments.ToString(Context.PathTable).ToUpperInvariant();
XAssert.AreEqual(expected, actual);
}
private DirectoryEntry CreateEntry(DirectoryArtifact dir)
{
var sealId = PipGraph.GetSealedDirectoryNode(dir).ToPipId();
var sealKind = PipTable.GetSealDirectoryKind(sealId);
var pipId = PipGraph.TryGetProducer(dir);
var producer = GetEntry(pipId);
var pip = (SealDirectory)GetPip(sealId);
var kind = pip.Kind.ToString();
if (pip.IsComposite)
{
kind = "Composite" + kind;
}
var entry = new DirectoryEntry()
{
Directory = dir,
Producer = GetEntry(pipId),
FileCount = GetContents(dir).Length,
Kind = sealKind,
SemistableHash = producer?.Identifier ?? string.Empty,
Identifier = $"{pip.FormattedSemiStableHash} [{kind}]",
Id = dir.PartialSealId.ToString(),
};
if (pip.Provenance.Token.Path.IsValid)
{
entry.SpecFileName = pip.Provenance.Token.Path.GetName(PathTable).ToString(StringTable);
}
return(entry);
}
public override void Prepare()
{
Directory.CreateDirectory(OutputFilePath);
m_writer = new StreamWriter(Path.Combine(OutputFilePath, "results.txt"));
Console.WriteLine("Creating nodes");
foreach (var node in DataflowGraph.Nodes)
{
m_mutableGraph.CreateNode();
}
Console.WriteLine("Created nodes");
foreach (var entry in PipGraph.AllOutputDirectoriesAndProducers)
{
var sealId = PipGraph.GetSealedDirectoryNode(entry.Key).ToPipId();
m_dynamicDirectoryProducers[sealId] = entry.Value;
}
foreach (CopyFile copyFile in PipGraph.RetrievePipsOfType(PipType.CopyFile))
{
m_copiedFilesByTarget[copyFile.Destination] = copyFile.Source;
}
foreach (var directory in PipGraph.AllSealDirectories)
{
var sealId = PipGraph.GetSealedDirectoryNode(directory).ToPipId();
var sealKind = PipTable.GetSealDirectoryKind(sealId);
// Populate map of whether this is a source only seal
IsSourceOnlySeal(sealId);
if (sealKind == SealDirectoryKind.Full || sealKind == SealDirectoryKind.Partial)
{
PipId?singleProducer = null;
foreach (var file in PipGraph.ListSealedDirectoryContents(directory))
{
if (file.IsOutputFile)
{
var producer = PipGraph.TryGetProducer(file);
if (singleProducer == null)
{
singleProducer = producer;
}
else if (singleProducer != producer)
{
singleProducer = PipId.Invalid;
}
}
}
if (singleProducer.HasValue && singleProducer.Value.IsValid)
{
m_dynamicDirectoryProducers[sealId] = singleProducer.Value;
}
}
}
}
private void GetPathProducers(AbsolutePath path)
{
Dictionary <AbsolutePath, DirectoryArtifact> directories = new Dictionary <AbsolutePath, DirectoryArtifact>();
foreach (var directory in PipGraph.AllSealDirectories)
{
directories[directory.Path] = directory;
}
var latest = PipGraph.TryGetLatestFileArtifactForPath(path);
if (!latest.IsValid)
{
m_writer.WriteLine("No declared file producers");
}
else
{
for (int i = 0; i <= latest.RewriteCount; i++)
{
var producerId = PipGraph.TryGetProducer(new FileArtifact(path, i));
if (producerId.IsValid)
{
m_writer.WriteLine("File Producer: ({0})", i);
m_producers.Add(producerId);
m_writer.WriteLine(GetDescription(GetPip(producerId)));
m_writer.WriteLine();
}
}
}
while (path.IsValid)
{
DirectoryArtifact containingDirectory;
if (directories.TryGetValue(path, out containingDirectory))
{
var directoryNode = PipGraph.GetSealedDirectoryNode(containingDirectory);
var sealDirectory = (SealDirectory)GetPip(directoryNode);
if (sealDirectory.Kind == SealDirectoryKind.Opaque)
{
m_writer.WriteLine("Directory Producer:");
m_producers.Add(PipGraph.GetProducer(containingDirectory));
m_writer.WriteLine(GetDescription(GetPip(PipGraph.GetProducer(containingDirectory))));
m_writer.WriteLine("Directory: " + GetDescription(sealDirectory));
m_writer.WriteLine();
}
}
path = path.GetParent(PathTable);
}
}
/// <summary>
/// Verifies that the arguments constructed in the fragment (string) matches with the one in the resulting graph.
/// </summary>
/// <param name="graph">Resulting graph.</param>
/// <param name="fragmentOrigin">Graph fragment where the arguments are constructed.</param>
/// <param name="processInFragment">Process in fragments whose arguments are to be verified.</param>
private void VerifyMatchingArguments(PipGraph graph, TestPipGraphFragment fragmentOrigin, Process processInFragment)
{
var outputPath = processInFragment.FileOutputs.First().ToFileArtifact().Path;
var pipId = graph.TryGetProducer(FileArtifact.CreateOutputFile(RemapFragmentPath(fragmentOrigin, outputPath)));
XAssert.IsTrue(pipId.IsValid);
Process processInGraph = graph.PipTable.HydratePip(pipId, PipQueryContext.PipGraphGetProducingPip) as Process;
XAssert.IsNotNull(processInGraph);
string argumentsInFragment = processInFragment.Arguments.ToString(fragmentOrigin.Context.PathTable).ToUpperInvariant();
string argumentsInGraph = processInGraph.Arguments.ToString(Context.PathTable).ToUpperInvariant();
XAssert.AreEqual(argumentsInFragment, argumentsInGraph);
}
private PipId GetProducer(FileArtifact file)
{
var producer = PipGraph.TryGetProducer(file);
if (producer.IsValid)
{
return(producer);
}
if (m_dynamicFileProducers.TryGetValue(file, out producer))
{
return(producer);
}
return(PipId.Invalid);
}
private ObjectInfo FileArtifactInfo(FileArtifact f)
{
if (!f.IsValid)
{
return(new ObjectInfo("Invalid"));
}
return(new ObjectInfoBuilder()
.Preview(FileArtifactPreview(f))
.Prop("Path", f.Path.ToString(PathTable))
.Prop("Kind", f.IsSourceFile ? "source" : "output")
.Prop("RewriteCount", f.RewriteCount)
.Prop("FileContentInfo", () => Analyzer.TryGetFileContentInfo(f))
.Prop("Producer", () => f.IsOutputFile ? Analyzer.GetPip(PipGraph.TryGetProducer(f)) : null)
.Prop("Consumers", () => PipGraph.GetConsumingPips(f.Path))
.Build());
}
private DirectoryEntry GetEntry(DirectoryArtifact dir)
{
if (!dir.IsValid)
{
return(null);
}
var result = m_directoryEntries.GetOrAdd(dir, this, (key, _this) => _this.CreateEntry(key));
var entry = result.Item.Value;
if (!result.IsFound)
{
var pipId = PipGraph.TryGetProducer(dir);
entry.Producer = GetEntry(pipId);
}
return(entry);
}
private ObjectInfo DirectoryArtifactInfo(DirectoryArtifact d)
{
if (!d.IsValid)
{
return(new ObjectInfo("Invalid"));
}
var name = d.Path.GetName(PathTable).ToString(StringTable);
var kind = d.IsSharedOpaque ? "shared opaque" : d.IsOutputDirectory() ? "exclusive opaque" : "source";
return(new ObjectInfoBuilder()
.Preview($"{name} [{kind}]")
.Prop("Path", d.Path.ToString(PathTable))
.Prop("PartialSealId", d.PartialSealId)
.Prop("Kind", kind)
.Prop("Producer", () => d.IsOutputDirectory() ? Analyzer.GetPip(PipGraph.TryGetProducer(d)) : null)
.Prop("Consumers", PipGraph.GetConsumingPips(d))
.Prop("Members", () => d.IsOutputDirectory()
? (object)Analyzer.GetDirMembers(d)
: d.PartialSealId > 0
? PipGraph.ListSealedDirectoryContents(d).Select(f => f.Path)
: CollectionUtilities.EmptyArray <AbsolutePath>())
.Build());
}
/// <summary>
/// Verifies that the file output by a fragment exists in the resulting graph.
/// </summary>
/// <param name="graph">Resulting graph.</param>
/// <param name="fragmentOrigin">Graph fragment where the output originates.</param>
/// <param name="outputPath">Path to output file.</param>
private void VerifyProducerExists(PipGraph graph, TestPipGraphFragment fragmentOrigin, AbsolutePath outputPath)
{
var pipId = graph.TryGetProducer(FileArtifact.CreateOutputFile(RemapFragmentPath(fragmentOrigin, outputPath)));
XAssert.IsTrue(pipId.IsValid, $"Producer of '{outputPath.ToString(fragmentOrigin.Context.PathTable)}' from fragment '{fragmentOrigin.ModuleName}' could not be found in the resulting graph");
}
