feat(GoTool): use go.mod to automatically install correct go versions

Signed-off-by: Christian Artin <[email protected]>

Author: gravufo

Tasks/GoToolV0/Strings/resources.resjson/en-US/resources.resjson

@@ -4,6 +4,10 @@
   "loc.description": "Find in cache or download a specific version of Go and add it to the PATH",
   "loc.instanceNameFormat": "Use Go $(version)",
   "loc.group.displayName.advanced": "Advanced",
+  "loc.input.label.useGoMod": "Use go.mod",
+  "loc.input.help.useGoMod": "Select this option to install the Go version matching the specified go.mod file. These files are searched from system.DefaultWorkingDirectory. You can change the search root path by setting working directory input.",
+  "loc.input.label.workingDirectory": "Working Directory",
+  "loc.input.help.workingDirectory": "Specify path from where go.mod files should be searched when using `Use go.mod`. If empty, `system.DefaultWorkingDirectory` will be considered as the root path.",
   "loc.input.label.version": "Version",
   "loc.input.help.version": "The Go version to download (if necessary) and use. Example: 1.9.3",
   "loc.input.label.goPath": "GOPATH",
@@ -13,5 +17,9 @@
   "loc.input.label.goDownloadUrl": "Go download URL",
   "loc.input.help.goDownloadUrl": "URL for downloading Go binaries. Only https://go.dev/dl (official) and https://aka.ms/golang/release/latest (Microsoft build) are supported. If omitted, the official Go download URL (https://go.dev/dl) will be used. This parameter takes priority over the GOTOOL_GODOWNLOADURL environment variable if both are set.",
   "loc.messages.FailedToDownload": "Failed to download Go version %s. Verify that the version is valid and resolve any other issues. Error: %s",
-  "loc.messages.TempDirNotSet": "The 'Agent.TempDirectory' environment variable was expected to be set."
+  "loc.messages.TempDirNotSet": "The 'Agent.TempDirectory' environment variable was expected to be set.",
+  "loc.messages.FailedToFindGoMod": "No go.mod file found in directory '%s'. Make sure go.mod file exists in the specified directory or its subdirectories.",
+  "loc.messages.GoModVersionDetected": "Detected Go version '%s' from go.mod file: %s",
+  "loc.messages.GoModVersionNotFound": "Could not find Go version directive in go.mod file: %s",
+  "loc.messages.FailedToReadGoMod": "Failed to read go.mod file '%s': %s"
 }

Tasks/GoToolV0/Tests/L0.ts

@@ -1,7 +1,6 @@
 import * as path from "path";
 import * as assert from "assert";
 import { MockTestRunner } from "azure-pipelines-task-lib/mock-test";
-import tl = require('azure-pipelines-task-lib');
 
 describe('GoToolV0 Suite', function() {
     this.timeout(60000);
@@ -10,10 +9,67 @@ describe('GoToolV0 Suite', function() {
         done();
     });
 
+    function runValidations(validator: () => void, tr: MockTestRunner) {
+        try {
+            validator();
+        }
+        catch (error) {
+            console.log('STDERR', tr.stderr);
+            console.log('STDOUT', tr.stdout);
+            throw error;
+        }
+    }
+
     after(function () {
         // Cleanup if needed
     });
 
+    // go.mod feature tests
+    it('Installs version from go.mod (single file)', async () => {
+        process.env['__case__'] = 'useGoModSingle';
+        const tp = path.join(__dirname, 'gotoolTests.js');
+        const tr: MockTestRunner = new MockTestRunner(tp);
+        await tr.runAsync();
+        runValidations(() => {
+            assert(tr.succeeded, 'Task should have succeeded');
+            assert(tr.stdout.indexOf("Parsed Go version '1.22'") > -1, 'Should log parsed Go version 1.22');
+        }, tr);
+    });
+
+    it('Installs versions from multiple go.mod files', async () => {
+        process.env['__case__'] = 'useGoModMulti';
+        const tp = path.join(__dirname, 'gotoolTests.js');
+        const tr: MockTestRunner = new MockTestRunner(tp);
+        await tr.runAsync();
+        runValidations(() => {
+            assert(tr.succeeded, 'Task should have succeeded');
+            assert(tr.stdout.indexOf("Parsed Go version '1.21'") > -1, 'Should parse 1.21');
+            assert(tr.stdout.indexOf("Parsed Go version '1.22'") > -1, 'Should parse 1.22');
+        }, tr);
+    });
+
+    it('Fails when go.mod not found', async () => {
+        process.env['__case__'] = 'useGoModNotFound';
+        const tp = path.join(__dirname, 'gotoolTests.js');
+        const tr: MockTestRunner = new MockTestRunner(tp);
+        await tr.runAsync();
+        runValidations(() => {
+            assert(tr.failed, 'Task should have failed');
+            assert(tr.stdout.indexOf('FailedToFindGoMod') > -1 || tr.stderr.indexOf('FailedToFindGoMod') > -1, 'Should output failure message for missing go.mod');
+        }, tr);
+    });
+
+    it('Installs version from explicit input (useGoMod disabled)', async () => {
+        process.env['__case__'] = 'explicitVersion';
+        const tp = path.join(__dirname, 'gotoolTests.js');
+        const tr: MockTestRunner = new MockTestRunner(tp);
+        await tr.runAsync();
+        runValidations(() => {
+            assert(tr.succeeded, 'Task should have succeeded');
+            assert(tr.stdout.indexOf('Go tool is cached under') > -1, 'Should have cached the tool');
+        }, tr);
+    });
+
     // Official Go (go.dev) tests
     it('Should install official Go with full patch version', async () => {
         let tp = path.join(__dirname, 'L0OfficialGoPatch.js');

Tasks/GoToolV0/Tests/gotoolTests.ts

@@ -0,0 +1,89 @@
+import ma = require('azure-pipelines-task-lib/mock-answer');
+import tmrm = require('azure-pipelines-task-lib/mock-run');
+import path = require('path');
+
+const taskPath = path.join(__dirname, '..', 'gotool.js');
+const tmr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);
+
+const testCase = process.env['__case__'];
+
+// Configure inputs depending on scenario
+switch (testCase) {
+    case 'useGoModSingle':
+        tmr.setInput('useGoMod', 'true');
+        tmr.setInput('workingDirectory', 'work');
+        break;
+    case 'useGoModMulti':
+        tmr.setInput('useGoMod', 'true');
+        tmr.setInput('workingDirectory', 'repo');
+        break;
+    case 'useGoModNotFound':
+        tmr.setInput('useGoMod', 'true');
+        tmr.setInput('workingDirectory', 'empty');
+        break;
+    case 'explicitVersion':
+        tmr.setInput('useGoMod', 'false');
+        tmr.setInput('version', '1.21.0');
+        break;
+    default:
+        throw new Error('Unknown __case__ value: ' + testCase);
+}
+
+const answers: ma.TaskLibAnswers = <ma.TaskLibAnswers>{
+    'assertAgent': { '2.115.0': true }
+};
+tmr.setAnswers(answers);
+
+// Dynamic findMatch behavior based on test case
+const tl = require('azure-pipelines-task-lib/mock-task');
+const tlClone = Object.assign({}, tl);
+tlClone.findMatch = function(root: string, pattern: string) {
+    if (pattern !== '**/go.mod') return [];
+    if (testCase === 'useGoModSingle' && root === 'work') {
+        return ['work/go.mod'];
+    }
+    if (testCase === 'useGoModMulti' && root === 'repo') {
+        return ['repo/a/go.mod', 'repo/b/go.mod'];
+    }
+    if (testCase === 'useGoModNotFound') {
+        return [];
+    }
+    return [];
+};
+tlClone.getVariable = function(v: string) {
+    if (v.toLowerCase() === 'system.defaultworkingdirectory') {
+        if (testCase === 'useGoModSingle') return 'work';
+        if (testCase === 'useGoModMulti') return 'repo';
+        if (testCase === 'useGoModNotFound') return 'empty';
+    }
+    if (v.toLowerCase() === 'agent.tempdirectory') return 'temp';
+    return null;
+};
+tlClone.assertAgent = function() { return; };
+tlClone.loc = function(locString: string, ...params: any[]) { return locString + ' ' + params.join(' '); };
+tlClone.prependPath = function(p: string) { /* no-op for tests */ };
+tmr.registerMock('azure-pipelines-task-lib/mock-task', tlClone);
+
+// fs mock
+tmr.registerMock('fs', {
+    readFileSync: function(p: string) {
+        if (p === 'work/go.mod') return Buffer.from('module example.com/single\n\n go 1.22');
+        if (p === 'repo/a/go.mod') return Buffer.from('module example.com/a\n go 1.21');
+        if (p === 'repo/b/go.mod') return Buffer.from('module example.com/b\n go 1.22');
+        return Buffer.from('');
+    }
+});
+
+// tool-lib mock
+tmr.registerMock('azure-pipelines-tool-lib/tool', {
+    findLocalTool: function(tool: string, version: string) { return false; },
+    downloadTool: function(url: string) { return 'download'; },
+    extractTar: function(downloadPath: string) { return 'ext'; },
+    extractZip: function(downloadPath: string) { return 'ext'; },
+    cacheDir: function(dir: string, tool: string, version: string) { return path.join('cache', tool, version); },
+    prependPath: function(p: string) { /* no-op */ }
+});
+
+tmr.registerMock('azure-pipelines-tasks-utility-common/telemetry', { emitTelemetry: function() {} });
+
+tmr.run();

Tasks/GoToolV0/gotool.ts

@@ -3,26 +3,50 @@ import * as tl from 'azure-pipelines-task-lib/task';
 import * as os from 'os';
 import * as path from 'path';
 import * as util from 'util';
-import * as telemetry from 'azure-pipelines-tasks-utility-common/telemetry';
 import * as fs from 'fs';
+import * as telemetry from 'azure-pipelines-tasks-utility-common/telemetry';
 
 const osPlat = os.platform();
 const osArch = os.arch();
 
+// Set resource path for localization
+try {
+    const taskManifestPath = path.join(__dirname, 'task.json');
+    tl.debug('Setting resource path to ' + taskManifestPath);
+    tl.setResourcePath(taskManifestPath);
+} catch (e) {
+    tl.debug('Failed to set resource path: ' + (e as any).message);
+}
+
 async function run() {
     try {
-        const rawVersion = tl.getInput('version', true);
-        if (!rawVersion || ['null','undefined',''].includes(rawVersion.trim().toLowerCase())) {
-            throw new Error("Input 'version' is required and must not be empty, 'null' or 'undefined'.");
+        const useGoMod: boolean = tl.getBoolInput('useGoMod', false);
+        const workingDirectory: string = tl.getPathInput('workingDirectory', false) || tl.getVariable('System.DefaultWorkingDirectory') || process.cwd();
+
+        if (useGoMod) {
+            const versions = getVersionsFromGoMod(workingDirectory);
+            if (!versions.length) {
+                throw tl.loc('FailedToFindGoMod', workingDirectory);
+            }
+            const downloadUrl = resolveDownloadUrl();
+            for (const version of versions) {
+                const resolvedVersion = await getGo(version, downloadUrl);
+                telemetry.emitTelemetry('TaskHub', 'GoToolV0', { versionSource: 'go.mod', version: resolvedVersion, customBaseUrl: String(!!downloadUrl) });
+            }
+        } else {
+            const rawVersion = tl.getInput('version', true);
+            if (!rawVersion || ['null','undefined',''].includes(rawVersion.trim().toLowerCase())) {
+                throw new Error("Input 'version' is required and must not be empty, 'null' or 'undefined'.");
+            }
+            const version = rawVersion.trim();
+            
+            const downloadUrl = resolveDownloadUrl();
+            const resolvedVersion = await getGo(version, downloadUrl);
+            telemetry.emitTelemetry('TaskHub', 'GoToolV0', { versionSource: 'input', version: resolvedVersion, customBaseUrl: String(!!downloadUrl) });
         }
-        const version = rawVersion.trim();
-        
-        const downloadUrl = resolveDownloadUrl();
-        const resolvedVersion = await getGo(version, downloadUrl);
-        telemetry.emitTelemetry('TaskHub', 'GoToolV0', { version: resolvedVersion, customBaseUrl: String(!!downloadUrl) });
     }
     catch (error) {
-        tl.setResult(tl.TaskResult.Failed, error);
+        tl.setResult(tl.TaskResult.Failed, error as any);
     }
 }
 
@@ -51,6 +75,82 @@ function resolveDownloadUrl(): string | undefined {
     return downloadUrl;
 }
 
+// Recursively find go.mod files starting at workingDirectory and extract the go version directive.
+// Returns distinct list of versions (without leading 'v').
+function getVersionsFromGoMod(workingDirectory: string): string[] {
+    const matches = tl.findMatch(workingDirectory, '**/go.mod');
+    if (!matches || !matches.length) {
+        return [];
+    }
+
+    const versions: Set<string> = new Set<string>();
+    for (const filePath of matches) {
+        tl.debug(`Found go.mod at ${filePath}`);
+        try {
+            const fileBuffer = fs.readFileSync(filePath);
+            if (!fileBuffer.length) {
+                tl.debug(`go.mod at ${filePath} is empty.`);
+                continue;
+            }
+            const content = fileBuffer.toString();
+            // Spec: a line starting with 'go ' followed by version (major.minor[.patch])
+            // We purposely ignore toolchain directive for now.
+            const regex = /^\s*go\s+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/m;
+            const match = content.match(regex);
+            if (match && match[1]) {
+                let version = match[1].trim();
+                tl.debug(`Parsed Go version '${version}' from ${filePath}`);
+                tl.loc('GoModVersionDetected', version, filePath);
+                versions.add(version);
+            } else {
+                tl.warning(tl.loc('GoModVersionNotFound', filePath));
+            }
+        } catch (err: any) {
+            tl.warning(tl.loc('FailedToReadGoMod', filePath, err.message || err));
+        }
+    }
+    return Array.from(versions.values());
+}
+
+async function getGo(version: string, baseUrl?: string): Promise<string> {
+    const resolved = await resolveVersionAndCache(version, baseUrl);
+    tl.debug(`resolveVersionAndCache result filenameVersion=${resolved.filenameVersion} cacheVersion=${resolved.cacheVersion ?? '<?>'} toolName=${resolved.toolName} (type=${typeof resolved.cacheVersion})`);
+    let toolPath: string | null = null;
+
+    if (resolved.cacheVersion) {
+        toolPath = toolLib.findLocalTool(resolved.toolName, resolved.cacheVersion);
+    }
+    }
+
+    const versions: Set<string> = new Set<string>();
+    for (const filePath of matches) {
+        tl.debug(`Found go.mod at ${filePath}`);
+        try {
+            const fileBuffer = fs.readFileSync(filePath);
+            if (!fileBuffer.length) {
+                tl.debug(`go.mod at ${filePath} is empty.`);
+                continue;
+            }
+            const content = fileBuffer.toString();
+            // Spec: a line starting with 'go ' followed by version (major.minor[.patch])
+            // We purposely ignore toolchain directive for now.
+            const regex = /^\s*go\s+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/m;
+            const match = content.match(regex);
+            if (match && match[1]) {
+                let version = match[1].trim();
+                tl.debug(`Parsed Go version '${version}' from ${filePath}`);
+                tl.loc('GoModVersionDetected', version, filePath);
+                versions.add(version);
+            } else {
+                tl.warning(tl.loc('GoModVersionNotFound', filePath));
+            }
+        } catch (err: any) {
+            tl.warning(tl.loc('FailedToReadGoMod', filePath, err.message || err));
+        }
+    }
+    return Array.from(versions.values());
+}
+
 async function getGo(version: string, baseUrl?: string): Promise<string> {
     const resolved = await resolveVersionAndCache(version, baseUrl);
     tl.debug(`resolveVersionAndCache result filenameVersion=${resolved.filenameVersion} cacheVersion=${resolved.cacheVersion ?? '<?>'} toolName=${resolved.toolName} (type=${typeof resolved.cacheVersion})`);

Tasks/GoToolV0/task.json

@@ -29,13 +29,31 @@
     }
   ],
   "inputs": [
+    {
+      "name": "useGoMod",
+      "type": "boolean",
+      "label": "Use go.mod",
+      "defaultValue": false,
+      "required": false,
+      "helpMarkDown": "Select this option to install the Go version matching the specified go.mod file. These files are searched from system.DefaultWorkingDirectory. You can change the search root path by setting working directory input."
+    },
+    {
+      "name": "workingDirectory",
+      "type": "filePath",
+      "label": "Working Directory",
+      "defaultValue": "",
+      "required": false,
+      "helpMarkDown": "Specify path from where go.mod files should be searched when using `Use go.mod`. If empty, `system.DefaultWorkingDirectory` will be considered as the root path.",
+      "visibleRule": "useGoMod = true"
+    },
     {
       "name": "version",
       "type": "string",
       "label": "Version",
       "defaultValue": "1.10",
       "required": true,
-      "helpMarkDown": "The Go version to download (if necessary) and use. Example: 1.9.3"
+      "helpMarkDown": "The Go version to download (if necessary) and use. Example: 1.9.3",
+      "visibleRule": "useGoMod = false"
     },
     {
       "name": "goPath",
@@ -77,6 +95,10 @@
   },
   "messages": {
     "FailedToDownload": "Failed to download Go version %s. Verify that the version is valid and resolve any other issues. Error: %s",
-    "TempDirNotSet": "The 'Agent.TempDirectory' environment variable was expected to be set."
+    "TempDirNotSet": "The 'Agent.TempDirectory' environment variable was expected to be set.",
+    "FailedToFindGoMod": "No go.mod file found in directory '%s'. Make sure go.mod file exists in the specified directory or its subdirectories.",
+    "GoModVersionDetected": "Detected Go version '%s' from go.mod file: %s",
+    "GoModVersionNotFound": "Could not find Go version directive in go.mod file: %s",
+    "FailedToReadGoMod": "Failed to read go.mod file '%s': %s"
   }
 }