コード例 #1
0
        /// <summary>
        /// Resolves the names of each node and aggregates' dependencies, and links them together into the build graph.
        /// </summary>
        /// <param name="AggregateNameToInfo">Map of aggregate names to their info objects</param>
        /// <param name="NodeNameToInfo">Map of node names to their info objects</param>
        private static void LinkGraph(IEnumerable <AggregateNodeDefinition> AggregateNodeDefinitions, IEnumerable <BuildNodeDefinition> BuildNodeDefinitions, out List <AggregateNode> AggregateNodes, out List <BuildNode> BuildNodes)
        {
            // Create all the build nodes, and a dictionary to find them by name
            Dictionary <string, UnlinkedBuildNode> NameToBuildNode = new Dictionary <string, UnlinkedBuildNode>(StringComparer.InvariantCultureIgnoreCase);

            foreach (BuildNodeDefinition Definition in BuildNodeDefinitions)
            {
                UnlinkedBuildNode UnlinkedNode = new UnlinkedBuildNode();
                UnlinkedNode.InputDependencyNames = ParseSemicolonDelimitedList(Definition.DependsOn);
                UnlinkedNode.OrderDependencyNames = ParseSemicolonDelimitedList(Definition.RunAfter);
                UnlinkedNode.Node = Definition.CreateNode();
                NameToBuildNode.Add(Definition.Name, UnlinkedNode);
            }

            // Create all the aggregate nodes, and add them to a dictionary too
            Dictionary <string, UnlinkedAggregateNode> NameToAggregateNode = new Dictionary <string, UnlinkedAggregateNode>(StringComparer.InvariantCultureIgnoreCase);

            foreach (AggregateNodeDefinition Definition in AggregateNodeDefinitions)
            {
                UnlinkedAggregateNode UnlinkedNode = new UnlinkedAggregateNode();
                UnlinkedNode.DependencyNames = ParseSemicolonDelimitedList(Definition.DependsOn);
                UnlinkedNode.Node            = new AggregateNode(Definition);
                NameToAggregateNode.Add(Definition.Name, UnlinkedNode);
            }

            // Link the graph
            int NumErrors = 0;

            foreach (UnlinkedAggregateNode Pair in NameToAggregateNode.Values)
            {
                LinkAggregate(Pair, NameToAggregateNode, NameToBuildNode, ref NumErrors);
            }
            foreach (UnlinkedBuildNode Pair in NameToBuildNode.Values)
            {
                LinkNode(Pair, new List <UnlinkedBuildNode>(), NameToAggregateNode, NameToBuildNode, ref NumErrors);
            }
            if (NumErrors > 0)
            {
                throw new AutomationException("Failed to link graph ({0} errors).", NumErrors);
            }

            // Set the output lists
            AggregateNodes = NameToAggregateNode.Values.Select(x => x.Node).ToList();
            BuildNodes     = NameToBuildNode.Values.Select(x => x.Node).ToList();
        }
コード例 #2
0
        /// <summary>
        /// Resolves the dependencies in a build graph
        /// </summary>
        /// <param name="UnlinkedNode">The build node template and instance to link.</param>
        /// <param name="Stack">Stack of all the build nodes currently being processed. Used to detect cycles.</param>
        /// <param name="NameToAggregateNode">Mapping of aggregate node names to their template and instance.</param>
        /// <param name="NameToBuildNode">Mapping of build node names to their template and instance.</param>
        /// <param name="NumErrors">Number of errors encountered. Will be incremented for each error encountered.</param>
        private static void LinkNode(UnlinkedBuildNode UnlinkedNode, List <UnlinkedBuildNode> Stack, Dictionary <string, UnlinkedAggregateNode> NameToAggregateNode, Dictionary <string, UnlinkedBuildNode> NameToBuildNode, ref int NumErrors)
        {
            if (UnlinkedNode.Node.OrderDependencies == null)
            {
                Stack.Add(UnlinkedNode);

                int StackIdx = Stack.IndexOf(UnlinkedNode);
                if (StackIdx != Stack.Count - 1)
                {
                    // There's a cycle in the build graph. Print out the chain.
                    CommandUtils.LogError("Build graph contains a cycle ({0})", String.Join(" -> ", Stack.Skip(StackIdx).Select(x => x.Node.Name)));
                    NumErrors++;
                    UnlinkedNode.Node.OrderDependencies = new HashSet <BuildNode>();
                    UnlinkedNode.Node.InputDependencies = new HashSet <BuildNode>();
                }
                else
                {
                    // Find all the direct input dependencies
                    HashSet <BuildNode> DirectInputDependencies = new HashSet <BuildNode>();
                    foreach (string InputDependencyName in UnlinkedNode.InputDependencyNames)
                    {
                        if (!ResolveDependencies(InputDependencyName, NameToAggregateNode, NameToBuildNode, DirectInputDependencies))
                        {
                            CommandUtils.LogError("Node {0} is not in the graph. It is an input dependency of {1}.", InputDependencyName, UnlinkedNode.Node.Name);
                            NumErrors++;
                        }
                    }

                    // Find all the direct order dependencies. All the input dependencies are also order dependencies.
                    HashSet <BuildNode> DirectOrderDependencies = new HashSet <BuildNode>(DirectInputDependencies);
                    foreach (string OrderDependencyName in UnlinkedNode.OrderDependencyNames)
                    {
                        if (!ResolveDependencies(OrderDependencyName, NameToAggregateNode, NameToBuildNode, DirectOrderDependencies))
                        {
                            CommandUtils.LogError("Node {0} is not in the graph. It is an order dependency of {1}.", OrderDependencyName, UnlinkedNode.Node.Name);
                            NumErrors++;
                        }
                    }

                    // Link everything
                    foreach (BuildNode DirectOrderDependency in DirectOrderDependencies)
                    {
                        LinkNode(NameToBuildNode[DirectOrderDependency.Name], Stack, NameToAggregateNode, NameToBuildNode, ref NumErrors);
                    }

                    // Recursively include all the input dependencies
                    UnlinkedNode.Node.InputDependencies = new HashSet <BuildNode>(DirectInputDependencies);
                    foreach (BuildNode DirectInputDependency in DirectInputDependencies)
                    {
                        UnlinkedNode.Node.InputDependencies.UnionWith(DirectInputDependency.InputDependencies);
                    }

                    // Same for the order dependencies
                    UnlinkedNode.Node.OrderDependencies = new HashSet <BuildNode>(DirectOrderDependencies);
                    foreach (BuildNode DirectOrderDependency in DirectOrderDependencies)
                    {
                        UnlinkedNode.Node.OrderDependencies.UnionWith(DirectOrderDependency.OrderDependencies);
                    }
                }

                Stack.RemoveAt(Stack.Count - 1);
            }
        }