/// <returns>True if the operation was successful</returns> internal static bool ExecuteTargets ( List <ITaskItem> projects, Dictionary <string, string> propertiesTable, string[] undefineProperties, List <string[]> targetLists, bool stopOnFirstFailure, bool rebaseOutputs, IBuildEngine3 buildEngine, TaskLoggingHelper log, List <ITaskItem> targetOutputs, bool unloadProjectsOnCompletion, string toolsVersion ) { bool success = true; // We don't log a message about the project and targets we're going to // build, because it'll all be in the immediately subsequent ProjectStarted event. var projectDirectory = new string[projects.Count]; var projectNames = new string[projects.Count]; var toolsVersions = new string[projects.Count]; var projectProperties = new Dictionary <string, string> [projects.Count]; var undefinePropertiesPerProject = new IList <string> [projects.Count]; for (int i = 0; i < projectNames.Length; i++) { projectNames[i] = null; projectProperties[i] = propertiesTable; if (projects[i] != null) { // Retrieve projectDirectory only the first time. It never changes anyway. string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); projectDirectory[i] = Path.GetDirectoryName(projectPath); projectNames[i] = projects[i].ItemSpec; toolsVersions[i] = toolsVersion; // If the user specified a different set of global properties for this project, then // parse the string containing the properties if (!String.IsNullOrEmpty(projects[i].GetMetadata("Properties"))) { if (!PropertyParser.GetTableWithEscaping (log, ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("General.OverridingProperties", projectNames[i]), "Properties", projects[i].GetMetadata("Properties").Split(';'), out Dictionary <string, string> preProjectPropertiesTable) ) { return(false); } projectProperties[i] = preProjectPropertiesTable; } if (undefineProperties != null) { undefinePropertiesPerProject[i] = new List <string>(undefineProperties); } // If the user wanted to undefine specific global properties for this project, parse // that string and remove them now. string projectUndefineProperties = projects[i].GetMetadata("UndefineProperties"); if (!String.IsNullOrEmpty(projectUndefineProperties)) { string[] propertiesToUndefine = projectUndefineProperties.Split(';'); if (undefinePropertiesPerProject[i] == null) { undefinePropertiesPerProject[i] = new List <string>(propertiesToUndefine.Length); } if (log != null && propertiesToUndefine.Length > 0) { log.LogMessageFromResources(MessageImportance.Low, "General.ProjectUndefineProperties", projectNames[i]); foreach (string property in propertiesToUndefine) { undefinePropertiesPerProject[i].Add(property); log.LogMessageFromText($" {property}", MessageImportance.Low); } } } // If the user specified a different set of global properties for this project, then // parse the string containing the properties if (!String.IsNullOrEmpty(projects[i].GetMetadata("AdditionalProperties"))) { if (!PropertyParser.GetTableWithEscaping (log, ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("General.AdditionalProperties", projectNames[i]), "AdditionalProperties", projects[i].GetMetadata("AdditionalProperties").Split(';'), out Dictionary <string, string> additionalProjectPropertiesTable) ) { return(false); } var combinedTable = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); // First copy in the properties from the global table that not in the additional properties table if (projectProperties[i] != null) { foreach (KeyValuePair <string, string> entry in projectProperties[i]) { if (!additionalProjectPropertiesTable.ContainsKey(entry.Key)) { combinedTable.Add(entry.Key, entry.Value); } } } // Add all the additional properties foreach (KeyValuePair <string, string> entry in additionalProjectPropertiesTable) { combinedTable.Add(entry.Key, entry.Value); } projectProperties[i] = combinedTable; } // If the user specified a different toolsVersion for this project - then override the setting if (!String.IsNullOrEmpty(projects[i].GetMetadata("ToolsVersion"))) { toolsVersions[i] = projects[i].GetMetadata("ToolsVersion"); } } } foreach (string[] targetList in targetLists) { if (stopOnFirstFailure && !success) { // Inform the user that we skipped the remaining targets StopOnFirstFailure=true. log.LogMessageFromResources(MessageImportance.Low, "MSBuild.SkippingRemainingTargets"); // We have encountered a failure. Caller has requested that we not // continue with remaining targets. break; } // Send the project off to the build engine. By passing in null to the // first param, we are indicating that the project to build is the same // as the *calling* project file. BuildEngineResult result = buildEngine.BuildProjectFilesInParallel(projectNames, targetList, projectProperties, undefinePropertiesPerProject, toolsVersions, true /* ask that target outputs are returned in the buildengineresult */); bool currentTargetResult = result.Result; IList <IDictionary <string, ITaskItem[]> > targetOutputsPerProject = result.TargetOutputsPerProject; success = success && currentTargetResult; // If the engine was able to satisfy the build request if (currentTargetResult) { for (int i = 0; i < projects.Count; i++) { IEnumerable <string> nonNullTargetList = targetList ?? targetOutputsPerProject[i].Keys; foreach (string targetName in nonNullTargetList) { if (targetOutputsPerProject[i].ContainsKey(targetName)) { ITaskItem[] outputItemsFromTarget = targetOutputsPerProject[i][targetName]; foreach (ITaskItem outputItemFromTarget in outputItemsFromTarget) { // No need to rebase if the calling project is the same as the callee project // (project == null). Also no point in trying to copy item metadata either, // because no items were passed into the Projects parameter! if (projects[i] != null) { // Rebase the output item paths if necessary. No need to rebase if the calling // project is the same as the callee project (project == null). if (rebaseOutputs) { try { outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); } catch (ArgumentException e) { log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message); } } // Copy the custom item metadata from the "Projects" items to these // output items. projects[i].CopyMetadataTo(outputItemFromTarget); // Set a metadata on the output items called "MSBuildProjectFile" which tells you which project file produced this item. if (String.IsNullOrEmpty(outputItemFromTarget.GetMetadata(ItemMetadataNames.msbuildSourceProjectFile))) { outputItemFromTarget.SetMetadata(ItemMetadataNames.msbuildSourceProjectFile, projects[i].GetMetadata(FileUtilities.ItemSpecModifiers.FullPath)); } } // Set a metadata on the output items called "MSBuildTargetName" which tells you which target produced this item. if (String.IsNullOrEmpty(outputItemFromTarget.GetMetadata(ItemMetadataNames.msbuildSourceTargetName))) { outputItemFromTarget.SetMetadata(ItemMetadataNames.msbuildSourceTargetName, targetName); } } targetOutputs.AddRange(outputItemsFromTarget); } } } } } return(success); }
public override bool Execute() { Hashtable hashtable; if ((this.Projects == null) || (this.Projects.Length == 0)) { return(true); } if ((this.TargetAndPropertyListSeparators != null) && (this.TargetAndPropertyListSeparators.Length > 0)) { this.ExpandAllTargetsAndProperties(); } if (!PropertyParser.GetTableWithEscaping(base.Log, Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("General.GlobalProperties", new object[0]), "Properties", this.Properties, out hashtable)) { return(false); } string[] undefineProperties = null; if (!string.IsNullOrEmpty(this.undefineProperties)) { base.Log.LogMessageFromResources(MessageImportance.Low, "General.UndefineProperties", new object[0]); undefineProperties = this.undefineProperties.Split(new char[] { ';' }); foreach (string str in undefineProperties) { base.Log.LogMessageFromText(string.Format(CultureInfo.InvariantCulture, " {0}", new object[] { str }), MessageImportance.Low); } } bool isRunningMultipleNodes = base.BuildEngine2.IsRunningMultipleNodes; if ((!isRunningMultipleNodes && this.stopOnFirstFailure) && this.buildInParallel) { this.buildInParallel = false; base.Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.NotBuildingInParallel", new object[0]); } if ((isRunningMultipleNodes && this.buildInParallel) && (this.stopOnFirstFailure && !this.runEachTargetSeparately)) { base.Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.NoStopOnFirstFailure", new object[0]); } ArrayList targetLists = CreateTargetLists(this.Targets, this.RunEachTargetSeparately); bool success = true; ITaskItem[] projects = null; bool[] skipProjects = null; if (this.buildInParallel) { skipProjects = new bool[this.Projects.Length]; for (int j = 0; j < skipProjects.Length; j++) { skipProjects[j] = true; } } else { projects = new ITaskItem[1]; } for (int i = 0; i < this.Projects.Length; i++) { ITaskItem item = this.Projects[i]; string path = Microsoft.Build.Shared.FileUtilities.AttemptToShortenPath(item.ItemSpec); if (this.stopOnFirstFailure && !success) { base.Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.SkippingRemainingProjects", new object[0]); break; } if (File.Exists(path) || (this.skipNonexistentProjects == SkipNonexistentProjectsBehavior.Build)) { if (Microsoft.Build.Shared.FileUtilities.IsVCProjFilename(path)) { base.Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", new object[] { item.ItemSpec }); success = false; } else if (!this.buildInParallel) { projects[0] = item; if (!ExecuteTargets(projects, hashtable, undefineProperties, targetLists, this.StopOnFirstFailure, this.RebaseOutputs, base.BuildEngine3, base.Log, this.targetOutputs, this.useResultsCache, this.unloadProjectsOnCompletion, this.ToolsVersion)) { success = false; } } else { skipProjects[i] = false; } } else if (this.skipNonexistentProjects == SkipNonexistentProjectsBehavior.Skip) { base.Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", new object[] { item.ItemSpec }); } else { Microsoft.Build.Shared.ErrorUtilities.VerifyThrow(this.skipNonexistentProjects == SkipNonexistentProjectsBehavior.Error, "skipNonexistentProjects has unexpected value {0}", this.skipNonexistentProjects); base.Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", new object[] { item.ItemSpec }); success = false; } } if (this.buildInParallel) { success = this.BuildProjectsInParallel(hashtable, undefineProperties, targetLists, success, skipProjects); } return(success); }
/// <summary> /// Instructs the MSBuild engine to build one or more project files whose locations are specified by the /// <see cref="Projects"/> property. /// </summary> /// <returns>true if all projects build successfully; false if any project fails</returns> public override bool Execute() { // If no projects were passed in, just return success. if ((Projects == null) || (Projects.Length == 0)) { return(true); } // We have been asked to unescape all escaped characters before processing if (TargetAndPropertyListSeparators != null && TargetAndPropertyListSeparators.Length > 0) { ExpandAllTargetsAndProperties(); } // Parse the global properties into a hashtable. if (!PropertyParser.GetTableWithEscaping(Log, ResourceUtilities.GetResourceString("General.GlobalProperties"), "Properties", Properties, out Dictionary <string, string> propertiesTable)) { return(false); } // Parse out the properties to undefine, if any. string[] undefinePropertiesArray = null; if (!String.IsNullOrEmpty(RemoveProperties)) { Log.LogMessageFromResources(MessageImportance.Low, "General.UndefineProperties"); undefinePropertiesArray = RemoveProperties.Split(';'); foreach (string property in undefinePropertiesArray) { Log.LogMessageFromText($" {property}", MessageImportance.Low); } } bool isRunningMultipleNodes = BuildEngine2.IsRunningMultipleNodes; // If we are in single proc mode and stopOnFirstFailure is true, we cannot build in parallel because // building in parallel sends all of the projects to the engine at once preventing us from not sending // any more projects after the first failure. Therefore, to preserve compatibility with whidbey if we are in this situation disable buildInParallel. if (!isRunningMultipleNodes && StopOnFirstFailure && BuildInParallel) { BuildInParallel = false; Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.NotBuildingInParallel"); } // When the condition below is met, provide an information message indicating stopOnFirstFailure // will have no effect. The reason there will be no effect is, when buildInParallel is true // All project files will be submitted to the engine all at once, this mean there is no stopping for failures between projects. // When RunEachTargetSeparately is false, all targets will be submitted to the engine at once, this means there is no way to stop between target failures. // therefore the first failure seen will be the only failure seen. if (isRunningMultipleNodes && BuildInParallel && StopOnFirstFailure && !RunEachTargetSeparately) { Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.NoStopOnFirstFailure"); } // This is a list of string[]. That is, each element in the list is a string[]. Each // string[] represents a set of target names to build. Depending on the value // of the RunEachTargetSeparately parameter, we each just call the engine to run all // the targets together, or we call the engine separately for each target. List <string[]> targetLists = CreateTargetLists(Targets, RunEachTargetSeparately); bool success = true; List <ITaskItem> singleProject = null; bool[] skipProjects = null; if (BuildInParallel) { skipProjects = new bool[Projects.Length]; for (int i = 0; i < skipProjects.Length; i++) { skipProjects[i] = true; } } else { singleProject = new List <ITaskItem>(1) { null }; } // Read in each project file. If there are any errors opening the file or parsing the XML, // raise an event and return False. If any one of the projects fails to build, return False, // otherwise return True. If parallel build is requested we first check for file existence so // that we don't pass a non-existent file to IBuildEngine causing an exception for (int i = 0; i < Projects.Length; i++) { ITaskItem project = Projects[i]; string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); if (StopOnFirstFailure && !success) { // Inform the user that we skipped the remaining projects because StopOnFirstFailure=true. Log.LogMessageFromResources(MessageImportance.Low, "MSBuild.SkippingRemainingProjects"); // We have encountered a failure. Caller has requested that we not // continue with remaining projects. break; } if (FileSystems.Default.FileExists(projectPath) || (_skipNonexistentProjects == SkipNonexistentProjectsBehavior.Build)) { if (FileUtilities.IsVCProjFilename(projectPath)) { Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); success = false; continue; } // If we are building in parallel we want to only make one call to // ExecuteTargets once we verified that all projects exist if (!BuildInParallel) { singleProject[0] = project; if (!ExecuteTargets ( singleProject, propertiesTable, undefinePropertiesArray, targetLists, StopOnFirstFailure, RebaseOutputs, BuildEngine3, Log, _targetOutputs, UnloadProjectsOnCompletion, ToolsVersion ) ) { success = false; } } else { skipProjects[i] = false; } } else { if (_skipNonexistentProjects == SkipNonexistentProjectsBehavior.Skip) { Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); } else { ErrorUtilities.VerifyThrow(_skipNonexistentProjects == SkipNonexistentProjectsBehavior.Error, "skipNonexistentProjects has unexpected value {0}", _skipNonexistentProjects); Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); success = false; } } } // We need to build all the projects that were not skipped if (BuildInParallel) { success = BuildProjectsInParallel(propertiesTable, undefinePropertiesArray, targetLists, success, skipProjects); } return(success); }
internal static bool ExecuteTargets(ITaskItem[] projects, Hashtable propertiesTable, string[] undefineProperties, ArrayList targetLists, bool stopOnFirstFailure, bool rebaseOutputs, IBuildEngine3 buildEngine, TaskLoggingHelper log, ArrayList targetOutputs, bool useResultsCache, bool unloadProjectsOnCompletion, string toolsVersion) { bool flag = true; string[] strArray = new string[projects.Length]; string[] projectFileNames = new string[projects.Length]; string[] strArray3 = new string[projects.Length]; IList <IDictionary <string, ITaskItem[]> > targetOutputsPerProject = null; IDictionary[] globalProperties = new IDictionary[projects.Length]; List <string>[] removeGlobalProperties = new List <string> [projects.Length]; for (int i = 0; i < projectFileNames.Length; i++) { projectFileNames[i] = null; globalProperties[i] = propertiesTable; if (projects[i] != null) { string path = Microsoft.Build.Shared.FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); strArray[i] = Path.GetDirectoryName(path); projectFileNames[i] = projects[i].ItemSpec; strArray3[i] = toolsVersion; if (!string.IsNullOrEmpty(projects[i].GetMetadata("Properties"))) { Hashtable hashtable; if (!PropertyParser.GetTableWithEscaping(log, Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("General.OverridingProperties", new object[] { projectFileNames[i] }), "Properties", projects[i].GetMetadata("Properties").Split(new char[] { ';' }), out hashtable)) { return(false); } globalProperties[i] = hashtable; } if (undefineProperties != null) { removeGlobalProperties[i] = new List <string>(undefineProperties); } string metadata = projects[i].GetMetadata("UndefineProperties"); if (!string.IsNullOrEmpty(metadata)) { string[] strArray4 = metadata.Split(new char[] { ';' }); if (removeGlobalProperties[i] == null) { removeGlobalProperties[i] = new List <string>(strArray4.Length); } if ((log != null) && (strArray4.Length > 0)) { log.LogMessageFromResources(MessageImportance.Low, "General.ProjectUndefineProperties", new object[] { projectFileNames[i] }); foreach (string str3 in strArray4) { removeGlobalProperties[i].Add(str3); log.LogMessageFromText(string.Format(CultureInfo.InvariantCulture, " {0}", new object[] { str3 }), MessageImportance.Low); } } } if (!string.IsNullOrEmpty(projects[i].GetMetadata("AdditionalProperties"))) { Hashtable hashtable2; if (!PropertyParser.GetTableWithEscaping(log, Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("General.AdditionalProperties", new object[] { projectFileNames[i] }), "AdditionalProperties", projects[i].GetMetadata("AdditionalProperties").Split(new char[] { ';' }), out hashtable2)) { return(false); } Hashtable hashtable3 = new Hashtable(StringComparer.OrdinalIgnoreCase); if (globalProperties[i] != null) { foreach (DictionaryEntry entry in globalProperties[i]) { if (!hashtable2.Contains(entry.Key)) { hashtable3.Add(entry.Key, entry.Value); } } } foreach (DictionaryEntry entry2 in hashtable2) { hashtable3.Add(entry2.Key, entry2.Value); } globalProperties[i] = hashtable3; } if (!string.IsNullOrEmpty(projects[i].GetMetadata("ToolsVersion"))) { strArray3[i] = projects[i].GetMetadata("ToolsVersion"); } } } foreach (string[] strArray5 in targetLists) { if (stopOnFirstFailure && !flag) { log.LogMessageFromResources(MessageImportance.Low, "MSBuild.SkippingRemainingTargets", new object[0]); return(flag); } bool flag2 = true; BuildEngineResult result = buildEngine.BuildProjectFilesInParallel(projectFileNames, strArray5, globalProperties, removeGlobalProperties, strArray3, true); flag2 = result.Result; targetOutputsPerProject = result.TargetOutputsPerProject; flag = flag && flag2; if (flag2) { for (int j = 0; j < projects.Length; j++) { IEnumerable enumerable = (strArray5 != null) ? ((IEnumerable)strArray5) : ((IEnumerable)targetOutputsPerProject[j].Keys); foreach (string str4 in enumerable) { if (targetOutputsPerProject[j].ContainsKey(str4)) { ITaskItem[] c = targetOutputsPerProject[j][str4]; foreach (ITaskItem item in c) { if (projects[j] != null) { if (rebaseOutputs) { try { item.ItemSpec = Path.Combine(strArray[j], item.ItemSpec); } catch (ArgumentException exception) { log.LogWarningWithCodeFromResources(null, projects[j].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", new object[] { item.ItemSpec, exception.Message }); } } projects[j].CopyMetadataTo(item); if (string.IsNullOrEmpty(item.GetMetadata("MSBuildSourceProjectFile"))) { item.SetMetadata("MSBuildSourceProjectFile", projects[j].GetMetadata("FullPath")); } } if (string.IsNullOrEmpty(item.GetMetadata("MSBuildSourceTargetName"))) { item.SetMetadata("MSBuildSourceTargetName", str4); } } targetOutputs.AddRange(c); } } } } } return(flag); }