/// <summary>
/// Augments the processBuilder with the OS dependencies
/// </summary>
public bool ProcessDefaults(ProcessBuilder processBuilder)
{
if ((processBuilder.Options & Process.Options.DependsOnCurrentOs) != 0)
{
var defaultSourceSealDirs = m_lazySourceSealDirectories.Value;
if (!defaultSourceSealDirs.IsValid)
{
return(false);
}
foreach (var inputDirectory in defaultSourceSealDirs.Directories)
{
processBuilder.AddInputDirectory(inputDirectory);
}
foreach (var untrackedFile in m_untrackedFiles)
{
processBuilder.AddUntrackedFile(untrackedFile);
}
foreach (var untrackedDirectory in m_untrackedDirectories)
{
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
return(true);
}
private void ProcessOutputs(RushProject project, ProcessBuilder processBuilder)
{
// HACK HACK. We are missing output dirs with exclusions, so we don't include node_modules here, which is a pain for scrubbing.
// So let's add known common directories one by one
// Ideally we'd like to say 'the root of the project without node_modules'. No projects are supposed to write there.
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder.Combine(PathTable, "lib")), SealDirectoryKind.SharedOpaque);
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder.Combine(PathTable, "temp")), SealDirectoryKind.SharedOpaque);
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder.Combine(PathTable, "dist")), SealDirectoryKind.SharedOpaque);
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder.Combine(PathTable, "release")), SealDirectoryKind.SharedOpaque);
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder.Combine(PathTable, "src")), SealDirectoryKind.SharedOpaque);
// HACK HACK. Only non-test projects generate these files at the root of the project. So don't add them twice otherwise graph construction complains
if (!project.Name.EndsWith("_test"))
{
processBuilder.AddOutputFile(new FileArtifact(project.ProjectFolder.Combine(PathTable, "test-api.js"), 0), FileExistence.Optional);
processBuilder.AddOutputFile(new FileArtifact(project.ProjectFolder.Combine(PathTable, "test-api.d.ts"), 0), FileExistence.Optional);
}
// Some projects share their temp folder. So don't declare this as a temp location. Anyway, rush makes sure the right files are deleted
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(project.TempFolder));
// Add all the additional output directories that the rush graph knows about
foreach (var additionalOutput in project.AdditionalOutputDirectories)
{
processBuilder.AddOutputDirectory(DirectoryArtifact.CreateWithZeroPartialSealId(additionalOutput), SealDirectoryKind.SharedOpaque);
}
// Add additional output directories configured in the main config file
AddAdditionalOutputDirectories(processBuilder, project.ProjectFolder);
}
/// <summary>
/// Some Windows Special Folders cannot be retrieved based on the state of the user profile. Only add them
/// if they were successfull retrieved.
/// </summary>
private void AddUntrackedScopeIfValid(DirectoryArtifact directoryArtifact, ProcessBuilder processBuilder)
{
if (directoryArtifact.IsValid)
{
processBuilder.AddUntrackedDirectoryScope(directoryArtifact);
}
}
/// <summary>
/// Augments the processBuilder with the OS dependencies
/// </summary>
public void ProcessDefaults(ProcessBuilder processBuilder)
{
if ((processBuilder.Options & Process.Options.DependsOnCurrentOs) != 0)
{
foreach (var inputFile in m_inputFiles)
{
processBuilder.AddInputFile(inputFile);
}
foreach (var inputDirectory in m_inputDirectories)
{
processBuilder.AddInputDirectory(inputDirectory);
}
foreach (var untrackedFile in m_untrackedFiles)
{
processBuilder.AddUntrackedFile(untrackedFile);
}
foreach (var untrackedDirectory in m_untrackedDirectories)
{
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
}
/// <summary>
/// Configures the process builder to execute the specified commands
/// </summary>
protected virtual void ConfigureProcessBuilder(
ProcessBuilder processBuilder,
JavaScriptProject project)
{
SetCmdTool(processBuilder, project);
// Working directory - the directory where the project file lives.
processBuilder.WorkingDirectory = DirectoryArtifact.CreateWithZeroPartialSealId(project.ProjectFolder);
// We allow undeclared inputs to be read
processBuilder.Options |= Process.Options.AllowUndeclaredSourceReads;
// We want to enforce the use of weak fingerprint augmentation since input predictions could be not complete/sufficient
// to avoid a large number of path sets
processBuilder.Options |= Process.Options.EnforceWeakFingerprintAugmentation;
// Try to preserve path set casing since many JavaScript projects deal with paths in a case-sensitive way
// Otherwise in Windows we force path sets to be all uppercase
processBuilder.Options |= Process.Options.PreservePathSetCasing;
// By default the double write policy is to allow same content double writes.
processBuilder.DoubleWritePolicy |= DoubleWritePolicy.AllowSameContentDoubleWrites;
// Untrack the user profile. The corresponding mount is already configured for not tracking source files, and with allowed undeclared source reads,
// any attempt to read into the user profile will fail to compute its corresponding hash
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(PathTable, SpecialFolderUtilities.GetFolderPath(Environment.SpecialFolder.UserProfile)));
// Add the associated build script name as a tag, so filtering on 'build' or 'test' can happen
processBuilder.Tags = ReadOnlyArray <StringId> .FromWithoutCopy(new[] { StringId.Create(m_context.StringTable, project.ScriptCommandName) });
PipConstructionUtilities.UntrackUserConfigurableArtifacts(processBuilder, m_resolverSettings);
var logDirectory = GetLogDirectory(project);
processBuilder.SetStandardOutputFile(logDirectory.Combine(m_context.PathTable, "build.log"));
processBuilder.SetStandardErrorFile(logDirectory.Combine(m_context.PathTable, "error.log"));
using (processBuilder.ArgumentsBuilder.StartFragment(PipDataFragmentEscaping.CRuntimeArgumentRules, " "))
{
processBuilder.ArgumentsBuilder.Add(PipDataAtom.FromString("/C"));
using (processBuilder.ArgumentsBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, " "))
{
// Execute the command and redirect the output to a designated log file
processBuilder.ArgumentsBuilder.Add(PipDataAtom.FromString(project.ScriptCommand));
// If we need to append arguments to the script command, do it here
if (m_customCommands.TryGetValue(project.ScriptCommandName, out IReadOnlyList <JavaScriptArgument> extraArguments))
{
foreach (JavaScriptArgument value in extraArguments)
{
AddJavaScriptArgumentToBuilder(processBuilder.ArgumentsBuilder, value);
}
}
}
}
FrontEndUtilities.SetProcessEnvironmentVariables(CreateEnvironment(project), m_userDefinedPassthroughVariables, processBuilder, m_context.PathTable);
}
/// <summary>
/// Augments the processBuilder with the OS dependencies.
/// </summary>
/// <param name="processBuilder">builder to use</param>
/// <param name="untrackInsteadSourceSeal">when true, directories that are meant to be source sealed are untracked instead</param>
public bool ProcessDefaults(ProcessBuilder processBuilder, bool untrackInsteadSourceSeal = false)
{
if (processBuilder.Options.HasFlag(Process.Options.DependsOnCurrentOs))
{
// process source seal directories: either source seal them or untrack them, depending on 'untrackInsteadSourceSeal'
if (untrackInsteadSourceSeal)
{
foreach (var sourceSealDirPath in m_sourceSealDirectoryPaths)
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(sourceSealDirPath));
}
}
else
{
var defaultSourceSealDirs = m_lazySourceSealDirectories.Value;
if (!defaultSourceSealDirs.IsValid)
{
return(false);
}
foreach (var inputDirectory in defaultSourceSealDirs.Directories)
{
processBuilder.AddInputDirectory(inputDirectory);
}
}
// add untracked files
foreach (var untrackedFile in m_untrackedFiles)
{
processBuilder.AddUntrackedFile(untrackedFile);
}
// add untracked directories
foreach (var untrackedDirectory in m_untrackedDirectories)
{
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
return(true);
}
/// <summary>
/// Augments the processBuilder with the OS dependencies
/// </summary>
public void ProcessDefaults(ProcessBuilder processBuilder)
{
if ((processBuilder.Options & Process.Options.DependsOnCurrentOs) != 0)
{
foreach (var untrackedDirectory in m_untrackedDirectories)
{
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
if ((processBuilder.Options & Process.Options.DependsOnWindowsAppData) != 0)
{
processBuilder.AddUntrackedDirectoryScope(m_applicationDataPath);
processBuilder.AddUntrackedDirectoryScope(m_localApplicationDataPath);
}
if ((processBuilder.Options & Process.Options.DependsOnWindowsProgramData) != 0)
{
processBuilder.AddUntrackedDirectoryScope(m_commonApplicationDataPath);
}
}
/// <summary>
/// Some FrontEnds allow configurable untracking of files, directories and directory scopes
/// This method applies that configuration to the process builder
/// </summary>
public static void UntrackUserConfigurableArtifacts(ProcessBuilder processBuilder, IUntrackingSettings settings)
{
Contract.Assert(settings != null);
if (settings.UntrackedDirectoryScopes != null)
{
foreach (var untrackedDirectoryScope in settings.UntrackedDirectoryScopes)
{
if (!untrackedDirectoryScope.IsValid)
{
continue;
}
processBuilder.AddUntrackedDirectoryScope(untrackedDirectoryScope);
}
}
if (settings.UntrackedDirectories != null)
{
foreach (var untrackedDirectory in settings.UntrackedDirectories)
{
if (!untrackedDirectory.IsValid)
{
continue;
}
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
if (settings.UntrackedFiles != null)
{
foreach (var untrackedFile in settings.UntrackedFiles)
{
if (!untrackedFile.IsValid)
{
continue;
}
processBuilder.AddUntrackedFile(untrackedFile);
}
}
}
/// <inheritdoc/>
protected override void ConfigureProcessBuilder(
ProcessBuilder processBuilder,
JavaScriptProject project)
{
base.ConfigureProcessBuilder(processBuilder, project);
// If dependencies are tracked with the shrinkwrap-deps file, then untrack everything under the Rush common temp folder, where all package
// dependencies are placed
if (m_resolverSettings.TrackDependenciesWithShrinkwrapDepsFile == true)
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(m_rushConfiguration.CommonTempFolder));
}
}
private void SetUntrackedFilesAndDirectories(ProcessBuilder processBuilder)
{
// On some machines, the current user and public user desktop.ini are read by Powershell.exe.
// Ignore accesses to the user profile and Public common user profile.
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(PathTable, SpecialFolderUtilities.GetFolderPath(Environment.SpecialFolder.UserProfile)));
if (Engine.TryGetBuildParameter("PUBLIC", m_frontEndName, out string publicDir))
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(PathTable, publicDir)));
}
PipConstructionUtilities.UntrackUserConfigurableArtifacts(processBuilder, m_resolverSettings);
// Git accesses should be ignored if .git directory is there
var gitDirectory = Root.Combine(PathTable, ".git");
if (Engine.DirectoryExists(gitDirectory))
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(gitDirectory));
processBuilder.AddUntrackedFile(FileArtifact.CreateSourceFile(Root.Combine(PathTable, ".gitattributes")));
processBuilder.AddUntrackedFile(FileArtifact.CreateSourceFile(Root.Combine(PathTable, ".gitignore")));
}
}
protected void AddUntrackedWindowsDirectories(ProcessBuilder processBuilder)
{
if (OperatingSystemHelper.IsUnixOS)
{
processBuilder.EnableTempDirectory();
foreach (var dir in new[] { Private, SystemLibrary, Usr, Dev, Var, AppleInternal, Bin, Etc, Proc, TmpDir })
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(Context.PathTable, dir));
}
string userTextEncodingFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".CFUserTextEncoding");
processBuilder.AddUntrackedFile(AbsolutePath.Create(Context.PathTable, userTextEncodingFile));
}
else
{
processBuilder.AddUntrackedWindowsDirectories();
}
}
private void UntrackFilesAndDirectories(ProcessBuilder processBuilder)
{
processBuilder.AddUntrackedWindowsDirectories();
processBuilder.AddUntrackedProgramDataDirectories();
processBuilder.AddUntrackedAppDataDirectories();
if (m_untrackingSettings != null)
{
PipConstructionUtilities.UntrackUserConfigurableArtifacts(processBuilder, m_untrackingSettings);
}
var programFilesDirectoryArtifact = DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(m_context.PathTable, Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)));
var programFilesX86DirectoryArtifact = DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(m_context.PathTable, Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86)));
processBuilder.AddUntrackedDirectoryScope(programFilesDirectoryArtifact);
processBuilder.AddUntrackedDirectoryScope(programFilesX86DirectoryArtifact);
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(m_context.PathTable, @"C:\PROGRA~1\"))); // TODO: This but better
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(m_context.PathTable, @"C:\PROGRA~2\"))); // TODO: This but better
// TODO: This is just here because the cloud build requires manually dropping the necessary executables and libraries, and should be removed
// when that issue is resolved.
string toolsDir = m_manuallyDroppedDependenciesPath.Value.ToString(m_context.PathTable);
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(AbsolutePath.Create(m_context.PathTable, toolsDir)));
// Git accesses should be ignored if .git directory is there
var gitDirectory = m_projectRoot.Combine(m_context.PathTable, ".git");
if (m_frontEndHost.Engine.DirectoryExists(gitDirectory))
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(gitDirectory));
processBuilder.AddUntrackedFile(FileArtifact.CreateSourceFile(m_projectRoot.Combine(m_context.PathTable, ".gitattributes")));
processBuilder.AddUntrackedFile(FileArtifact.CreateSourceFile(m_projectRoot.Combine(m_context.PathTable, ".gitignore")));
}
}
/// <summary>
/// Some FrontEnds allow configurable untracking of files, directories and directory scopes
/// This method applies that configuration to the process builder
/// </summary>
public static void UntrackUserConfigurableArtifacts(PathTable pathTable, AbsolutePath currentProjectRoot, IEnumerable <AbsolutePath> allProjectRoots, ProcessBuilder processBuilder, IUntrackingSettings settings)
{
Contract.AssertNotNull(settings);
Contract.Assert(currentProjectRoot.IsValid);
Contract.AssertNotNull(allProjectRoots);
Contract.AssertNotNull(processBuilder);
Contract.AssertNotNull(settings);
if (settings.UntrackedDirectoryScopes != null)
{
foreach (var untrackedDirectoryScopeUnion in settings.UntrackedDirectoryScopes)
{
DirectoryArtifact untrackedDirectoryScope = ResolveAbsoluteOrRelativeDirectory(pathTable, untrackedDirectoryScopeUnion, currentProjectRoot);
if (!untrackedDirectoryScope.IsValid)
{
continue;
}
processBuilder.AddUntrackedDirectoryScope(untrackedDirectoryScope);
}
}
if (settings.UntrackedDirectories != null)
{
foreach (var untrackedDirectoryUnion in settings.UntrackedDirectories)
{
DirectoryArtifact untrackedDirectory = ResolveAbsoluteOrRelativeDirectory(pathTable, untrackedDirectoryUnion, currentProjectRoot);
if (!untrackedDirectory.IsValid)
{
continue;
}
processBuilder.AddUntrackedDirectoryScope(untrackedDirectory);
}
}
if (settings.UntrackedFiles != null)
{
foreach (var untrackedFile in settings.UntrackedFiles)
{
if (!untrackedFile.IsValid)
{
continue;
}
processBuilder.AddUntrackedFile(untrackedFile);
}
}
if (settings.UntrackedGlobalDirectoryScopes != null)
{
foreach (var relativeDirectory in settings.UntrackedGlobalDirectoryScopes)
{
if (!relativeDirectory.IsValid)
{
continue;
}
foreach (var projectRoot in allProjectRoots)
{
processBuilder.AddUntrackedDirectoryScope(DirectoryArtifact.CreateWithZeroPartialSealId(projectRoot.Combine(pathTable, relativeDirectory)));
}
}
}
if (settings.ChildProcessesToBreakawayFromSandbox != null)
{
processBuilder.ChildProcessesToBreakawayFromSandbox = settings.ChildProcessesToBreakawayFromSandbox.Where(processName => processName.IsValid).ToReadOnlyArray();
}
}
