Add modern .NET SDK MSBuild auto-detection and improve macOS/Linux support

- Auto-detect dotnet SDK MSBuild on non-Windows platforms
- Add msBuildPath property to NuGetRestore for explicit MSBuild configuration
- Add ignoreFailuresOnNonWindows property to gracefully handle Mono xbuild issues
- Improve ignoreExitValue handling for Gradle 8 compatibility
- Use Exec task's built-in execution when ignoring failures to respect ignoreExitValue

Author: gamma

CHANGELOG.md

@@ -2,11 +2,17 @@
 
 ## 2.24
 
+### Added
+* Auto-detection of modern .NET SDK MSBuild on macOS/Linux platforms
+* Added `msBuildPath` property to `NuGetRestore` task for explicit MSBuild path configuration
+* Added `ignoreFailuresOnNonWindows` property to `NuGetRestore` task to gracefully handle Mono xbuild limitations
+
 ### Fixed
 * Fixed stack overflow in Gradle 8 when calling `super.exec()` by using `@TaskAction` instead of overriding `exec()`
 * Fixed constructor injection compatibility for both Gradle 8 (no injection) and Gradle 9+ (with injection)
 * Fixed `nugetExePath` resolution to use project directory instead of Gradle daemon working directory
 * Changed private helper methods to `protected @Internal` for Gradle 9 task validation
+* Improved MSBuild handling on non-Windows platforms by auto-detecting dotnet SDK and using `ignoreExitValue` when configured
 
 ## 2.22
 ### Fixed

src/main/groovy/com/ullink/BaseNuGet.groovy

@@ -165,46 +165,53 @@ class BaseNuGet extends Exec {
         args '-NonInteractive'
         args '-Verbosity', (verbosity ?: getNugetVerbosity())
 
-        // Execute using the ExecActionFactory to avoid method interception recursion
-        def execActionFactory = getExecActionFactory()
-        if (execActionFactory != null) {
-            def execAction = execActionFactory.newExecAction()
-            execAction.setExecutable(executable)
-            execAction.setArgs(getArgs())
-            execAction.setWorkingDir(project.projectDir)
-            
-            // Check if we should ignore failures on non-Windows (for Mono xbuild issues)
-            def shouldIgnoreFailures = false
+        // Check if we should ignore failures on non-Windows (for Mono xbuild issues)
+        // Set ignoreExitValue on the Exec task itself before execution
+        def shouldIgnoreFailures = false
+        try {
             if (this.hasProperty('ignoreFailuresOnNonWindows') && this.ignoreFailuresOnNonWindows) {
                 shouldIgnoreFailures = !isFamily(FAMILY_WINDOWS)
-            }
-            
-            try {
-                execAction.execute()
-            } catch (Exception e) {
                 if (shouldIgnoreFailures) {
-                    project.logger.warn("NuGet restore failed on non-Windows platform (likely Mono xbuild issue), ignoring: ${e.message}")
-                    return
+                    project.logger.debug("Will ignore failures on non-Windows platform")
+                    // Use the Exec task's built-in ignoreExitValue property
+                    this.ignoreExitValue = true
                 }
-                throw e
             }
-        } else {
-            // Fallback: try to call Exec.exec() via reflection
+        } catch (Exception e) {
+            project.logger.debug("Could not check ignoreFailuresOnNonWindows: ${e.message}")
+        }
+        
+        // Execute using the ExecActionFactory to avoid method interception recursion
+        // However, if we need to ignore exit values, we must use the Exec task's built-in execution
+        // because ExecAction doesn't respect the Exec task's ignoreExitValue property
+        if (shouldIgnoreFailures) {
+            // Use Exec task's built-in execution when ignoring failures (respects ignoreExitValue)
             try {
                 def execMethod = Exec.class.getDeclaredMethod("exec")
                 execMethod.setAccessible(true)
                 execMethod.invoke(this)
-            } catch (Exception e) {
-                // Check if we should ignore failures on non-Windows
-                def shouldIgnoreFailures = false
-                if (this.hasProperty('ignoreFailuresOnNonWindows') && this.ignoreFailuresOnNonWindows) {
-                    shouldIgnoreFailures = !isFamily(FAMILY_WINDOWS)
-                }
-                if (shouldIgnoreFailures) {
-                    project.logger.warn("NuGet restore failed on non-Windows platform (likely Mono xbuild issue), ignoring: ${e.message}")
-                    return
+            } catch (Throwable e) {
+                project.logger.warn("NuGet restore failed on non-Windows platform (likely Mono xbuild issue), ignoring: ${e.class.simpleName}: ${e.message}")
+                return
+            }
+        } else {
+            // Use ExecActionFactory for normal execution (avoids stack overflow in Gradle 8)
+            def execActionFactory = getExecActionFactory()
+            if (execActionFactory != null) {
+                def execAction = execActionFactory.newExecAction()
+                execAction.setExecutable(executable)
+                execAction.setArgs(getArgs())
+                execAction.setWorkingDir(project.projectDir)
+                execAction.execute()
+            } else {
+                // Fallback: try to call Exec.exec() via reflection
+                try {
+                    def execMethod = Exec.class.getDeclaredMethod("exec")
+                    execMethod.setAccessible(true)
+                    execMethod.invoke(this)
+                } catch (Exception e) {
+                    throw new RuntimeException("Cannot execute NuGet command - no ExecActionFactory available", e)
                 }
-                throw new RuntimeException("Cannot execute NuGet command - no ExecActionFactory available", e)
             }
         }
     }

src/main/groovy/com/ullink/NuGetRestore.groovy

@@ -4,6 +4,7 @@ import com.ullink.util.GradleHelper
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
 
@@ -37,6 +38,9 @@ class NuGetRestore extends BaseNuGet {
     def msBuildVersion
     @Optional
     @Input
+    def msBuildPath
+    @Optional
+    @Input
     def packagesDirectory
     @Input
     def ignoreFailuresOnNonWindows = false
@@ -86,14 +90,39 @@ class NuGetRestore extends BaseNuGet {
         if (solutionDirectory) args '-SolutionDirectory', solutionDirectory
         if (disableParallelProcessing) args '-DisableParallelProcessing'
 
-        // Skip MSBuildVersion on non-Windows platforms (macOS/Linux) because Mono's xbuild/MSBuild
-        // doesn't work properly with NuGet restore and causes "Too many project files specified" errors
+        // On non-Windows platforms, try to use modern .NET SDK's MSBuild if available
         if (!isFamily(FAMILY_WINDOWS)) {
-            project.logger.debug("Skipping MSBuildVersion on non-Windows platform to avoid Mono xbuild issues")
+            // If msBuildPath is not explicitly set, try to auto-detect dotnet SDK MSBuild
+            if (!msBuildPath) {
+                def dotnetPath = findDotnetPath()
+                if (dotnetPath) {
+                    def dotnetMsbuildPath = findDotnetMsbuildPath(dotnetPath)
+                    if (dotnetMsbuildPath) {
+                        msBuildPath = dotnetMsbuildPath
+                        project.logger.debug("Auto-detected dotnet MSBuild at: ${msBuildPath}")
+                    }
+                }
+            }
+            
+            // Use MSBuildPath if available (takes precedence over MSBuildVersion)
+            if (msBuildPath) {
+                args '-MSBuildPath', msBuildPath
+                project.logger.debug("Using MSBuildPath: ${msBuildPath}")
+            } else {
+                // Skip MSBuildVersion on non-Windows if no MSBuildPath found
+                // because Mono's xbuild/MSBuild doesn't work properly with NuGet restore
+                project.logger.debug("Skipping MSBuildVersion on non-Windows platform (no dotnet MSBuild found)")
+            }
         } else {
+            // On Windows, use MSBuildVersion as before
             if (!msBuildVersion) msBuildVersion = GradleHelper.getPropertyFromTask(project, 'version', 'msbuild')
             if (msBuildVersion) args '-MsBuildVersion', msBuildVersion
         }
+        
+        // MSBuildPath can also be explicitly set on Windows
+        if (msBuildPath) {
+            args '-MSBuildPath', msBuildPath
+        }
 
         project.logger.info "Restoring NuGet packages " +
             (sources ? "from $sources" : '') +
@@ -116,4 +145,88 @@ class NuGetRestore extends BaseNuGet {
         def solutionDir = solutionFile ? project.file(solutionFile.getParent()) : solutionDirectory
         return new File(solutionDir ? solutionDir.toString() : '.', 'packages')
     }
+    
+    /**
+     * Find the dotnet executable path
+     */
+    private String findDotnetPath() {
+        try {
+            def process = ['which', 'dotnet'].execute()
+            process.waitFor()
+            if (process.exitValue() == 0) {
+                return process.text.trim()
+            }
+        } catch (Exception e) {
+            // dotnet not found
+        }
+        return null
+    }
+    
+    /**
+     * Find the MSBuild.dll path in the dotnet SDK
+     */
+    private String findDotnetMsbuildPath(String dotnetPath) {
+        try {
+            // Get dotnet SDK path
+            def process = [dotnetPath, '--info'].execute()
+            process.waitFor()
+            def output = process.text
+            
+            // Look for SDK base path
+            def sdkBasePath = null
+            output.eachLine { line ->
+                if (line.contains('Base Path:') || line.contains('SDK Base Path:')) {
+                    def path = line.split(':')[1]?.trim()
+                    if (path) {
+                        sdkBasePath = path
+                    }
+                }
+            }
+            
+            if (sdkBasePath) {
+                // Try to find MSBuild.dll in the SDK
+                def msbuildDll = new File(sdkBasePath, 'MSBuild.dll')
+                if (msbuildDll.exists()) {
+                    return msbuildDll.parentFile.absolutePath
+                }
+                
+                // Alternative: look in Current/MSBuild directory
+                def currentMsbuild = new File(sdkBasePath, 'Current/MSBuild.dll')
+                if (currentMsbuild.exists()) {
+                    return currentMsbuild.parentFile.absolutePath
+                }
+            }
+            
+            // Fallback: try common SDK locations
+            def commonPaths = [
+                '/usr/local/share/dotnet/sdk',
+                '/usr/share/dotnet/sdk',
+                System.getProperty('user.home') + '/.dotnet/sdk'
+            ]
+            
+            for (def basePath : commonPaths) {
+                def sdkDir = new File(basePath)
+                if (sdkDir.exists() && sdkDir.isDirectory()) {
+                    // Find the highest version SDK
+                    def sdkVersions = sdkDir.listFiles().findAll { it.isDirectory() && it.name.matches(/^\d+\.\d+\.\d+.*/) }
+                    if (sdkVersions) {
+                        sdkVersions.sort { a, b -> 
+                            // Simple version comparison
+                            def aVer = a.name.split(/[.-]/).collect { it.toInteger() }
+                            def bVer = b.name.split(/[.-]/).collect { it.toInteger() }
+                            return bVer <=> aVer
+                        }
+                        def latestSdk = sdkVersions[0]
+                        def msbuildDll = new File(latestSdk, 'MSBuild.dll')
+                        if (msbuildDll.exists()) {
+                            return msbuildDll.parentFile.absolutePath
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            project.logger.debug("Could not find dotnet MSBuild: ${e.message}")
+        }
+        return null
+    }
 }