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; }