/// <summary>
/// Gets the expression for an input
/// </summary>
/// <param name="depId">Id of the input artifact</param>
/// <param name="specWriter">
/// SpecWriter to receive expression string according to the language and add ImportStatement to
/// the Spec if the language is DScript.
/// </param>
/// <param name="configWriter">ConfigWriter to add a new mount if necessary</param>
/// <param name="isDirectory">returns whether the input was a directory</param>
/// <param name="isResponseFile">returns whether the input was a response file</param>
/// <returns>expression for the input dependency</returns>
private string GetInputExpression(int depId, SpecWriter specWriter, ConfigWriter configWriter,
out bool isDirectory, out bool isResponseFile)
{
Dir dir;
int producingProcess;
File f;
isResponseFile = false;
if (m_buildGraph.Directories.TryGetValue(depId, out dir))
{
isDirectory = true;
var producingSpecPath = m_buildGraph.Pips[dir.ProducerId].Spec;
return(specWriter.GetSealCopyWriteInputName(GetSealOutputName(depId), producingSpecPath));
}
if (m_buildGraph.OutputArtifactToProducingPip.TryGetValue(depId, out producingProcess))
{
isDirectory = false;
Pip p = m_buildGraph.Pips[producingProcess];
if (p is Process)
{
return(specWriter.GetProcessInputName(GetProcessOutputName(producingProcess), p.Spec, depId));
}
if (p is CopyFile || p is WriteFile)
{
if (m_buildGraph.Files.TryGetValue(depId, out f))
{
isResponseFile = f.Location.EndsWith(ResponseFileName, StringComparison.OrdinalIgnoreCase);
}
return(specWriter.GetSealCopyWriteInputName(GetProcessOutputName(producingProcess), p.Spec));
}
throw new MimicGeneratorException("Error. Pip isn't of known type");
}
if (m_buildGraph.Files.TryGetValue(depId, out f))
{
isDirectory = false;
QueueWritingInputFileIfNecessary(depId);
return(configWriter.ToRelativePathExpression(f.Location));
}
throw new MimicGeneratorException("Could not find a producer for dependency:{0}", depId);
}
private void HandleProcesses(SpecWriter writer, ConfigWriter configWriter, List <Process> processes)
{
Tuple <ProcessStats, Process>[] stats = new Tuple <ProcessStats, Process> [processes.Count];
for (int i = 0; i < processes.Count; i++)
{
stats[i] = new Tuple <ProcessStats, Process>(GetProcessStats(processes[i]), processes[i]);
}
var sortedStats = stats.OrderByDescending(s => s.Item1.ExecutionTimeMs);
// Mark the longest process in the spec so it may be used for scaling in the transformer if applicable
bool isLongest = true;
foreach (var item in sortedStats)
{
WriteMimicInvocation(item.Item2, writer, configWriter, isLongest);
isLongest = false;
}
}
/// <summary>
/// Gets an expression for an output file
/// </summary>
private string GetOutputExpression(int fileId, ConfigWriter configWriter)
{
return(configWriter.ToRelativePathExpression(m_buildGraph.Files[fileId].Location));
}
private void WriteMimicInvocation(Process process, SpecWriter writer, ConfigWriter configWriter, bool isLongestProcess)
{
// Declared inputs & seal directory dependencies
List <string> directoryDependencies = new List <string>();
List <string> fileDependencies = new List <string>();
foreach (int consumes in process.Consumes)
{
bool wasDirectory;
bool isResponseFile;
string expression = GetInputExpression(consumes, writer, configWriter, out wasDirectory, out isResponseFile);
if (wasDirectory)
{
directoryDependencies.Add(expression);
}
else if (!m_ignoreResponseFiles || !isResponseFile)
{
fileDependencies.Add(expression);
}
}
// Declared outputs
List <SpecWriter.MimicFileOutput> mimicOutputs = new List <SpecWriter.MimicFileOutput>();
foreach (var produces in process.Produces)
{
File file = m_buildGraph.Files[produces];
SpecWriter.MimicFileOutput mimicOutput = new SpecWriter.MimicFileOutput()
{
Path = GetOutputExpression(produces, configWriter),
LengthInBytes = file.GetScaledLengthInBytes(m_inputScaleFactor),
RepeatingContent = file.Hash,
FileId = produces,
};
mimicOutputs.Add(mimicOutput);
}
// Observed accesses (if applicable)
ObservedAccess[] accesses = null;
int lookupPip = -1;
if (m_buildGraph.ObservedAccesses.Count > 0)
{
lookupPip = process.OriginalPipId ?? process.PipId;
if (!m_buildGraph.ObservedAccesses.TryGetValue(lookupPip, out accesses))
{
Console.WriteLine("Warning: No observed accesses recorded for Pip Id: {0}", lookupPip);
}
}
string relativeObservedAccessPath = null;
if (accesses != null)
{
string observedAccessesPath = writer.WriteObservedAccessesFile(accesses, lookupPip);
relativeObservedAccessPath = observedAccessesPath.Replace(writer.AbsolutePath, string.Empty).TrimStart('\\');
}
writer.AddMimicInvocation(
GetProcessOutputName(process.PipId),
directoryDependencies,
fileDependencies,
mimicOutputs,
relativeObservedAccessPath,
process.Semaphores,
Math.Max(1, process.ProcessWallTimeMs),
isLongestProcess);
}
public void HandleSealDirectory(SealDirectory sealDirectory, SpecWriter writer, ConfigWriter configWriter)
{
List <string> remappedContents = new List <string>();
Dir dir = m_buildGraph.Directories[sealDirectory.Directory];
foreach (int content in dir.Contents)
{
int producingProcess;
if (m_buildGraph.OutputArtifactToProducingPip.TryGetValue(content, out producingProcess))
{
var p = m_buildGraph.Pips[producingProcess];
remappedContents.Add(writer.GetProcessInputName(GetProcessOutputName(producingProcess), p.Spec,
content));
}
else
{
remappedContents.Add(configWriter.ToRelativePathExpression(m_buildGraph.Files[content].Location));
QueueWritingInputFileIfNecessary(content);
}
}
writer.AddSealDirectory(GetSealOutputName(sealDirectory.Directory), configWriter.ToRelativePathExpression(dir.Location), remappedContents);
}
