public void PrintOptions(string indent)
{
UnsafeOptions defaultOptions = new UnsafeOptions(null);
defaultOptions.PrintOptions(indent);
defaultOptions.PrintDerivedOptions(indent);
}
/// <nodoc />
public static Xldb.UnsafeOptions ToUnsafeOptions(this UnsafeOptions unsafeOption)
{
var unsafeOpt = new Xldb.UnsafeOptions()
{
PreserveOutputsSalt = new Xldb.ContentHash()
{
Value = unsafeOption.PreserveOutputsSalt.ToString()
},
UnsafeConfiguration = new Xldb.UnsafeSandboxConfiguration()
{
PreserveOutputs = (Xldb.PreserveOutputsMode)unsafeOption.UnsafeConfiguration.PreserveOutputs,
MonitorFileAccesses = unsafeOption.UnsafeConfiguration.MonitorFileAccesses,
IgnoreZwRenameFileInformation = unsafeOption.UnsafeConfiguration.IgnoreZwRenameFileInformation,
IgnoreZwOtherFileInformation = unsafeOption.UnsafeConfiguration.IgnoreZwOtherFileInformation,
IgnoreNonCreateFileReparsePoints = unsafeOption.UnsafeConfiguration.IgnoreNonCreateFileReparsePoints,
IgnoreSetFileInformationByHandle = unsafeOption.UnsafeConfiguration.IgnoreSetFileInformationByHandle,
IgnoreReparsePoints = unsafeOption.UnsafeConfiguration.IgnoreReparsePoints,
IgnorePreloadedDlls = unsafeOption.UnsafeConfiguration.IgnorePreloadedDlls,
ExistingDirectoryProbesAsEnumerations = unsafeOption.UnsafeConfiguration.ExistingDirectoryProbesAsEnumerations,
MonitorNtCreateFile = unsafeOption.UnsafeConfiguration.MonitorNtCreateFile,
MonitorZwCreateOpenQueryFile = unsafeOption.UnsafeConfiguration.MonitorZwCreateOpenQueryFile,
SandboxKind = (Xldb.SandboxKind)unsafeOption.UnsafeConfiguration.SandboxKind,
UnexpectedFileAccessesAreErrors = unsafeOption.UnsafeConfiguration.UnexpectedFileAccessesAreErrors,
IgnoreGetFinalPathNameByHandle = unsafeOption.UnsafeConfiguration.IgnoreGetFinalPathNameByHandle,
IgnoreDynamicWritesOnAbsentProbes = unsafeOption.UnsafeConfiguration.IgnoreDynamicWritesOnAbsentProbes,
IgnoreUndeclaredAccessesUnderSharedOpaques = unsafeOption.UnsafeConfiguration.IgnoreUndeclaredAccessesUnderSharedOpaques,
}
};
if (unsafeOption.UnsafeConfiguration.DoubleWritePolicy != null)
{
unsafeOpt.UnsafeConfiguration.DoubleWritePolicy = (Xldb.DoubleWritePolicy)unsafeOption.UnsafeConfiguration.DoubleWritePolicy;
}
return(unsafeOpt);
}
public bool Initialize(ILogOptions logoptions, string[] args)
{
var newoptions = new UnsafeOptions(logoptions);
newoptions.Parse(args);
this.options.Add(newoptions);
return(!newoptions.HasErrors);
}
/// <summary>
/// Class constructor. Do not call from outside parent class.
/// </summary>
/// <param name="parent">the parent execution state containing the global information from which module specific instances can be retrieved</param>
/// <param name="moduleId">the module id of the state to create</param>
/// <param name="allowPreserveOutputs">whether preserveOutputs is allowed for the pip</param>
internal PipScopeState(PipExecutionState parent, ModuleId moduleId, bool allowPreserveOutputs)
{
if (moduleId.IsValid)
{
FileAccessWhitelist = parent.m_fileAccessWhitelist?.GetModuleWhitelist(moduleId);
Contract.Assume(parent.m_pathExpander != null, "m_pathExpander cannot be null. This is envorced by PipExecutionState's constructor");
PathExpander = parent.m_pathExpander.GetModuleExpander(moduleId);
DirectoryMembershipFingerprinterRuleSet = parent.m_directoryMembershipFingerprinterRuleSet?.GetModuleRule(moduleId);
}
else
{
FileAccessWhitelist = parent.m_fileAccessWhitelist;
PathExpander = parent.m_pathExpander;
DirectoryMembershipFingerprinterRuleSet = parent.m_directoryMembershipFingerprinterRuleSet;
}
UnsafeOptions = new UnsafeOptions(parent.m_unsafeConfiguration, allowPreserveOutputs ? parent.m_preserveOutputsSalt : UnsafeOptions.PreserveOutputsNotUsed);
}
/// <inheritdoc />
public void WriteFingerprintInputs(IFingerprinter writer)
{
using (var stream = new MemoryStream())
{
using (var buildXLWriter = new BuildXLWriter(
debug: false,
stream: stream,
leaveOpen: false,
logStats: false))
{
UnsafeOptions.Serialize(buildXLWriter);
writer.Add("SerializedUnsafeOptions", System.BitConverter.ToString(stream.ToArray()));
}
}
var thisRef = this;
writer.AddNested(ObservedPathEntryConstants.PathSet, w =>
{
foreach (var p in thisRef.PathEntries)
{
w.Add(ObservedPathEntryConstants.Path, p.Path);
if (p.Flags != ObservedPathEntryFlags.None)
{
w.Add(ObservedPathEntryConstants.Flags, p.Flags.ToString());
}
if (p.EnumeratePatternRegex != null)
{
w.Add(ObservedPathEntryConstants.EnumeratePatternRegex, p.EnumeratePatternRegex);
}
}
});
writer.AddCollection <StringId, ReadOnlyArray <StringId> >(
"ObservedAccessedFileNames",
ObservedAccessedFileNames,
(w, v) => w.Add(v));
// Observed inputs are included directly into the strong fingerprint hash computation,
// so they do not need to be serialized here
}
/// <summary>
/// Class constructor
/// </summary>
public Process(
FileArtifact executable,
AbsolutePath workingDirectory,
PipData arguments,
FileArtifact responseFile,
PipData responseFileData,
ReadOnlyArray <EnvironmentVariable> environmentVariables,
StandardInput standardInput,
FileArtifact standardOutput,
FileArtifact standardError,
AbsolutePath standardDirectory,
TimeSpan?warningTimeout,
TimeSpan?timeout,
ReadOnlyArray <FileArtifact> dependencies,
ReadOnlyArray <FileArtifactWithAttributes> outputs,
ReadOnlyArray <DirectoryArtifact> directoryDependencies,
ReadOnlyArray <DirectoryArtifact> directoryOutputs,
ReadOnlyArray <PipId> orderDependencies,
ReadOnlyArray <AbsolutePath> untrackedPaths,
ReadOnlyArray <AbsolutePath> untrackedScopes,
ReadOnlyArray <StringId> tags,
ReadOnlyArray <int> successExitCodes,
ReadOnlyArray <ProcessSemaphoreInfo> semaphores,
PipProvenance provenance,
StringId toolDescription,
ReadOnlyArray <AbsolutePath> additionalTempDirectories,
RegexDescriptor warningRegex = default,
RegexDescriptor errorRegex = default,
AbsolutePath uniqueOutputDirectory = default,
AbsolutePath tempDirectory = default,
Options options = default,
UnsafeOptions unsafeOptions = default,
bool testRetries = false,
ReadOnlyArray <int>?retryExitCodes = null,
ReadOnlyArray <PathAtom>?allowedSurvivingChildProcessNames = null,
TimeSpan?nestedProcessTerminationTimeout = null)
{
Contract.Requires(executable.IsValid);
Contract.Requires(workingDirectory.IsValid);
Contract.Requires(arguments.IsValid);
Contract.RequiresForAll(environmentVariables, environmentVariable => environmentVariable.Name.IsValid);
Contract.RequiresForAll(environmentVariables, environmentVariable => environmentVariable.Value.IsValid ^ environmentVariable.IsPassThrough);
Contract.Requires(dependencies.IsValid);
Contract.RequiresForAll(dependencies, dependency => dependency.IsValid);
Contract.Requires(directoryDependencies.IsValid);
Contract.RequiresForAll(directoryDependencies, directoryDependency => directoryDependency.IsValid);
Contract.Requires(outputs.IsValid);
Contract.RequiresForAll(outputs, output => output.IsValid);
Contract.Requires(directoryOutputs.IsValid);
Contract.RequiresForAll(outputs, output => !output.IsSourceFile);
Contract.RequiresForAll(directoryOutputs, directoryOutput => directoryOutput.IsValid);
Contract.Requires(orderDependencies.IsValid);
Contract.RequiresForAll(orderDependencies, dependency => dependency != PipId.Invalid);
Contract.Requires(untrackedPaths.IsValid);
Contract.RequiresForAll(untrackedPaths, path => path.IsValid);
Contract.Requires(untrackedScopes.IsValid);
Contract.RequiresForAll(untrackedScopes, scope => scope.IsValid);
Contract.Requires(!timeout.HasValue || timeout.Value <= MaxTimeout);
Contract.Requires(standardDirectory.IsValid || (standardOutput.IsValid && standardError.IsValid));
Contract.Requires(provenance != null);
Contract.Requires(additionalTempDirectories.IsValid);
Contract.RequiresForAll(additionalTempDirectories, path => path.IsValid);
Contract.Requires(tags.IsValid);
#if DEBUG // a little too expensive for release builds
Contract.Requires(Contract.Exists(dependencies, d => d == executable), "The executable must be declared as a dependency");
Contract.Requires(
!standardInput.IsFile || Contract.Exists(dependencies, d => d == standardInput.File),
"If provided, the standard-input artifact must be declared as a dependency");
Contract.Requires(
!standardOutput.IsValid || Contract.Exists(outputs, o => o.ToFileArtifact() == standardOutput),
"If provided, the standard-error artifact must be declared as an expected output");
Contract.Requires(
!standardError.IsValid || Contract.Exists(outputs, o => o.ToFileArtifact() == standardError),
"If provided, the standard-error artifact must be declared as an expected output");
Contract.Requires(
!responseFile.IsValid ^ responseFileData.IsValid,
"If provided, the response-file artifact must have a corresponding ResponseFileData");
Contract.Requires(outputs.Length == outputs.Distinct().Count());
Contract.Requires(directoryOutputs.Length == directoryOutputs.Distinct().Count());
Contract.Requires(dependencies.Length == dependencies.Distinct().Count());
Contract.Requires(directoryDependencies.Length == directoryDependencies.Distinct().Count());
Contract.Requires(untrackedPaths.Length == untrackedPaths.Distinct().Count());
Contract.Requires(untrackedScopes.Length == untrackedScopes.Distinct().Count());
Contract.Requires(additionalTempDirectories.Length == additionalTempDirectories.Distinct().Count());
Contract.RequiresForAll(semaphores, s => s.IsValid);
Contract.Requires(semaphores.Length == semaphores.Distinct().Count());
#endif
Provenance = provenance;
Tags = tags;
Executable = executable;
ToolDescription = toolDescription;
WorkingDirectory = workingDirectory;
Arguments = arguments;
ResponseFile = responseFile;
ResponseFileData = responseFileData;
StandardOutput = standardOutput;
StandardError = standardError;
StandardInput = standardInput;
StandardDirectory = standardDirectory;
WarningTimeout = warningTimeout;
Timeout = timeout;
// We allow any IEnumerable for these fields, but perform a copy up-front. Transformer implementations
// may be calling this constructor, and we should exhaust their computation up front (yield,
// LINQ, custom collections, etc. are all valid).
// See the remarks of RemoveDuplicateFileArtifacts for why it is used on the input / output lists.
Dependencies = dependencies;
DirectoryDependencies = directoryDependencies;
FileOutputs = outputs;
DirectoryOutputs = directoryOutputs;
OrderDependencies = orderDependencies;
UntrackedPaths = untrackedPaths;
UntrackedScopes = untrackedScopes;
EnvironmentVariables = environmentVariables;
SuccessExitCodes = successExitCodes;
RetryExitCodes = retryExitCodes ?? ReadOnlyArray <int> .Empty;
WarningRegex = warningRegex;
ErrorRegex = errorRegex;
UniqueOutputDirectory = uniqueOutputDirectory;
Semaphores = semaphores;
TempDirectory = tempDirectory;
TestRetries = testRetries;
ProcessOptions = options;
ProcessUnsafeOptions = unsafeOptions;
AdditionalTempDirectories = additionalTempDirectories;
AllowedSurvivingChildProcessNames = allowedSurvivingChildProcessNames ?? ReadOnlyArray <PathAtom> .Empty;
NestedProcessTerminationTimeout = nestedProcessTerminationTimeout;
}
