public UATTestNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InTestName, string InUATCommandLine, bool InDependsOnEditor = true, List<UnrealTargetPlatform> InDependsOnCooked = null, bool bInExposeToEC = false, float InECPriority = 0.0f) : base(InHostPlatform) { bExposeToEC = bInExposeToEC; ECPriority = InECPriority; GameProj = InGameProj; TestName = InTestName; UATCommandLine = InUATCommandLine; bool bWillCook = InUATCommandLine.IndexOf("-cook") >= 0; DependsOnEditor = InDependsOnEditor || bWillCook; if (InDependsOnCooked != null) { DependsOnCooked = InDependsOnCooked; } else { DependsOnCooked = new List<UnrealTargetPlatform>(); } if (DependsOnEditor) { AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform)); if (GameProj.GameName != bp.Branch.BaseEngineProject.GameName) { if (GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); } } } foreach (var Plat in DependsOnCooked) { AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat)); if (bWillCook && Plat != HostPlatform && Plat != GUBP.GetAltHostPlatform(HostPlatform)) { AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat)); } } if (!bp.bWide) { var Options = InGameProj.Options(HostPlatform); if (Options.bSeparateGamePromotion) { AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false)); } else { AddPseudodependency(WaitForTestShared.StaticGetFullName()); } } if (InGameProj.GameName == bp.Branch.BaseEngineProject.GameName) { ECPriority = ECPriority + 1.0f; } if (UATCommandLine.IndexOf("-RunAutomationTests", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority - 4.0f; if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority - 4.0f; } } else if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority + 2.0f; } }
public GameLabelPromotableNode(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted) : base(InGameProj.GameName, bInLabelPromoted) { GameProj = InGameProj; }
public GamePlatformMonolithicsNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddPseudodependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)); } else { AddPseudodependency(RootEditorNode.StaticGetFullName(HostPlatform)); if (TargetPlatform != HostPlatform) { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, HostPlatform)); } } if (InGameProj.Options(HostPlatform).bTestWithShared) /// compiling templates is only for testing purposes { AddPseudodependency(WaitForTestShared.StaticGetFullName()); } }
public UATTestNode(GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InTestName, string InUATCommandLine, string InAgentSharingGroup, bool InDependsOnEditor = true, List<UnrealTargetPlatform> InDependsOnCooked = null, float InECPriority = 0.0f) : base(InHostPlatform) { AgentSharingGroup = InAgentSharingGroup; ECPriority = InECPriority; GameProj = InGameProj; TestName = InTestName; UATCommandLine = InUATCommandLine; bool bWillCook = InUATCommandLine.IndexOf("-cook") >= 0; DependsOnEditor = InDependsOnEditor || bWillCook; if (InDependsOnCooked != null) { DependsOnCooked = InDependsOnCooked; } else { DependsOnCooked = new List<UnrealTargetPlatform>(); } if (DependsOnEditor) { AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform)); if (GameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName) { if (GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); } } } foreach (var Plat in DependsOnCooked) { AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat)); } AddPseudodependency(WaitForTestShared.StaticGetFullName()); // If the same test fails for the base engine, don't bother trying if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName) { if (BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TestName))) { AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, InTestName)); } else { bool bFoundACook = false; foreach (var Plat in DependsOnCooked) { var PlatTestName = "CookedGameTest_" + Plat.ToString(); if (BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, PlatTestName))) { AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, PlatTestName)); bFoundACook = true; } } if (!bFoundACook && BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, "EditorTest"))) { AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, "EditorTest")); } } } if (InGameProj.GameName == BranchConfig.Branch.BaseEngineProject.GameName) { ECPriority = ECPriority + 1.0f; } if (UATCommandLine.IndexOf("-RunAutomationTests", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority - 4.0f; if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority - 4.0f; } } else if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0) { ECPriority = ECPriority + 2.0f; } }
public GameLabelPromotableNode(GUBP.GUBPBranchConfig InBranchConfig, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted) : base(InBranchConfig, InGameProj.GameName, "", bInLabelPromoted) { GameProj = InGameProj; }
public CookNode(GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; CookPlatform = InCookPlatform; bIsMassive = false; AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform)); bool bIsShared = false; // is this the "base game" or a non code project? if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { var Options = InGameProj.Options(HostPlatform); bIsMassive = Options.bIsMassive; AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); // add an arc to prevent cooks from running until promotable is labeled if (Options.bIsPromotable) { if (!Options.bSeparateGamePromotion) { bIsShared = true; } } else if (Options.bTestWithShared) { bIsShared = true; } if (!BranchConfig.BranchOptions.bNoMonolithicDependenciesForCooks) { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform)); } } else { bIsShared = true; AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform)); } if (bIsShared) { // add an arc to prevent cooks from running until promotable is labeled AddPseudodependency(WaitForTestShared.StaticGetFullName()); AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform); // If the cook fails for the base engine, don't bother trying if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && BranchConfig.HasNode(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, CookPlatform))) { AddPseudodependency(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, CookPlatform)); } // If the base cook platform fails, don't bother trying other ones string BaseCookedPlatform = Platform.Platforms[HostPlatform].GetCookPlatform(false, false, ""); if (InGameProj.GameName == BranchConfig.Branch.BaseEngineProject.GameName && CookPlatform != BaseCookedPlatform && BranchConfig.HasNode(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, BaseCookedPlatform))) { AddPseudodependency(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, BaseCookedPlatform)); } } if(GamePlatformMonolithicsNode.IsSample(BranchConfig, GameProj)) { AddDependency(WaitToPackageSamplesNode.StaticGetFullName()); AgentSharingGroup = "SampleCooks" + StaticGetHostPlatformSuffix(HostPlatform); } }
public FormalBuildNode(GUBP.GUBPBranchConfig InBranchConfig, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InClientTargetPlatforms = null, List<UnrealTargetConfiguration> InClientConfigs = null, List<UnrealTargetPlatform> InServerTargetPlatforms = null, List<UnrealTargetConfiguration> InServerConfigs = null, bool InClientNotGame = false ) : base(InHostPlatform) { BranchConfig = InBranchConfig; GameProj = InGameProj; ClientTargetPlatforms = InClientTargetPlatforms; ServerTargetPlatforms = InServerTargetPlatforms; ClientConfigs = InClientConfigs; ServerConfigs = InServerConfigs; ClientNotGame = InClientNotGame; GameOrClient = TargetRules.TargetType.Game; if (ClientNotGame) { GameOrClient = TargetRules.TargetType.Client; } if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { bIsCode = true; } else { bIsCode = false; } // verify we actually built these var WorkingGameProject = InGameProj; if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { // this is a codeless project, use the base project WorkingGameProject = BranchConfig.Branch.BaseEngineProject; } var AllTargetPlatforms = new List<UnrealTargetPlatform>(); if (ClientTargetPlatforms != null) { if (!WorkingGameProject.Properties.Targets.ContainsKey(GameOrClient)) { throw new AutomationException("Can't make a game build for {0} because it doesn't have a {1} target.", WorkingGameProject.GameName, GameOrClient.ToString()); } foreach (var Plat in ClientTargetPlatforms) { if (!AllTargetPlatforms.Contains(Plat)) { AllTargetPlatforms.Add(Plat); } } if (ClientConfigs == null) { ClientConfigs = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development }; } foreach (var Plat in ClientTargetPlatforms) { if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(Plat)) { throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, Plat.ToString()); } foreach (var Config in ClientConfigs) { if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, Plat).Contains(Config)) { throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, Plat.ToString(), Config.ToString()); } } } } if (ServerTargetPlatforms != null) { if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Server) && ServerTargetPlatforms != null) { throw new AutomationException("Can't make a server build for {0} because it doesn't have a server target.", WorkingGameProject.GameName); } foreach (var Plat in ServerTargetPlatforms) { if (!AllTargetPlatforms.Contains(Plat)) { AllTargetPlatforms.Add(Plat); } } if (ServerConfigs == null) { ServerConfigs = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development }; } foreach (var Plat in ServerTargetPlatforms) { if (!WorkingGameProject.Properties.Targets[TargetRules.TargetType.Server].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(Plat)) { throw new AutomationException("Can't make a server build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, Plat.ToString()); } foreach (var Config in ServerConfigs) { if (!WorkingGameProject.Properties.Targets[TargetRules.TargetType.Server].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, Plat).Contains(Config)) { throw new AutomationException("Can't make a server build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, Plat.ToString(), Config.ToString()); } } } } // add dependencies for cooked and compiled foreach (var Plat in AllTargetPlatforms) { AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat)); } }
public GamePlatformCookedAndCompiledNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool bCodeProject) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; foreach (var Kind in BranchInfo.MonolithicKinds) { if (bCodeProject) { if (GameProj.Properties.Targets.ContainsKey(Kind)) { var Target = GameProj.Properties.Targets[Kind]; var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { //@todo how do we get the client target platform? string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, ""); if (Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform) != "") { CookedPlatform = Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform); } AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform)); AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform)); if(Target.Rules.GUBP_BuildWindowsXPMonolithics()) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform, true)); } } } } else { if (Kind == TargetRules.TargetType.Game) //for now, non-code projects don't do client or server. { if (bp.Branch.BaseEngineProject.Properties.Targets.ContainsKey(Kind)) { var Target = bp.Branch.BaseEngineProject.Properties.Targets[Kind]; var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { //@todo how do we get the client target platform? string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, ""); AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform)); AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)); } } } } } // put these in the right agent group, even though they aren't exposed to EC to sort right. if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { var Options = InGameProj.Options(HostPlatform); if ((Options.bIsPromotable || Options.bTestWithShared) && !Options.bSeparateGamePromotion) { AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform); } } else { AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform); } }
public WaitForGamePromotionUserInput(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted) : base(InGameProj.GameName, "", bInLabelPromoted) { GameProj = InGameProj; var Options = InGameProj.Options(UnrealTargetPlatform.Win64); bCustomWorkflow = Options.bCustomWorkflowForPromotion; }
public DDCNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; CookPlatform = InCookPlatform; bIsMassive = false; AddDependency(RootEditorNode.StaticGetFullName(HostPlatform)); if (bp.bOrthogonalizeEditorPlatforms) { if (TargetPlatform != HostPlatform && TargetPlatform != GUBP.GetAltHostPlatform(HostPlatform)) { AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, TargetPlatform)); } } bool bIsShared = false; // is this the "base game" or a non code project? if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { var Options = InGameProj.Options(HostPlatform); bIsMassive = Options.bIsMassive; AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); // add an arc to prevent DDCNode from running until promotable is labeled if (Options.bIsPromotable) { if (Options.bSeparateGamePromotion) { // AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false)); } else { bIsShared = true; } } else if (Options.bTestWithShared) { bIsShared = true; } //AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform)); } else { bIsShared = true; //AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)); } if (bIsShared) { // add an arc to prevent cooks from running until promotable is labeled //AddPseudodependency(WaitForTestShared.StaticGetFullName()); //AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform); // If the cook fails for the base engine, don't bother trying if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && bp.HasNode(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, CookPlatform))) { //AddPseudodependency(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, CookPlatform)); } // If the base cook platform fails, don't bother trying other ones string BaseCookedPlatform = Platform.Platforms[HostPlatform].GetCookPlatform(false, false, ""); if (InGameProj.GameName == bp.Branch.BaseEngineProject.GameName && CookPlatform != BaseCookedPlatform && bp.HasNode(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, BaseCookedPlatform))) { //AddPseudodependency(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, BaseCookedPlatform)); } } }
public GameAggregatePromotableNode(GUBP bp, List<UnrealTargetPlatform> InHostPlatforms, BranchInfo.BranchUProject InGameProj, bool IsSeparate) : base(InHostPlatforms, InGameProj.GameName) { GameProj = InGameProj; foreach (var HostPlatform in HostPlatforms) { AddDependency(RootEditorNode.StaticGetFullName(HostPlatform)); if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); } // add all of the platforms I use { var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, false); if (bp.bOrthogonalizeEditorPlatforms) { foreach (var Plat in Platforms) { AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat)); } } } { if (!GameProj.Options(HostPlatform).bPromoteEditorOnly) { var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, true); foreach (var Plat in Platforms) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat)); if (Plat == UnrealTargetPlatform.Win32 && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Game)) { if (GameProj.Properties.Targets[TargetRules.TargetType.Game].Rules.GUBP_BuildWindowsXPMonolithics()) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat, true)); } } } } } } }
public GamePlatformMonolithicsNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool InWithXp = false) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; WithXp = InWithXp; if (TargetPlatform == UnrealTargetPlatform.PS4) { var PS4MapFileUtil = bp.Branch.FindProgram("PS4MapFileUtil"); if(PS4MapFileUtil.Rules == null) { throw new AutomationException("PS4MapFileUtil is not is this branch, but is required to build PS4 monolithics"); } AddDependency(SingleToolsNode.StaticGetFullName(HostPlatform, PS4MapFileUtil)); } if (TargetPlatform == UnrealTargetPlatform.XboxOne) { var XboxOnePDBFileUtil = bp.Branch.FindProgram("XboxOnePDBFileUtil"); if (XboxOnePDBFileUtil.Rules == null) { throw new AutomationException("XboxOnePDBFileUtil is not is this branch, but is required to build Xbox One monolithics"); } AddDependency(SingleToolsNode.StaticGetFullName(HostPlatform, XboxOnePDBFileUtil)); } if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { if (!bp.BranchOptions.ExcludePlatformsForEditor.Contains(InHostPlatform)) { AddPseudodependency(EditorGameNode.StaticGetFullName(InHostPlatform, GameProj)); } if (bp.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform))) { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)); } } else { if (TargetPlatform != InHostPlatform && bp.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, bp.Branch.BaseEngineProject, InHostPlatform)) && !GUBP.bBuildRocket) // more errors and more performance by just starting, for example, IOS without waiting for mac { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, bp.Branch.BaseEngineProject, InHostPlatform)); } if (GUBP.bBuildRocket && InGameProj.GameName == bp.Branch.BaseEngineProject.GameName) { AgentSharingGroup = "UE4_" + InTargetPlatform + "_Mono" + StaticGetHostPlatformSuffix(InHostPlatform); // lets just start this right away AddPseudodependency(RootEditorHeadersNode.StaticGetFullName(HostPlatform)); // maybe we should start these sooner, but that rather tangles the agent groups } } if (InGameProj.Options(InHostPlatform).bTestWithShared) /// compiling templates is only for testing purposes, and we will group them to avoid saturating the farm { AddPseudodependency(WaitForTestShared.StaticGetFullName()); AgentSharingGroup = "TemplateMonolithics" + StaticGetHostPlatformSuffix(InHostPlatform); } if (GUBP.bBuildRocket) { var Target = bp.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Game]; var Configs = Target.Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, TargetPlatform); foreach (var Config in Configs) { if (HostPlatform == UnrealTargetPlatform.Win64) { if (TargetPlatform == UnrealTargetPlatform.Win32 && Config != UnrealTargetConfiguration.Shipping) { continue; } if (TargetPlatform == UnrealTargetPlatform.Win64 && Config != UnrealTargetConfiguration.Development) { continue; } if (TargetPlatform == UnrealTargetPlatform.Android && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development) { continue; } if (TargetPlatform == UnrealTargetPlatform.HTML5 && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development) { continue; } if (TargetPlatform == UnrealTargetPlatform.Linux && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development) { continue; } } else if (Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development) { continue; } Log("Building {0} for Host={1} Target={2} Config={3} for rocket. Node={4}", Target.TargetName, HostPlatform, TargetPlatform, Config, GetFullName()); } } }
public MakeFeaturePackNode(UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj) : base(InHostPlatform) { GameProj = InGameProj; AddDependency(ToolsNode.StaticGetFullName(InHostPlatform)); // for UnrealPak AgentSharingGroup = "FeaturePacks" + StaticGetHostPlatformSuffix(InHostPlatform); }
public EditorGameNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj) : base(InHostPlatform) { AgentSharingGroup = "Editor" + StaticGetHostPlatformSuffix(InHostPlatform); GameProj = InGameProj; AddDependency(RootEditorNode.StaticGetFullName(InHostPlatform)); }
public WaitForGamePromotionUserInput(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted) : base(InGameProj.GameName, bInLabelPromoted) { GameProj = InGameProj; }
public CookNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; CookPlatform = InCookPlatform; bIsMassive = false; AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform)); if (TargetPlatform != HostPlatform && TargetPlatform != GUBP.GetAltHostPlatform(HostPlatform)) { AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, TargetPlatform)); } // is this the "base game" or a non code project? if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { var Options = InGameProj.Options(HostPlatform); bIsMassive = Options.bIsMassive; AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); if (!bp.bWide || bIsMassive) { // add an arc to prevent cooks from running until promotable is labeled if (Options.bIsPromotable) { if (Options.bSeparateGamePromotion) { AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false)); } else { AddPseudodependency(WaitForTestShared.StaticGetFullName()); } } } AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform)); } else { if (!bp.bWide) { // add an arc to prevent cooks from running until promotable is labeled AddPseudodependency(WaitForTestShared.StaticGetFullName()); } AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)); } }
public GamePlatformMonolithicsNode(GUBPBranchConfig InBranchConfig, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InActivePlatforms, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool InWithXp = false, bool InPrecompiled = false) : base(InBranchConfig, InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; ActivePlatforms = InActivePlatforms; WithXp = InWithXp; Precompiled = InPrecompiled; EnhanceAgentRequirements = BranchConfig.BranchOptions.EnhanceAgentRequirements.Contains(StaticGetFullName(HostPlatform, GameProj, TargetPlatform, WithXp, Precompiled)); if (TargetPlatform == UnrealTargetPlatform.PS4 || TargetPlatform == UnrealTargetPlatform.XboxOne) { // Required for PS4MapFileUtil/XboxOnePDBFileUtil AddDependency(ToolsNode.StaticGetFullName(InHostPlatform)); } if(IsSample(BranchConfig, InGameProj)) { AddDependency(WaitToPackageSamplesNode.StaticGetFullName()); } if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { if (!BranchConfig.BranchOptions.ExcludePlatformsForEditor.Contains(InHostPlatform)) { AddPseudodependency(EditorGameNode.StaticGetFullName(InHostPlatform, GameProj)); } if (BranchConfig.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform))) { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform)); } } else { if (TargetPlatform != InHostPlatform && BranchConfig.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, BranchConfig.Branch.BaseEngineProject, InHostPlatform, Precompiled: Precompiled))) { AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, BranchConfig.Branch.BaseEngineProject, InHostPlatform, Precompiled: Precompiled)); } } if (InGameProj.Options(InHostPlatform).bTestWithShared) /// compiling templates is only for testing purposes, and we will group them to avoid saturating the farm { AddPseudodependency(WaitForTestShared.StaticGetFullName()); AgentSharingGroup = "TemplateMonolithics" + StaticGetHostPlatformSuffix(InHostPlatform); } }
public EditorGameNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj) : base(InHostPlatform) { GameProj = InGameProj; AddDependency(RootEditorNode.StaticGetFullName(InHostPlatform)); }
public GamePlatformCookedAndCompiledNode(GUBP.GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool bCodeProject) : base(InHostPlatform) { GameProj = InGameProj; TargetPlatform = InTargetPlatform; foreach (var Kind in BranchInfo.MonolithicKinds) { if (bCodeProject) { if (GameProj.Properties.Targets.ContainsKey(Kind)) { var Target = GameProj.Properties.Targets[Kind]; var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { //@todo how do we get the client target platform? string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, ""); if (Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform) != "") { CookedPlatform = Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform); } AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform)); AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform)); if(Target.Rules.GUBP_BuildWindowsXPMonolithics()) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform, true)); } } } } else { if (Kind == TargetRules.TargetType.Game) //for now, non-code projects don't do client or server. { if (BranchConfig.Branch.BaseEngineProject.Properties.Targets.ContainsKey(Kind)) { var Target = BranchConfig.Branch.BaseEngineProject.Properties.Targets[Kind]; var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { //@todo how do we get the client target platform? string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, ""); AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform)); AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform)); } } } } } }
public GameAggregateNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InAggregateName, List<string> Dependencies, bool bInExposeToEC, float InECPriority = 100.0f) : base(InHostPlatform) { GameProj = InGameProj; AggregateName = InAggregateName; bExposeToEC = bInExposeToEC; ECPriority = InECPriority; foreach (var Dep in Dependencies) { AddDependency(Dep); } }
public FormalBuildTestNode(GUBP.GUBPBranchConfig InBranchConfig, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InHostPlatform, UnrealTargetPlatform InClientTargetPlatform, UnrealTargetConfiguration InClientConfig ) : base(InHostPlatform) { BranchConfig = InBranchConfig; GameProj = InGameProj; ClientTargetPlatform = InClientTargetPlatform; ClientConfig = InClientConfig; GameOrClient = TargetRules.TargetType.Game; // verify we actually built these var WorkingGameProject = InGameProj; if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { // this is a codeless project, use the base project WorkingGameProject = BranchConfig.Branch.BaseEngineProject; } if (!WorkingGameProject.Properties.Targets.ContainsKey(GameOrClient)) { throw new AutomationException("Can't make a game build for {0} because it doesn't have a {1} target.", WorkingGameProject.GameName, GameOrClient.ToString()); } if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(ClientTargetPlatform)) { throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, ClientTargetPlatform.ToString()); } if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, ClientTargetPlatform).Contains(ClientConfig)) { throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, ClientTargetPlatform.ToString(), ClientConfig.ToString()); } AddDependency(FormalBuildNode.StaticGetFullName(GameProj, HostPlatform, new List<UnrealTargetPlatform>() { ClientTargetPlatform }, InClientConfigs: new List<UnrealTargetConfiguration>() { ClientConfig }, InClientNotGame: GameOrClient == TargetRules.TargetType.Client)); }
public GameAggregatePromotableNode(GUBP bp, List<UnrealTargetPlatform> InHostPlatforms, BranchInfo.BranchUProject InGameProj) : base(InHostPlatforms, InGameProj.GameName) { GameProj = InGameProj; foreach (var HostPlatform in HostPlatforms) { if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); } // add all of the platforms I use { var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, false); foreach (var Plat in Platforms) { AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat)); } } { var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, true); foreach (var Plat in Platforms) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat)); } } } }
public GameAggregateNode(UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InAggregateName, List<string> Dependencies) : base(InHostPlatform) { GameProj = InGameProj; AggregateName = InAggregateName; foreach (var Dep in Dependencies) { AddDependency(Dep); } }
public GameAggregatePromotableNode(GUBP.GUBPBranchConfig BranchConfig, List<UnrealTargetPlatform> InHostPlatforms, List<UnrealTargetPlatform> InActivePlatforms, BranchInfo.BranchUProject InGameProj, bool IsSeparate, bool bNoIOSOnPC) : base(InHostPlatforms, InGameProj.GameName) { GameProj = InGameProj; foreach (var HostPlatform in HostPlatforms) { AddDependency(RootEditorNode.StaticGetFullName(HostPlatform)); if(!BranchConfig.BranchOptions.PromotablesWithoutTools.Contains(GameProj.GameName)) { AddDependency(ToolsNode.StaticGetFullName(HostPlatform)); AddDependency(InternalToolsNode.StaticGetFullName(HostPlatform)); } if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor)) { AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj)); } // add all of the platforms I use { if (!GameProj.Options(HostPlatform).bPromoteEditorOnly) { var Platforms = GamePlatformMonolithicsNode.GetMonolithicPlatformsForUProject(HostPlatform, InActivePlatforms, InGameProj, true, bNoIOSOnPC); foreach (var Plat in Platforms) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat)); if (Plat == UnrealTargetPlatform.Win32 && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Game)) { if (GameProj.Properties.Targets[TargetRules.TargetType.Game].Rules.GUBP_BuildWindowsXPMonolithics()) { AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat, true)); } } } } } } }