C# GUBP类代码示例

	public override UE4Build.BuildAgenda GetAgenda(GUBP bp)
    {
        var Agenda = new UE4Build.BuildAgenda();
		Agenda.DotNetSolutions.Add("Engine/Source/Programs/UnrealDocTool/APIDocTool/APIDocTool.sln");
		Agenda.DotNetSolutions.Add("Engine/Source/Programs/UnrealDocTool/UnrealDocTool/UnrealDocTool.sln");
		return Agenda;
    }

 public override void AddNodes(GUBP bp, GUBP.GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InActivePlatforms)
 {
     /*		if(InHostPlatform == UnrealTargetPlatform.Win64 && !BranchConfig.BranchOptions.bNoDocumentation)
     {
         BranchConfig.AddNode(new ToolsForDocumentationNode(BranchConfig, InHostPlatform));
         BranchConfig.AddNode(new CodeDocumentationNode(InHostPlatform));
         BranchConfig.AddNode(new BlueprintDocumentationNode(InHostPlatform));
     }*/
 }

		public TriggerNode(GUBP bp, GUBP.WaitForUserInput InNode) : base(bp, InNode)
		{
			AddSubmittersToFailureEmails = false;

			StateName = InNode.GetTriggerStateName();
			DescriptionText = InNode.GetTriggerDescText();
			ActionText = InNode.GetTriggerActionText();
			RequiresRecursiveWorkflow = InNode.TriggerRequiresRecursiveWorkflow();
		}

 public override void AddNodes(GUBP bp, UnrealTargetPlatform InHostPlatform)
 {
     if(InHostPlatform == UnrealTargetPlatform.Win64 && !bp.BranchOptions.bNoDocumentation)
     {
         bp.AddNode(new ToolsForDocumentationNode(InHostPlatform));
         bp.AddNode(new CodeDocumentationNode(InHostPlatform));
         bp.AddNode(new BlueprintDocumentationNode(InHostPlatform));
     }
 }

 public LegacyNode(GUBP.GUBPNode InNode)
 {
     Name = InNode.GetFullName();
     Node = InNode;
     AgentRequirements = Node.ECAgentString();
     AgentSharingGroup = Node.AgentSharingGroup;
     AgentMemoryRequirement = Node.AgentMemoryRequirement();
     TimeoutInMinutes = Node.TimeoutInMinutes();
     SendSuccessEmail = Node.SendSuccessEmail();
     Priority = Node.Priority();
 }

        public BuildDerivedDataCacheNode(GUBP.GUBPBranchConfig InBranchConfig, UnrealTargetPlatform InHostPlatform, string InTargetPlatforms, string[] InProjectNames)
            : base(InHostPlatform)
        {
            BranchConfig = InBranchConfig;
            TargetPlatforms = InTargetPlatforms;
            ProjectNames = InProjectNames;
            SavedDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", HostPlatform.ToString());
            SavedManifestPath = CommandUtils.CombinePaths(SavedDir, "DerivedDataCacheManifest.txt");

            AddDependency(GUBP.RootEditorNode.StaticGetFullName(HostPlatform));
            AddDependency(GUBP.ToolsNode.StaticGetFullName(HostPlatform));
        }

        public override void DoBuild(GUBP bp)
        {
            CommandUtils.DeleteDirectoryContents(OutputDir);

            // Extract the editor headers
            CommandUtils.UnzipFiles(GUBP.RootEditorNode.StaticGetArchivedHeadersPath(HostPlatform), CommandUtils.CmdEnv.LocalRoot);

            // Extract all the headers for code target platforms
            foreach(UnrealTargetPlatform CodeTargetPlatform in CodeTargetPlatforms)
            {
                UnrealTargetPlatform SourceHostPlatform = RocketBuild.GetSourceHostPlatform(bp, HostPlatform, CodeTargetPlatform);
                string ZipFileName = GUBP.GamePlatformMonolithicsNode.StaticGetArchivedHeadersPath(SourceHostPlatform, bp.Branch.BaseEngineProject, CodeTargetPlatform);
                CommandUtils.UnzipFiles(ZipFileName, CommandUtils.CmdEnv.LocalRoot);
            }

            // Copy the depot files to the output directory
            FilterRocketNode FilterNode = (FilterRocketNode)bp.FindNode(FilterRocketNode.StaticGetFullName(HostPlatform));
            CopyManifestFilesToOutput(FilterNode.DepotManifestPath, CommandUtils.CmdEnv.LocalRoot, OutputDir);

            // Copy the stripped files to the output directory
            foreach(KeyValuePair<string, string> StrippedManifestPath in FilterNode.StrippedNodeManifestPaths)
            {
                StripRocketNode StripNode = (StripRocketNode)bp.FindNode(StrippedManifestPath.Key);
                CopyManifestFilesToOutput(StrippedManifestPath.Value, StripNode.StrippedDir, OutputDir);
            }

            // Copy the DDC to the output directory
            BuildDerivedDataCacheNode DerivedDataCacheNode = (BuildDerivedDataCacheNode)bp.FindNode(BuildDerivedDataCacheNode.StaticGetFullName(HostPlatform));
            CopyManifestFilesToOutput(DerivedDataCacheNode.SavedManifestPath, DerivedDataCacheNode.SavedDir, OutputDir);

            // Write the Rocket.txt file with the
            string RocketFile = CommandUtils.CombinePaths(OutputDir, "Engine/Build/Rocket.txt");
            CommandUtils.WriteAllText(RocketFile, "-installedengine -rocket");

            // Create a dummy build product
            BuildProducts = new List<string>();
            SaveRecordOfSuccessAndAddToBuildProducts();
        }

 static void AddRuleForBuildProducts(FileFilter Filter, GUBP bp, string NodeName, FileFilterType Type)
 {
     GUBP.GUBPNode Node = bp.FindNode(NodeName);
     if(Node == null)
     {
         throw new AutomationException("Couldn't find node '{0}'", NodeName);
     }
     Filter.AddRuleForFiles(Node.BuildProducts, CommandUtils.CmdEnv.LocalRoot, Type);
 }

        public FilterRocketNode(GUBP bp, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InTargetPlatforms, string[] InCurrentFeaturePacks, string[] InCurrentTemplates)
            : base(InHostPlatform)
        {
            TargetPlatforms = new List<UnrealTargetPlatform>(InTargetPlatforms);
            CurrentFeaturePacks = InCurrentFeaturePacks;
            CurrentTemplates = InCurrentTemplates;
            DepotManifestPath = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", HostPlatform.ToString(), "Filter.txt");

            // Add the editor
            AddDependency(GUBP.VersionFilesNode.StaticGetFullName());
            AddDependency(GUBP.ToolsForCompileNode.StaticGetFullName(HostPlatform));
            AddDependency(GUBP.RootEditorNode.StaticGetFullName(HostPlatform));
            AddDependency(GUBP.ToolsNode.StaticGetFullName(HostPlatform));

            // Add all the monolithic builds from their appropriate source host platform
            foreach(UnrealTargetPlatform TargetPlatform in TargetPlatforms)
            {
                UnrealTargetPlatform SourceHostPlatform = RocketBuild.GetSourceHostPlatform(bp, HostPlatform, TargetPlatform);
                bool bIsCodeTargetPlatform = RocketBuild.IsCodeTargetPlatform(SourceHostPlatform, TargetPlatform);
                AddDependency(GUBP.GamePlatformMonolithicsNode.StaticGetFullName(SourceHostPlatform, bp.Branch.BaseEngineProject, TargetPlatform, Precompiled: bIsCodeTargetPlatform));
            }

            // Also add stripped symbols for all the target platforms that require it
            List<string> StrippedNodeNames = new List<string>();
            foreach(UnrealTargetPlatform TargetPlatform in TargetPlatforms)
            {
                if(StripRocketNode.IsRequiredForPlatform(TargetPlatform))
                {
                    UnrealTargetPlatform SourceHostPlatform = RocketBuild.GetSourceHostPlatform(bp, HostPlatform, TargetPlatform);
                    string StripNode = StripRocketMonolithicsNode.StaticGetFullName(SourceHostPlatform, bp.Branch.BaseEngineProject, TargetPlatform, RocketBuild.IsCodeTargetPlatform(SourceHostPlatform, TargetPlatform));
                    AddDependency(StripNode);
                    StrippedNodeNames.Add(StripNode);
                }
            }

            // Add win64 tools on Mac, to get the win64 build of UBT, UAT and IPP
            if (HostPlatform == UnrealTargetPlatform.Mac && bp.HostPlatforms.Contains(UnrealTargetPlatform.Win64))
            {
                AddDependency(GUBP.ToolsNode.StaticGetFullName(UnrealTargetPlatform.Win64));
                AddDependency(GUBP.ToolsForCompileNode.StaticGetFullName(UnrealTargetPlatform.Win64));
            }

            // Add all the feature packs
            AddDependency(GUBP.MakeFeaturePacksNode.StaticGetFullName(GUBP.MakeFeaturePacksNode.GetDefaultBuildPlatform(bp)));

            // Find all the host platforms we need
            SourceHostPlatforms = TargetPlatforms.Select(x => RocketBuild.GetSourceHostPlatform(bp, HostPlatform, x)).Distinct().ToList();
            if(!SourceHostPlatforms.Contains(HostPlatform))
            {
                SourceHostPlatforms.Add(HostPlatform);
            }

            // Add the stripped host platforms
            if(StripRocketNode.IsRequiredForPlatform(HostPlatform))
            {
                AddDependency(StripRocketToolsNode.StaticGetFullName(HostPlatform));
                StrippedNodeNames.Add(StripRocketToolsNode.StaticGetFullName(HostPlatform));

                AddDependency(StripRocketEditorNode.StaticGetFullName(HostPlatform));
                StrippedNodeNames.Add(StripRocketEditorNode.StaticGetFullName(HostPlatform));
            }

            // Set all the stripped manifest paths
            foreach(string StrippedNodeName in StrippedNodeNames)
            {
                StrippedNodeManifestPaths.Add(StrippedNodeName, Path.Combine(Path.GetDirectoryName(DepotManifestPath), "Filter_" + StrippedNodeName + ".txt"));
            }
        }

        public override UE4Build.BuildAgenda GetAgenda(GUBP bp)
        {
            bool bAnyAdded = false;
            var Agenda = new UE4Build.BuildAgenda();

			if (HostPlatform == UnrealTargetPlatform.Win64)
            {
                bAnyAdded = true;
                Agenda.DotNetProjects.AddRange(
                    new string[] 
			    {
                    CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportCommon\CrashReportCommon.csproj"),
					CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportReceiver\CrashReportReceiver.csproj"),
					CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportProcess\CrashReportProcess.csproj"),
                    CombinePaths(@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj"),
			    });
                Agenda.DotNetSolutions.AddRange(
                    new string[] 
			        {
				        CombinePaths(@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln"),
			        }
                    );
                Agenda.ExtraDotNetFiles.AddRange(
                    new string[] 
			        {
				        "Interop.IWshRuntimeLibrary",
				        "UnrealMarkdown",
				        "CommonUnrealMarkdown",
			        }
                    );
            }
            string AddArgs = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice";

			foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs)
            {
                bool bInternalOnly;
                bool SeparateNode;
				bool CrossCompile;
                if (ProgramTarget.Rules.GUBP_AlwaysBuildWithTools(HostPlatform, out bInternalOnly, out SeparateNode, out CrossCompile) && ProgramTarget.Rules.SupportsPlatform(HostPlatform) && bInternalOnly && !SeparateNode)
                {
                    foreach (var Plat in ProgramTarget.Rules.GUBP_ToolPlatforms(HostPlatform))
                    {
                        foreach (var Config in ProgramTarget.Rules.GUBP_ToolConfigs(HostPlatform))
                        {
                            Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, Plat, Config, InAddArgs: AddArgs);
                            bAnyAdded = true;
                        }
                    }
                }
            }
            if (bAnyAdded)
            {
                return Agenda;
            }
            return null;
        }

        public BuildGitPromotable(GUBP bp, UnrealTargetPlatform HostPlatform, string InConfigRelativePath)
            : base(HostPlatform)
        {
            ConfigRelativePath = InConfigRelativePath;

            foreach(UnrealTargetPlatform OtherHostPlatform in bp.HostPlatforms)
            {
                AddDependency(GUBP.RootEditorNode.StaticGetFullName(OtherHostPlatform));
                AddDependency(GUBP.ToolsNode.StaticGetFullName(OtherHostPlatform));
                AddDependency(GUBP.InternalToolsNode.StaticGetFullName(OtherHostPlatform));
            }
        }

        public override void AddNodes(GUBP bp, UnrealTargetPlatform HostPlatform)
        {
            if(!bp.BranchOptions.bNoInstalledEngine)
            {
                // Find all the target platforms for this host platform.
                List<UnrealTargetPlatform> TargetPlatforms = GetTargetPlatforms(bp, HostPlatform);

                // Remove any platforms that aren't available on this machine
                TargetPlatforms.RemoveAll(x => !bp.ActivePlatforms.Contains(x));

                // Get the temp directory for stripped files for this host
                string StrippedDir = Path.GetFullPath(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", HostPlatform.ToString()));

                // Strip the host platform
                if (StripRocketNode.IsRequiredForPlatform(HostPlatform))
                {
                    bp.AddNode(new StripRocketToolsNode(HostPlatform, StrippedDir));
                    bp.AddNode(new StripRocketEditorNode(HostPlatform, StrippedDir));
                }

                // Strip all the target platforms that are built on this host
                foreach (UnrealTargetPlatform TargetPlatform in TargetPlatforms)
                {
                    if (GetSourceHostPlatform(bp, HostPlatform, TargetPlatform) == HostPlatform && StripRocketNode.IsRequiredForPlatform(TargetPlatform))
                    {
                        bp.AddNode(new StripRocketMonolithicsNode(bp, HostPlatform, TargetPlatform, StrippedDir));
                    }
                }

                // Build the DDC
                bp.AddNode(new BuildDerivedDataCacheNode(HostPlatform, GetCookPlatforms(HostPlatform, TargetPlatforms), CurrentFeaturePacks));

                // Generate a list of files that needs to be copied for each target platform
                bp.AddNode(new FilterRocketNode(bp, HostPlatform, TargetPlatforms, CurrentFeaturePacks, CurrentTemplates));

                // Copy the install to the output directory
                string LocalOutputDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "Rocket", CommandUtils.GetGenericPlatformName(HostPlatform));
                bp.AddNode(new GatherRocketNode(HostPlatform, TargetPlatforms, LocalOutputDir));

                // Add the aggregate node for the entire install
                GUBP.GUBPNode PromotableNode = bp.FindNode(GUBP.SharedAggregatePromotableNode.StaticGetFullName());
                PromotableNode.AddDependency(FilterRocketNode.StaticGetFullName(HostPlatform));
                PromotableNode.AddDependency(BuildDerivedDataCacheNode.StaticGetFullName(HostPlatform));

                // Add a node for GitHub promotions
                if(HostPlatform == UnrealTargetPlatform.Win64)
                {
                    string GitConfigRelativePath = "Engine/Build/Git/UnrealBot.ini";
                    if(CommandUtils.FileExists(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, GitConfigRelativePath)))
                    {
                        bp.AddNode(new BuildGitPromotable(bp, HostPlatform, GitConfigRelativePath));
                        PromotableNode.AddDependency(BuildGitPromotable.StaticGetFullName(HostPlatform));
                    }
                }

                // Get the output directory for the build zips
                string PublishedEngineDir;
                if(ShouldDoSeriousThingsLikeP4CheckinAndPostToMCP())
                {
                    PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.RootSharedTempStorageDirectory(), "Rocket", "Automated", GetBuildLabel(), CommandUtils.GetGenericPlatformName(HostPlatform));
                }
                else
                {
                    PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "RocketPublish", CommandUtils.GetGenericPlatformName(HostPlatform));
                }

                // Publish the install to the network
                bp.AddNode(new PublishRocketNode(HostPlatform, LocalOutputDir, PublishedEngineDir));
                bp.AddNode(new PublishRocketSymbolsNode(bp, HostPlatform, TargetPlatforms, PublishedEngineDir + "Symbols"));

                // Add a dependency on this being published as part of the shared promotable being labeled
                GUBP.SharedLabelPromotableSuccessNode LabelPromotableNode = (GUBP.SharedLabelPromotableSuccessNode)bp.FindNode(GUBP.SharedLabelPromotableSuccessNode.StaticGetFullName());
                LabelPromotableNode.AddDependency(PublishRocketNode.StaticGetFullName(HostPlatform));
                LabelPromotableNode.AddDependency(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));

                // Add dependencies on a promotable to do these steps too
                GUBP.WaitForSharedPromotionUserInput WaitForPromotionNode = (GUBP.WaitForSharedPromotionUserInput)bp.FindNode(GUBP.WaitForSharedPromotionUserInput.StaticGetFullName(true));
                WaitForPromotionNode.AddDependency(PublishRocketNode.StaticGetFullName(HostPlatform));
                WaitForPromotionNode.AddDependency(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));

                // Push everything behind the promotion triggers if we're doing things on the build machines
                if(ShouldDoSeriousThingsLikeP4CheckinAndPostToMCP() || bp.ParseParam("WithRocketPromotable"))
                {
                    string WaitForTrigger = GUBP.WaitForSharedPromotionUserInput.StaticGetFullName(false);

                    GatherRocketNode GatherRocket = (GatherRocketNode)bp.FindNode(GatherRocketNode.StaticGetFullName(HostPlatform));
                    GatherRocket.AddDependency(WaitForTrigger);

                    PublishRocketSymbolsNode PublishRocketSymbols = (PublishRocketSymbolsNode)bp.FindNode(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));
                    PublishRocketSymbols.AddDependency(WaitForTrigger);
                }
            }
        }

 public override int CISFrequencyQuantumShift(GUBP bp)
 {
     return base.CISFrequencyQuantumShift(bp) + 2;
 }

    public ToolsForDocumentationNode(GUBP.GUBPBranchConfig InBranchConfig, UnrealTargetPlatform InHostPlatform)
        : base(InBranchConfig, InHostPlatform, false)
    {
		AgentSharingGroup = "Documentation" + StaticGetHostPlatformSuffix(InHostPlatform);
    }

	public override void DoBuild(GUBP bp)
	{
		ExecuteApiDocTool("-rebuildblueprint", "APIDocTool-Blueprint");
		SubmitOutputs("Blueprint documentation", "Engine/Documentation/Builds/BlueprintAPI-*", "Engine/Documentation/CHM/BlueprintAPI.chm");
		base.DoBuild(bp);
	}