Fix assemblyInfoPatcher dependency resolution when dotnet is unavailable

- Add defensive error handling in AssemblyInfoVersionPatcher provider evaluation
- Catch process execution failures when dotnet command cannot be started
- Handle Windows and Linux-specific error messages gracefully
- Make provider evaluation return empty lists instead of throwing exceptions
- Add OS-aware warning messages (Windows MSBuild vs Mono's MSBuild)
- Update version to 4.9-SNAPSHOT
- Update CHANGELOG with all fixes

This fixes the issue where builds fail during task dependency resolution
on Windows servers without dotnet SDK installed, allowing builds to
proceed using Windows MSBuild instead.

Author: gamma

CHANGELOG.md

@@ -12,6 +12,10 @@
 * ProjectFileParser Linux compatibility
 * MSBuild task execution for Gradle 9
 * Snapshot publishing optimizations
+* Fixed `assemblyInfoPatcher` task dependency resolution failure when `dotnet` command is not available
+* Improved error handling for process execution failures when `dotnet` cannot be started (Windows and Linux)
+* Made `assemblyInfoPatcher` provider evaluation defensive to gracefully handle exceptions during configuration phase
+* OS-aware warning messages (Windows MSBuild vs Mono's MSBuild)
 
 ### Changed
 * Updated Gradle wrapper from 6.9 to 9.2.1

gradle.properties

@@ -1 +1 @@
-version = 4.8
+version = 4.9-SNAPSHOT

src/main/groovy/com/ullink/AssemblyInfoVersionPatcher.groovy

@@ -18,26 +18,64 @@ class AssemblyInfoVersionPatcher extends DefaultTask {
     AssemblyInfoVersionPatcher() {
         projects = project.getObjects().listProperty(String)
         projects.set(project.provider({
-            project.tasks.msbuild.projects.collect { it.key }
+            try {
+                def msbuildTask = project.tasks.findByName('msbuild')
+                if (msbuildTask == null) {
+                    project.logger.debug("AssemblyInfoPatcher: msbuild task not found, using empty list")
+                    return []
+                }
+                msbuildTask.projects.collect { it.key }
+            } catch (Exception e) {
+                // If accessing msbuild.projects fails (e.g., dotnet not available), return empty list
+                // This allows the build to continue without project parsing
+                project.logger.debug("AssemblyInfoPatcher: Could not access msbuild.projects, using empty list. Error: ${e.message}")
+                []
+            }
         }))
 
         files = project.getObjects().listProperty(File)
         files.set(project.provider({
-            projects.get()
-                .collect { project.tasks.msbuild.projects[it] }
-                .collect {
-                    if (it.properties.UsingMicrosoftNETSdk == 'true') {
-                        it.properties.MSBuildProjectFullPath
-                    } else {
-                        it?.getItems('Compile')?.find { Files.getNameWithoutExtension(it.name) == 'AssemblyInfo' }
-                    }
-                }
-                .findAll { it != null }
-                .unique()
-                .collect {
-                    project.logger.info("AssemblyInfoPatcher: found file ${it} (${it?.class})")
-                    project.file(it)
+            try {
+                def msbuildTask = project.tasks.findByName('msbuild')
+                if (msbuildTask == null) {
+                    project.logger.debug("AssemblyInfoPatcher: msbuild task not found, using empty file list")
+                    return []
                 }
+                projects.get()
+                    .collect { 
+                        try {
+                            msbuildTask.projects[it]
+                        } catch (Exception e) {
+                            project.logger.debug("AssemblyInfoPatcher: Could not access project '${it}', skipping. Error: ${e.message}")
+                            null
+                        }
+                    }
+                    .findAll { it != null }
+                    .collect {
+                        try {
+                            def result
+                            if (it.properties.UsingMicrosoftNETSdk == 'true') {
+                                result = it.properties.MSBuildProjectFullPath
+                            } else {
+                                result = it?.getItems('Compile')?.find { Files.getNameWithoutExtension(it.name) == 'AssemblyInfo' }
+                            }
+                            result
+                        } catch (Exception e) {
+                            project.logger.debug("AssemblyInfoPatcher: Error processing project file, skipping. Error: ${e.message}")
+                            null
+                        }
+                    }
+                    .findAll { it != null }
+                    .unique()
+                    .collect {
+                        project.logger.info("AssemblyInfoPatcher: found file ${it} (${it?.class})")
+                        project.file(it)
+                    }
+            } catch (Exception e) {
+                // If file resolution fails, return empty list
+                project.logger.debug("AssemblyInfoPatcher: Could not resolve files, using empty list. Error: ${e.message}")
+                []
+            }
         }))
 
         fileVersion = project.getObjects().property(String)

src/main/groovy/com/ullink/Msbuild.groovy

@@ -115,9 +115,10 @@ class Msbuild extends ConventionTask {
             version.startsWith('4.') || version == '14.0' || version == '12.0')
 
         if (useOldMsbuild) {
+            def msbuildType = OperatingSystem.current().windows ? "Windows MSBuild" : "Mono's MSBuild"
             logger.warn("Skipping project file parsing for old MSBuild version (${version}). " +
                 "ProjectFileParser uses .NET SDK MSBuild which cannot parse old-style projects. " +
-                "The build will proceed using Mono's MSBuild.")
+                "The build will proceed using ${msbuildType}.")
             parseProject = false
             // Initialize allProjects as empty map to prevent NPE
             if (allProjects == null) {
@@ -132,8 +133,11 @@ class Msbuild extends ConventionTask {
         resolveProject()
             }
         } catch (OldProjectFormatException e) {
-            // Old project format detected - skip parsing
-            logger.warn("Old-style project format detected. Build will proceed using Mono's MSBuild.")
+            // Old project format detected or dotnet not available - skip parsing
+            def msbuildType = OperatingSystem.current().windows ? "Windows MSBuild" : "Mono's MSBuild"
+            def reason = e.message?.contains("dotnet command not available") ? 
+                "dotnet command not available" : "old-style project format detected"
+            logger.warn("${reason}. Project file parsing will be skipped. Build will proceed using ${msbuildType}.")
             parseProject = false
             if (allProjects == null) {
                 allProjects = [:]
@@ -153,8 +157,9 @@ class Msbuild extends ConventionTask {
                 combinedError.contains('invalidprojectfileexception') || 
                 combinedError.contains('microsoft.build.exceptions') ||
                 (combinedError.contains('failed to parse project') && combinedError.contains('exit code: 255'))) {
+                def msbuildType = OperatingSystem.current().windows ? "Windows MSBuild" : "Mono's MSBuild"
                 logger.warn("Failed to parse project file (old-style project detected, .NET SDK MSBuild cannot parse it). " +
-                    "Build will proceed using Mono's MSBuild.")
+                    "Build will proceed using ${msbuildType}.")
                 parseProject = false
                 if (allProjects == null) {
                     allProjects = [:]
@@ -224,13 +229,38 @@ class Msbuild extends ConventionTask {
         def parserDll = new File(tempDir, 'ProjectFileParser.dll')
         def parseOutputStream = new ByteArrayOutputStream()
         def errorOutputStream = new ByteArrayOutputStream()
-        def parser = execOps.exec { exec ->
-            exec.commandLine('dotnet', '--roll-forward', 'Major', parserDll)
-            exec.args(file.toString(), JsonOutput.toJson(getInitProperties()).replace('"', '\''))
-            exec.standardOutput = parseOutputStream
-            exec.errorOutput = errorOutputStream
-            // We want to be able to print the details of what actually failed, otherwise we won't have this info
-            exec.ignoreExitValue = true
+        def parser
+        try {
+            parser = execOps.exec { exec ->
+                exec.commandLine('dotnet', '--roll-forward', 'Major', parserDll)
+                exec.args(file.toString(), JsonOutput.toJson(getInitProperties()).replace('"', '\''))
+                exec.standardOutput = parseOutputStream
+                exec.errorOutput = errorOutputStream
+                // We want to be able to print the details of what actually failed, otherwise we won't have this info
+                exec.ignoreExitValue = true
+            }
+        } catch (Exception e) {
+            // Handle process start failures (e.g., dotnet command not found, permission denied, etc.)
+            def errorMsg = e.message?.toLowerCase() ?: ''
+            def isCommandNotFound = errorMsg.contains('command') && errorMsg.contains('not found') ||
+                                    errorMsg.contains('cannot run program') ||
+                                    errorMsg.contains('no such file') ||
+                                    errorMsg.contains('executable not found') ||
+                                    errorMsg.contains('not recognized') ||  // Windows: "is not recognized as an internal or external command"
+                                    errorMsg.contains('cannot find the file') ||  // Windows alternative
+                                    (errorMsg.contains('system cannot find') && errorMsg.contains('specified'))  // Windows error
+            
+            if (isCommandNotFound) {
+                logger.warn("dotnet command not found or cannot be executed. " +
+                    "Project file parsing will be skipped. " +
+                    "Make sure dotnet SDK is installed and available in PATH. " +
+                    "Error: ${e.message}")
+                throw new OldProjectFormatException("dotnet command not available - skipping project parsing")
+            } else {
+                // Re-throw other exceptions (IO errors, etc.)
+                logger.error("Failed to execute ProjectFileParser: ${e.message}")
+                throw new GradleException("Failed to execute ProjectFileParser: ${e.message}", e)
+            }
         }
         if (parser.exitValue != 0) {
             def errorOutput = errorOutputStream.toString()