/// <summary>
/// Gets the effective environment variables, taking into account default and machine-specific values
/// </summary>
public IBuildParameters GetEffectiveEnvironmentVariables(Process pip, PipFragmentRenderer pipFragmentRenderer, int currentUserRetryCount, IReadOnlyList <string> globalUnsafePassthroughEnvironmentVariables = null)
{
Contract.Requires(pipFragmentRenderer != null);
Contract.Requires(pip != null);
Contract.Requires(currentUserRetryCount >= 0);
var trackedEnv = pip.EnvironmentVariables.Where(envVar => !envVar.IsPassThrough);
var passThroughEnvNames = pip.EnvironmentVariables.Where(envVar => envVar.IsPassThrough).Select(envVar => pipFragmentRenderer.Render(envVar.Name));
// Append any passthrough environment variables if they're specified
passThroughEnvNames = globalUnsafePassthroughEnvironmentVariables != null?passThroughEnvNames.Union(globalUnsafePassthroughEnvironmentVariables) : passThroughEnvNames;
IBuildParameters fullEnvironmentForPassThrough = OrchestratorEnvironmentVariables != null?
// We first look at the env variables from the worker,
// then if the pass through variable is unset, we look at the env variables from the orchestrator.
// That's why, if OrchestratorEnvironmentVariables is not null, it is overridden by the current environment variables.
GetFactory(ReportDuplicateVariable).PopulateFromDictionary(OrchestratorEnvironmentVariables).Override(FullEnvironmentVariables.ToDictionary()) :
FullEnvironmentVariables;
IBuildParameters effectiveVariables = m_baseEnvironmentVariables
.Override(trackedEnv.ToDictionary(
envVar => pipFragmentRenderer.Render(envVar.Name),
envVar => envVar.Value.ToString(pipFragmentRenderer)))
.Override(fullEnvironmentForPassThrough.Select(passThroughEnvNames).ToDictionary());
// If the variable to indicate the retry attempt is set, make sure it gets populated
if (pip.RetryAttemptEnvironmentVariable.IsValid)
{
effectiveVariables = effectiveVariables.Override(
new[] { new KeyValuePair <string, string>(pipFragmentRenderer.Render(pip.RetryAttemptEnvironmentVariable), currentUserRetryCount.ToString()) });
}
return(effectiveVariables);
}
/// <summary>
/// Gets the effective environment variables, taking into account default and machine-specific values
/// </summary>
public IBuildParameters GetEffectiveEnvironmentVariables(Process pip, PipFragmentRenderer pipFragmentRenderer, IReadOnlyList <string> globalUnsafePassthroughEnvironmentVariables = null)
{
Contract.Requires(pipFragmentRenderer != null);
Contract.Requires(pip != null);
Contract.Ensures(Contract.Result <IBuildParameters>() != null);
var trackedEnv = pip.EnvironmentVariables.Where(envVar => !envVar.IsPassThrough);
var passThroughEnvNames = pip.EnvironmentVariables.Where(envVar => envVar.IsPassThrough).Select(envVar => pipFragmentRenderer.Render(envVar.Name));
// Append any passthrough environment variables if they're specified
passThroughEnvNames = globalUnsafePassthroughEnvironmentVariables != null?passThroughEnvNames.Union(globalUnsafePassthroughEnvironmentVariables) : passThroughEnvNames;
IBuildParameters fullEnvironmentForPassThrough = MasterEnvironmentVariables != null?
// We first look at the env variables from the worker,
// then if the pass through variable is unset, we look at the env variables from the master.
// That's why, if MasterEnvironmentVariables is not null, it is overridden by the current environment variables.
GetFactory(ReportDuplicateVariable).PopulateFromDictionary(MasterEnvironmentVariables).Override(FullEnvironmentVariables.ToDictionary()) :
FullEnvironmentVariables;
return(m_baseEnvironmentVariables
.Override(trackedEnv.ToDictionary(
envVar => pipFragmentRenderer.Render(envVar.Name),
envVar => envVar.Value.ToString(pipFragmentRenderer)))
.Override(fullEnvironmentForPassThrough.Select(passThroughEnvNames).ToDictionary()));
}
/// <inheritdoc />
public ReturnCode PostDependency(IBuildParameters buildParameters, IDependencyData dependencyData)
{
if (PostDependencyCallback != null)
{
return(PostDependencyCallback(buildParameters, dependencyData));
}
return(ReturnCode.Success);
}
/// <inheritdoc />
public ReturnCode PostPacking(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData)
{
if (PostPackingCallback != null)
{
return(PostPackingCallback(buildParameters, dependencyData, writeData));
}
return(ReturnCode.Success);
}
/// <inheritdoc />
public ReturnCode PostWriting(IBuildParameters parameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults results)
{
if (PostWritingCallback != null)
{
return(PostWritingCallback(parameters, dependencyData, writeData, results));
}
return(ReturnCode.Success);
}
/// <inheritdoc />
public ReturnCode PostScripts(IBuildParameters parameters, IBuildResults results)
{
if (PostScriptsCallbacks != null)
{
return(PostScriptsCallbacks(parameters, results));
}
return(ReturnCode.Success);
}
/// <summary>
/// Constructor
/// </summary>
public PipEnvironment(LoggingContext loggingContext)
{
m_loggingContext = loggingContext;
FullEnvironmentVariables =
GetFactory(ReportDuplicateVariable)
.PopulateFromEnvironment();
#if PLATFORM_WIN
var comspec = Path.Combine(SpecialFolderUtilities.SystemDirectory, "cmd.exe");
var pathExt = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC";
#endif
var path =
string.Join(
OperatingSystemHelper.IsUnixOS ? ":" : ";",
SpecialFolderUtilities.SystemDirectory,
#if PLATFORM_WIN
SpecialFolderUtilities.GetFolderPath(Environment.SpecialFolder.Windows),
Path.Combine(SpecialFolderUtilities.SystemDirectory, "wbem")
#else
MacPaths.UsrBin,
MacPaths.UsrSbin,
MacPaths.Bin,
MacPaths.Sbin
#endif
);
// the environment variable names below should use the casing appropriate for the target OS
// (on Windows it won't matter, but on Unix-like systems, including Cygwin environment on Windows,
// it matters, and has to be all upper-cased). See also doc comment for IBuildParameters.Select
m_baseEnvironmentVariables = FullEnvironmentVariables
.Select(new[]
{
"NUMBER_OF_PROCESSORS",
"OS",
"PROCESSOR_ARCHITECTURE",
"PROCESSOR_IDENTIFIER",
"PROCESSOR_LEVEL",
"PROCESSOR_REVISION",
"SystemDrive",
"SystemRoot",
"SYSTEMTYPE",
})
.Override(new Dictionary <string, string>()
{
{ "PATH", path },
#if PLATFORM_WIN
{ "ComSpec", comspec },
{ "PATHEXT", pathExt }
#endif
})
.Override(DisallowedTempVariables
.Select(tmp => new KeyValuePair <string, string>(tmp, RestrictedTemp)));
}
public void DefaultBuildTasks_WriteSerializedFiles()
{
IBuildParameters buildParams = GetBuildParameters();
IDependencyData dependencyData = new BuildDependencyData();
IWriteData writeData = new BuildWriteData();
IBuildResults results = new BuildResults();
ReturnCode exitCode = RunTask <WriteSerializedFiles>(buildParams, dependencyData, writeData, results);
Assert.AreEqual(ReturnCode.Success, exitCode);
}
public string GetTargetBuildLocation(IBuildParameters buildParameters)
{
var file = buildParameters.OutputFile;
var folder = buildParameters.OutputFolder;
var artifactPath = folder.
CombinePath(buildParameters.BuildTarget.ToString()).
CombinePath(file);
buildParameters.ArtifactPath = artifactPath;
return(artifactPath);
}
public HostService(string baseDir, IEnumerable <FileModel> models, string versionName, string versionDir, int lruSize, GroupInfo groupInfo, IBuildParameters buildParameters)
{
VersionName = versionName;
VersionOutputFolder = versionDir;
GroupInfo = groupInfo;
BuildParameters = buildParameters;
// Disable LRU, when Content.get, it is possible that the value is Serialized before the modification on the content does not complete yet
//if (lruSize > 0)
//{
// _lru = LruList<ModelWithCache>.CreateSynchronized(lruSize, OnLruRemoving);
//}
LoadCore(models);
}
private static ReturnCode PostPackingForSelectiveBuild(IBuildParameters buildParams, IDependencyData dependencyData, IWriteData writeData)
{
var includedBundles = AssetbundleBuildSettings.EditorInstance.BundleSettings
.Where(setting => setting.IncludedInPlayer)
.Select(setting => setting.BundleName)
.ToList();
//quick exit
if (includedBundles == null || includedBundles.Count == 0)
{
return(ReturnCode.Success);
}
for (int i = writeData.WriteOperations.Count - 1; i >= 0; --i)
{
string bundleName;
//derive bundle name from operation
if (writeData.WriteOperations[i] is AssetBundleWriteOperation bundleOp)
{
bundleName = bundleOp.Info.bundleName;
}
else if (writeData.WriteOperations[i] is SceneBundleWriteOperation sceneBundleOp)
{
bundleName = sceneBundleOp.Info.bundleName;
}
else if (writeData.WriteOperations[i] is SceneDataWriteOperation sceneDataOp)
{
//this is the simplest way to derive bundle name from SceneDataWriteOperation
var bundleWriteData = writeData as IBundleWriteData;
bundleName = bundleWriteData.FileToBundle[sceneDataOp.Command.internalName];
}
else
{
Debug.LogError("Unexpected write operation");
return(ReturnCode.Error);
}
// if we do not want to build that bundle, remove the write operation from the list
if (includedBundles.Contains(bundleName) == false)
{
writeData.WriteOperations.RemoveAt(i);
}
}
return(ReturnCode.Success);
}
internal LocalTc(IBuildParameters buildParameters = null, ITeamCityWriterFactory teamCityWriterFactory = null, params object[] overrides)
{
var bootstrapper = new Bootstrapper(overrides);
m_BuildParameters = buildParameters ?? bootstrapper.Get <IBuildParameters>();
teamCityWriterFactory = teamCityWriterFactory ?? bootstrapper.Get <ITeamCityWriterFactory>();
m_TeamCityWriter = teamCityWriterFactory.CreateTeamCityWriter();
string changedFilesPath;
if (m_BuildParameters.TryGetBuildParameter("build.changedFiles.file", out changedFilesPath))
{
m_ChangedFiles = bootstrapper.Get <IChangedFilesParser>().ParseChangedFiles(changedFilesPath);
}
else
{
m_ChangedFiles = new List <IChangedFile>();
}
}
public void DefaultBuildTasks_PostScriptsCallbacks()
{
bool scriptsCallbackCalled = false;
IBuildParameters buildParameters = GetBuildParameters();
IBuildResults results = new BuildResults();
BuildCallbacks callback = new BuildCallbacks();
callback.PostScriptsCallbacks = (parameters, buildResults) =>
{
scriptsCallbackCalled = true;
return(ReturnCode.Success);
};
ReturnCode exitCode = RunTask <PostScriptsCallback>(buildParameters, results, callback);
Assert.AreEqual(ReturnCode.Success, exitCode);
Assert.IsTrue(scriptsCallbackCalled);
}
public void DefaultBuildTasks_PostDependencyCallback()
{
bool dependencyCallbackCalled = false;
IBuildParameters buildParameters = GetBuildParameters();
IDependencyData dep = GetDependencyData();
BuildCallbacks callback = new BuildCallbacks();
callback.PostDependencyCallback = (parameters, data) =>
{
dependencyCallbackCalled = true;
return(ReturnCode.Success);
};
ReturnCode exitCode = RunTask <PostDependencyCallback>(buildParameters, dep, callback);
Assert.AreEqual(ReturnCode.Success, exitCode);
Assert.IsTrue(dependencyCallbackCalled);
}
public void DefaultBuildTasks_PostPackingCallback()
{
bool packingCallbackCalled = false;
IBuildParameters buildParams = GetBuildParameters();
IDependencyData dep = GetDependencyData();
IBundleWriteData writeData = new BundleWriteData();
BuildCallbacks callback = new BuildCallbacks();
callback.PostPackingCallback = (parameters, data, arg3) =>
{
packingCallbackCalled = true;
return(ReturnCode.Success);
};
ReturnCode exitCode = RunTask <PostPackingCallback>(buildParams, dep, writeData, callback);
Assert.AreEqual(ReturnCode.Success, exitCode);
Assert.IsTrue(packingCallbackCalled);
}
/// <summary>
/// This callback is what remove the unwanted AssetBundle writing operation from being processed with the WriteSerializedFiles
/// and ArchiveAndCompressBundles taskes
/// </summary>
/// <param name="buildParams"></param>
/// <param name="dependencyData"></param>
/// <param name="writeData"></param>
/// <returns></returns>
private static ReturnCode PostPackingCallback(IBuildParameters buildParams, IDependencyData dependencyData, IWriteData writeData)
{
if (includedBundles != null && includedBundles.Count > 0)
{
for (int i = writeData.WriteOperations.Count - 1; i >= 0; --i)
{
// get the AssetBundle name that the writeOperation is for
AssetBundleWriteOperation op = writeData.WriteOperations[i] as AssetBundleWriteOperation;
string bundleName = null;
if (op != null)
{
bundleName = op.Info.bundleName;
}
else
{
// scene bundles are also different
if (writeData.WriteOperations[i] is SceneBundleWriteOperation s_op)
{
bundleName = s_op.Info.bundleName;
}
else
{
Debug.LogError("Unexpected write operation");
return(ReturnCode.Error);
}
}
// if we do not want to build that bundle, remove the write operation from the list
if (includedBundles.Contains(bundleName) == false)
{
writeData.WriteOperations.RemoveAt(i);
}
}
}
return(ReturnCode.Success);
}
private ReturnCode PostWriting(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults results)
{
var parameters = buildParameters as BundleBuildParameters;
return(ReturnCode.Success);
}
public void SerializeSandboxedProcessInfo(bool useNullFileStorage, bool useRootJail)
{
var pt = new PathTable();
var fam =
new FileAccessManifest(pt, CreateDirectoryTranslator())
{
FailUnexpectedFileAccesses = false,
IgnoreCodeCoverage = false,
ReportFileAccesses = false,
ReportUnexpectedFileAccesses = false,
MonitorChildProcesses = false
};
var vac = new ValidationDataCreator(fam, pt);
vac.AddScope(A("C", "Users", "AppData"), FileAccessPolicy.AllowAll);
vac.AddPath(A("C", "Source", "source.txt"), FileAccessPolicy.AllowReadAlways);
vac.AddPath(A("C", "Out", "out.txt"), FileAccessPolicy.AllowAll);
SandboxedProcessStandardFiles standardFiles = null;
ISandboxedProcessFileStorage fileStorage;
if (useNullFileStorage)
{
fileStorage = null;
}
else
{
standardFiles = new SandboxedProcessStandardFiles(A("C", "pip", "pip.out"), A("C", "pip", "pip.err"));
fileStorage = new StandardFileStorage(standardFiles);
}
var envVars = new Dictionary <string, string>()
{
["Var1"] = "Val1",
["Var2"] = "Val2",
};
IBuildParameters buildParameters = BuildParameters.GetFactory().PopulateFromDictionary(envVars);
var sidebandLogFile = A("C", "engine-cache", "sideband-logs", "log-1");
var loggerRootDirs = new[] { A("C", "out", "dir1"), A("C", "out", "dir2") };
var sharedOpaqueOutputLogger = new SidebandWriter(DefaultSidebandMetadata, sidebandLogFile, loggerRootDirs);
SandboxedProcessInfo info = new SandboxedProcessInfo(
pt,
fileStorage,
A("C", "tool", "tool.exe"),
fam,
true,
null,
LoggingContext,
sidebandWriter: sharedOpaqueOutputLogger)
{
Arguments = @"/arg1:val1 /arg2:val2",
WorkingDirectory = A("C", "Source"),
RootJailInfo = useRootJail ? (RootJailInfo?)new RootJailInfo(A("C", "RootJail"), 123, 234) : null,
EnvironmentVariables = buildParameters,
Timeout = TimeSpan.FromMinutes(15),
PipSemiStableHash = 0x12345678,
PipDescription = nameof(SerializeSandboxedProcessInfo),
TimeoutDumpDirectory = A("C", "Timeout"),
SandboxKind = global::BuildXL.Utilities.Configuration.SandboxKind.Default,
AllowedSurvivingChildProcessNames = new[] { "conhost.exe", "mspdbsrv.exe" },
NestedProcessTerminationTimeout = SandboxedProcessInfo.DefaultNestedProcessTerminationTimeout,
StandardInputSourceInfo = StandardInputInfo.CreateForData("Data"),
StandardObserverDescriptor = new SandboxObserverDescriptor()
{
WarningRegex = new ExpandedRegexDescriptor("*warn", System.Text.RegularExpressions.RegexOptions.Compiled)
},
};
// Serialize and deserialize.
SandboxedProcessInfo readInfo = null;
using (var stream = new MemoryStream())
{
info.Serialize(stream);
stream.Position = 0;
readInfo = SandboxedProcessInfo.Deserialize(
stream,
new global::BuildXL.Utilities.Instrumentation.Common.LoggingContext("Test"),
null);
}
using (readInfo.SidebandWriter)
{
// Verify.
XAssert.AreEqual(info.FileName, readInfo.FileName);
XAssert.AreEqual(info.Arguments, readInfo.Arguments);
XAssert.AreEqual(info.WorkingDirectory, readInfo.WorkingDirectory);
XAssert.AreEqual(info.RootJailInfo?.RootJail, readInfo.RootJailInfo?.RootJail);
XAssert.AreEqual(info.RootJailInfo?.UserId, readInfo.RootJailInfo?.UserId);
XAssert.AreEqual(info.RootJailInfo?.GroupId, readInfo.RootJailInfo?.GroupId);
var readEnvVars = readInfo.EnvironmentVariables.ToDictionary();
XAssert.AreEqual(envVars.Count, readEnvVars.Count);
foreach (var kvp in envVars)
{
XAssert.AreEqual(kvp.Value, readEnvVars[kvp.Key]);
}
XAssert.AreEqual(info.Timeout, readInfo.Timeout);
XAssert.AreEqual(info.PipSemiStableHash, readInfo.PipSemiStableHash);
XAssert.AreEqual(info.PipDescription, readInfo.PipDescription);
XAssert.AreEqual(info.TimeoutDumpDirectory, readInfo.TimeoutDumpDirectory);
XAssert.AreEqual(info.SandboxKind, readInfo.SandboxKind);
XAssert.AreEqual(info.AllowedSurvivingChildProcessNames.Length, readInfo.AllowedSurvivingChildProcessNames.Length);
for (int i = 0; i < info.AllowedSurvivingChildProcessNames.Length; ++i)
{
XAssert.AreEqual(info.AllowedSurvivingChildProcessNames[i], readInfo.AllowedSurvivingChildProcessNames[i]);
}
XAssert.AreEqual(info.NestedProcessTerminationTimeout, readInfo.NestedProcessTerminationTimeout);
XAssert.AreEqual(info.StandardInputSourceInfo, readInfo.StandardInputSourceInfo);
if (useNullFileStorage)
{
XAssert.IsNull(readInfo.SandboxedProcessStandardFiles);
XAssert.IsNull(readInfo.FileStorage);
}
else
{
XAssert.IsNotNull(readInfo.SandboxedProcessStandardFiles);
XAssert.AreEqual(standardFiles.StandardOutput, readInfo.SandboxedProcessStandardFiles.StandardOutput);
XAssert.AreEqual(standardFiles.StandardError, readInfo.SandboxedProcessStandardFiles.StandardError);
XAssert.AreEqual(standardFiles.StandardOutput, readInfo.FileStorage.GetFileName(SandboxedProcessFile.StandardOutput));
XAssert.AreEqual(standardFiles.StandardError, readInfo.FileStorage.GetFileName(SandboxedProcessFile.StandardError));
}
XAssert.IsFalse(readInfo.ContainerConfiguration.IsIsolationEnabled);
XAssert.AreEqual(sidebandLogFile, readInfo.SidebandWriter.SidebandLogFile);
XAssert.ArrayEqual(loggerRootDirs, readInfo.SidebandWriter.RootDirectories.ToArray());
if (!OperatingSystemHelper.IsUnixOS)
{
// this validator examines serialized FAM bytes using the same Windows-only native parser used by Detours
ValidationDataCreator.TestManifestRetrieval(vac.DataItems, readInfo.FileAccessManifest, false);
}
}
}
private static ReturnCode PostPackingForSelectiveBuild(IBuildParameters buildParams, IDependencyData dependencyData, IWriteData writeData)
{
var customBuildParams = buildParams as CustomBuildParameters;
List <string> includedBundles;
if (customBuildParams.CurrentBuildType == BuildType.Local)
{
includedBundles = customBuildParams.CurrentSettings.BundleSettings
.Where(setting => setting.IncludedInPlayer)
.Select(setting => setting.BundleName)
.ToList();
}
//if not local build, we include everything
else
{
includedBundles = customBuildParams.CurrentSettings.BundleSettings
.Select(setting => setting.BundleName)
.ToList();
}
//quick exit
if (includedBundles == null || includedBundles.Count == 0)
{
Debug.Log("Nothing to build");
return(ReturnCode.Success);
}
var bundleHashDic = new Dictionary <string, HashSet <GUID> >();
for (int i = writeData.WriteOperations.Count - 1; i >= 0; --i)
{
string bundleName;
HashSet <GUID> guidHashSet;
switch (writeData.WriteOperations[i])
{
case SceneBundleWriteOperation sceneOperation:
bundleName = sceneOperation.Info.bundleName;
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var bundleSceneInfo in sceneOperation.Info.bundleScenes)
{
guidHashSet.Add(bundleSceneInfo.asset);
}
foreach (var asset in sceneOperation.PreloadInfo.preloadObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
break;
case SceneDataWriteOperation sceneDataOperation:
var bundleWriteData = writeData as IBundleWriteData;
bundleName = bundleWriteData.FileToBundle[sceneDataOperation.Command.internalName];
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var identifier in sceneDataOperation.PreloadInfo.preloadObjects)
{
if (identifier.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(identifier.guid);
}
break;
case AssetBundleWriteOperation assetBundleOperation:
bundleName = assetBundleOperation.Info.bundleName;
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var bs in assetBundleOperation.Info.bundleAssets)
{
foreach (var asset in bs.includedObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
foreach (var asset in bs.referencedObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
}
break;
default:
Debug.LogError("Unexpected write operation");
return(ReturnCode.Error);
}
// if we do not want to build that bundle, remove the write operation from the list
if (!includedBundles.Contains(bundleName) || customBuildParams.CurrentBuildType == BuildType.Dry)
{
writeData.WriteOperations.RemoveAt(i);
}
}
//log deps file
WriteDuplicateLogFile(Application.dataPath + "/../", bundleHashDic);
return(ReturnCode.Success);
}
public EditorBuildConfiguration(IArgumentsProvider argumentsProvider, IBuildParameters parameters)
{
arguments = argumentsProvider;
buildParameters = parameters;
}
/// <nodoc />
public static SandboxedProcessInfo Deserialize(Stream stream, LoggingContext loggingContext, IDetoursEventListener detoursEventListener)
{
using (var reader = new BuildXLReader(false, stream, true))
{
string arguments = reader.ReadNullableString();
string commandLine = reader.ReadNullableString();
bool disableConHostSharing = reader.ReadBoolean();
string fileName = reader.ReadNullableString();
Encoding standardInputEncoding = reader.ReadNullable(r => r.ReadEncoding());
Encoding standardOutputEncoding = reader.ReadNullable(r => r.ReadEncoding());
Encoding standardErrorEncoding = reader.ReadNullable(r => r.ReadEncoding());
string workingDirectory = reader.ReadNullableString();
IBuildParameters buildParameters = null;
var envVars = reader.ReadNullable(r => r.ReadReadOnlyList(r2 => new KeyValuePair <string, string>(r2.ReadString(), r2.ReadString())));
if (envVars != null)
{
buildParameters = BuildParameters.GetFactory().PopulateFromDictionary(envVars.ToDictionary(kvp => kvp.Key, kvp => kvp.Value));
}
string[] allowedSurvivingChildNames = reader.ReadNullable(r => r.ReadReadOnlyList(r2 => r2.ReadString()))?.ToArray();
int maxLengthInMemory = reader.ReadInt32();
TimeSpan? timeout = reader.ReadNullableStruct(r => r.ReadTimeSpan());
TimeSpan nestedProcessTerminationTimeout = reader.ReadTimeSpan();
long pipSemiStableHash = reader.ReadInt64();
string timeoutDumpDirectory = reader.ReadNullableString();
SandboxKind sandboxKind = (SandboxKind)reader.ReadByte();
string pipDescription = reader.ReadNullableString();
SandboxedProcessStandardFiles sandboxedProcessStandardFiles = SandboxedProcessStandardFiles.Deserialize(reader);
StandardInputInfo standardInputSourceInfo = reader.ReadNullable(r => StandardInputInfo.Deserialize(r));
SandboxObserverDescriptor standardObserverDescriptor = reader.ReadNullable(r => SandboxObserverDescriptor.Deserialize(r));
FileAccessManifest fam = reader.ReadNullable(r => FileAccessManifest.Deserialize(stream));
return(new SandboxedProcessInfo(
new PathTable(),
new StandardFileStorage(sandboxedProcessStandardFiles),
fileName,
fam,
disableConHostSharing,
// TODO: serialize/deserialize container configuration.
containerConfiguration: ContainerConfiguration.DisabledIsolation,
loggingContext: loggingContext,
detoursEventListener: detoursEventListener)
{
m_arguments = arguments,
m_commandLine = commandLine,
StandardInputEncoding = standardInputEncoding,
StandardOutputEncoding = standardOutputEncoding,
StandardErrorEncoding = standardErrorEncoding,
WorkingDirectory = workingDirectory,
EnvironmentVariables = buildParameters,
AllowedSurvivingChildProcessNames = allowedSurvivingChildNames,
MaxLengthInMemory = maxLengthInMemory,
Timeout = timeout,
NestedProcessTerminationTimeout = nestedProcessTerminationTimeout,
PipSemiStableHash = pipSemiStableHash,
TimeoutDumpDirectory = timeoutDumpDirectory,
SandboxKind = sandboxKind,
PipDescription = pipDescription,
SandboxedProcessStandardFiles = sandboxedProcessStandardFiles,
StandardInputSourceInfo = standardInputSourceInfo,
StandardObserverDescriptor = standardObserverDescriptor
});
}
}
public void SerializeSandboxedProcessInfo()
{
var pt = new PathTable();
var fam =
new FileAccessManifest(pt, CreateDirectoryTranslator())
{
FailUnexpectedFileAccesses = false,
IgnoreCodeCoverage = false,
ReportFileAccesses = false,
ReportUnexpectedFileAccesses = false,
MonitorChildProcesses = false
};
var vac = new ValidationDataCreator(fam, pt);
vac.AddScope(A("C", "Users", "AppData"), FileAccessPolicy.AllowAll);
vac.AddPath(A("C", "Source", "source.txt"), FileAccessPolicy.AllowReadAlways);
vac.AddPath(A("C", "Out", "out.txt"), FileAccessPolicy.AllowAll);
var standardFiles = new SandboxedProcessStandardFiles(A("C", "pip", "pip.out"), A("C", "pip", "pip.err"));
var envVars = new Dictionary <string, string>()
{
["Var1"] = "Val1",
["Var2"] = "Val2",
};
IBuildParameters buildParameters = BuildParameters.GetFactory().PopulateFromDictionary(envVars);
SandboxedProcessInfo info = new SandboxedProcessInfo(
pt,
new StandardFileStorage(standardFiles),
A("C", "tool", "tool.exe"),
fam,
true,
null)
{
Arguments = @"/arg1:val1 /arg2:val2",
WorkingDirectory = A("C", "Source"),
EnvironmentVariables = buildParameters,
Timeout = TimeSpan.FromMinutes(15),
PipSemiStableHash = 0x12345678,
PipDescription = nameof(SerializeSandboxedProcessInfo),
ProcessIdListener = null,
TimeoutDumpDirectory = A("C", "Timeout"),
SandboxKind = global::BuildXL.Utilities.Configuration.SandboxKind.Default,
AllowedSurvivingChildProcessNames = new[] { "conhost.exe", "mspdbsrv.exe" },
NestedProcessTerminationTimeout = SandboxedProcessInfo.DefaultNestedProcessTerminationTimeout,
StandardInputSourceInfo = StandardInputInfo.CreateForData("Data"),
StandardObserverDescriptor = new SandboxObserverDescriptor()
{
WarningRegex = new ExpandedRegexDescriptor("*warn", System.Text.RegularExpressions.RegexOptions.Compiled)
},
};
// Serialize and deserialize.
SandboxedProcessInfo readInfo = null;
using (var stream = new MemoryStream())
{
info.Serialize(stream);
stream.Position = 0;
readInfo = SandboxedProcessInfo.Deserialize(
stream,
new global::BuildXL.Utilities.Instrumentation.Common.LoggingContext("Test"),
null);
}
// Verify.
XAssert.AreEqual(info.FileName, readInfo.FileName);
XAssert.AreEqual(info.Arguments, readInfo.Arguments);
XAssert.AreEqual(info.WorkingDirectory, readInfo.WorkingDirectory);
var readEnvVars = readInfo.EnvironmentVariables.ToDictionary();
XAssert.AreEqual(envVars.Count, readEnvVars.Count);
foreach (var kvp in envVars)
{
XAssert.AreEqual(kvp.Value, readEnvVars[kvp.Key]);
}
XAssert.AreEqual(info.Timeout, readInfo.Timeout);
XAssert.AreEqual(info.PipSemiStableHash, readInfo.PipSemiStableHash);
XAssert.AreEqual(info.PipDescription, readInfo.PipDescription);
XAssert.AreEqual(info.ProcessIdListener, readInfo.ProcessIdListener);
XAssert.AreEqual(info.TimeoutDumpDirectory, readInfo.TimeoutDumpDirectory);
XAssert.AreEqual(info.SandboxKind, readInfo.SandboxKind);
XAssert.AreEqual(info.AllowedSurvivingChildProcessNames.Length, readInfo.AllowedSurvivingChildProcessNames.Length);
for (int i = 0; i < info.AllowedSurvivingChildProcessNames.Length; ++i)
{
XAssert.AreEqual(info.AllowedSurvivingChildProcessNames[i], readInfo.AllowedSurvivingChildProcessNames[i]);
}
XAssert.AreEqual(info.NestedProcessTerminationTimeout, readInfo.NestedProcessTerminationTimeout);
XAssert.AreEqual(info.StandardInputSourceInfo, readInfo.StandardInputSourceInfo);
XAssert.IsNotNull(readInfo.SandboxedProcessStandardFiles);
XAssert.AreEqual(standardFiles.StandardOutput, readInfo.SandboxedProcessStandardFiles.StandardOutput);
XAssert.AreEqual(standardFiles.StandardError, readInfo.SandboxedProcessStandardFiles.StandardError);
XAssert.AreEqual(standardFiles.StandardOutput, readInfo.FileStorage.GetFileName(SandboxedProcessFile.StandardOutput));
XAssert.AreEqual(standardFiles.StandardError, readInfo.FileStorage.GetFileName(SandboxedProcessFile.StandardError));
XAssert.IsFalse(readInfo.ContainerConfiguration.IsIsolationEnabled);
ValidationDataCreator.TestManifestRetrieval(vac.DataItems, readInfo.FileAccessManifest, false);
}
private static ReturnCode PostPackingForSelectiveBuild(IBuildParameters buildParams, IDependencyData dependencyData, IWriteData writeData)
{
var customBuildParams = buildParams as CustomBuildParameters;
var depsDic = customBuildParams.DependencyDic;
List <string> includedBundles;
if (customBuildParams.CurrentBuildType == BuildType.Local)
{
//deps includes every local dependencies recursively
includedBundles = customBuildParams.CurrentSettings.BundleSettings
.Where(setting => setting.IncludedInPlayer)
.Select(setting => setting.BundleName)
.SelectMany(bundleName => Utility.CollectBundleDependencies(depsDic, bundleName, true))
.Distinct()
.ToList();
}
//if not local build, we include everything
else
{
includedBundles = depsDic.Keys.ToList();
}
//quick exit
if (includedBundles == null || includedBundles.Count == 0)
{
Debug.Log("Nothing to build");
writeData.WriteOperations.Clear();
return(ReturnCode.Success);
}
for (int i = writeData.WriteOperations.Count - 1; i >= 0; --i)
{
string bundleName;
switch (writeData.WriteOperations[i])
{
case SceneBundleWriteOperation sceneOperation:
bundleName = sceneOperation.Info.bundleName;
break;
case SceneDataWriteOperation sceneDataOperation:
var bundleWriteData = writeData as IBundleWriteData;
bundleName = bundleWriteData.FileToBundle[sceneDataOperation.Command.internalName];
break;
case AssetBundleWriteOperation assetBundleOperation:
bundleName = assetBundleOperation.Info.bundleName;
break;
default:
Debug.LogError("Unexpected write operation");
return(ReturnCode.Error);
}
// if we do not want to build that bundle, remove the write operation from the list
if (!includedBundles.Contains(bundleName))
{
writeData.WriteOperations.RemoveAt(i);
}
}
return(ReturnCode.Success);
}
private static ReturnCode PostPackingForSelectiveBuild(IBuildParameters buildParams, IDependencyData dependencyData, IWriteData writeData)
{
List <string> includedBundles;
if (s_CurrentBuildType == BuildType.Local)
{
includedBundles = s_CurrentBuildingSettings.BundleSettings
.Where(setting => setting.IncludedInPlayer)
.Select(setting => setting.BundleName)
.ToList();
}
//if not local build, we include everything
else
{
includedBundles = s_CurrentBuildingSettings.BundleSettings
.Select(setting => setting.BundleName)
.ToList();
}
//quick exit
if (includedBundles == null || includedBundles.Count == 0)
{
Debug.Log("Nothing to build");
return(ReturnCode.Success);
}
var sb = new System.Text.StringBuilder();
sb.AppendLine($"Build Time : {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
sb.AppendLine();
var bundleHashDic = new Dictionary <string, HashSet <GUID> >();
for (int i = writeData.WriteOperations.Count - 1; i >= 0; --i)
{
string bundleName;
HashSet <GUID> guidHashSet;
switch (writeData.WriteOperations[i])
{
case SceneBundleWriteOperation sceneOperation:
bundleName = sceneOperation.Info.bundleName;
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var bundleSceneInfo in sceneOperation.Info.bundleScenes)
{
guidHashSet.Add(bundleSceneInfo.asset);
}
foreach (var asset in sceneOperation.PreloadInfo.preloadObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
break;
case SceneDataWriteOperation sceneDataOperation:
var bundleWriteData = writeData as IBundleWriteData;
bundleName = bundleWriteData.FileToBundle[sceneDataOperation.Command.internalName];
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var identifier in sceneDataOperation.PreloadInfo.preloadObjects)
{
if (identifier.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(identifier.guid);
}
break;
case AssetBundleWriteOperation assetBundleOperation:
bundleName = assetBundleOperation.Info.bundleName;
if (!bundleHashDic.TryGetValue(bundleName, out guidHashSet))
{
guidHashSet = new HashSet <GUID>();
bundleHashDic.Add(bundleName, guidHashSet);
}
foreach (var bs in assetBundleOperation.Info.bundleAssets)
{
foreach (var asset in bs.includedObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
foreach (var asset in bs.referencedObjects)
{
if (asset.fileType == UnityEditor.Build.Content.FileType.NonAssetType)
{
continue;
}
guidHashSet.Add(asset.guid);
}
}
break;
default:
Debug.LogError("Unexpected write operation");
return(ReturnCode.Error);
}
// if we do not want to build that bundle, remove the write operation from the list
if (!includedBundles.Contains(bundleName) || s_CurrentBuildType == BuildType.Dry)
{
writeData.WriteOperations.RemoveAt(i);
}
}
foreach (var kv in bundleHashDic)
{
sb.AppendLine($"----File Path : {kv.Key}----");
foreach (var guid in kv.Value)
{
sb.AppendLine($"{(GetCompressedFileSize(guid.ToString()) * 0.000001f).ToString("0.00000").PadLeft(10)} mb - {AssetDatabase.GUIDToAssetPath(guid.ToString())}");
}
sb.AppendLine();
}
var path = Application.dataPath + "/../";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
File.WriteAllText(Path.Combine(path, LogDependencyName), sb.ToString());
return(ReturnCode.Success);
}
internal LocalTc(IBuildParameters buildParameters, ITeamCityWriterFactory teamCityWriterFactory)
{
m_BuildParameters = buildParameters;
m_TeamCityWriter = teamCityWriterFactory.CreateTeamCityWriter();
}
