C# GUBP.FindNode方法代码示例

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

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

        public StripRocketMonolithicsNode(GUBP bp, UnrealTargetPlatform InHostPlatform, UnrealTargetPlatform InTargetPlatform, string InStrippedDir)
            : base(InHostPlatform, InTargetPlatform, InStrippedDir)
        {
            Project = bp.Branch.BaseEngineProject;
            bIsCodeTargetPlatform = RocketBuild.IsCodeTargetPlatform(InHostPlatform, InTargetPlatform);

            GUBP.GUBPNode Node = bp.FindNode(GUBP.GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, Project, InTargetPlatform, Precompiled: bIsCodeTargetPlatform));
            if(String.IsNullOrEmpty(Node.AgentSharingGroup))
            {
                Node.AgentSharingGroup = bp.Branch.BaseEngineProject.GameName + "_MonolithicsGroup_" + InTargetPlatform + StaticGetHostPlatformSuffix(InHostPlatform);
            }
            AddNodeToStrip(Node.GetFullName());

            AgentSharingGroup = Node.AgentSharingGroup;
        }

 public CleanSharedTempStorageNode(GUBP bp)
 {
     var ToolsNode = bp.FindNode(ToolsForCompileNode.StaticGetFullName(UnrealTargetPlatform.Win64));
     AgentSharingGroup = ToolsNode.AgentSharingGroup;
 }

		public SignRocketMonolithicsNode(GUBP.GUBPBranchConfig InBranchConfig, UnrealTargetPlatform InHostPlatform, UnrealTargetPlatform InTargetPlatform, string InSignedDir)
			: base(InBranchConfig, InHostPlatform, InTargetPlatform, InSignedDir)
		{
			Project = InBranchConfig.Branch.BaseEngineProject;
			bIsCodeTargetPlatform = RocketBuild.IsCodeTargetPlatform(InHostPlatform, InTargetPlatform);

			GUBP.GUBPNode Node = InBranchConfig.FindNode(GUBP.GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, Project, InTargetPlatform, Precompiled: bIsCodeTargetPlatform));
			if (String.IsNullOrEmpty(Node.AgentSharingGroup))
			{
				Node.AgentSharingGroup = BranchConfig.Branch.BaseEngineProject.GameName + "_MonolithicsGroup_" + InTargetPlatform + StaticGetHostPlatformSuffix(InHostPlatform);
			}
			AddNodeToSign(Node.GetFullName());
			string StripNode = StripRocketMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform, RocketBuild.IsCodeTargetPlatform(HostPlatform, TargetPlatform));
			AddDependency(StripNode);

			AgentSharingGroup = Node.AgentSharingGroup;
		}