2020-02-09 00:21:39 -05:00
import * as core from '@actions/core' ;
2020-03-26 12:40:41 -04:00
import * as io from '@actions/io' ;
2026-07-16 02:04:36 +05:30
import * as installer from './installer.js' ;
2022-03-14 12:21:30 -04:00
import * as semver from 'semver' ;
2020-03-27 00:55:12 -04:00
import path from 'path' ;
2026-07-16 02:04:36 +05:30
import { fileURLToPath } from 'url' ;
import { restoreCache } from './cache-restore.js' ;
import { isCacheFeatureAvailable } from './cache-utils.js' ;
2020-03-27 00:55:12 -04:00
import cp from 'child_process' ;
import fs from 'fs' ;
2022-08-12 12:29:48 +02:00
import os from 'os' ;
2026-07-16 02:04:36 +05:30
import { Architecture } from './types.js' ;
2026-09-25 21:05:28 +05:30
import { GO_ENV_OUTPUTS , GoEnv , Outputs } from './constants.js' ;
2020-02-09 00:21:39 -05:00
export async function run() {
try {
//
// versionSpec is optional. If supplied, install / use from the tool cache
// If not supplied then problem matchers will still be setup. Useful for self-hosted.
//
2022-05-12 17:04:39 +09:00
const versionSpec = resolveVersionInput ();
2025-08-29 04:21:56 +01:00
setGoToolchain ();
2020-02-09 08:47:38 -05:00
2022-05-25 12:07:29 +02:00
const cache = core . getBooleanInput ( 'cache' );
2020-02-09 22:39:44 -05:00
2025-09-04 03:54:45 +01:00
let arch = core . getInput ( 'architecture' ) as Architecture ;
2022-08-12 12:29:48 +02:00
if ( ! arch ) {
2025-09-04 03:54:45 +01:00
arch = os . arch () as Architecture ;
2022-08-12 12:29:48 +02:00
}
2020-02-09 00:21:39 -05:00
if ( versionSpec ) {
2026-09-09 00:47:06 +05:30
core . startGroup ( 'Installed version' );
try {
core . info ( `Setup go version spec ${ versionSpec } ` );
2020-02-09 00:21:39 -05:00
2026-09-09 00:47:06 +05:30
const token = core . getInput ( 'token' );
const auth = ! token ? undefined : `token ${ token } ` ;
2022-12-12 10:58:49 +01:00
2026-09-09 00:47:06 +05:30
const checkLatest = core . getBooleanInput ( 'check-latest' );
2026-03-16 17:43:44 +00:00
2026-09-09 00:47:06 +05:30
const goDownloadBaseUrl =
core . getInput ( 'go-download-base-url' ) ||
process . env [ 'GO_DOWNLOAD_BASE_URL' ] ||
undefined ;
if ( goDownloadBaseUrl ) {
core . info ( `Using custom Go download base URL: ${ goDownloadBaseUrl } ` );
}
const installDir = await installer . getGo (
versionSpec ,
checkLatest ,
auth ,
arch ,
goDownloadBaseUrl
);
const installDirVersion = path . basename ( path . dirname ( installDir ));
core . addPath ( path . join ( installDir , 'bin' ));
core . info ( 'Added go to the path' );
const version = installer . makeSemver ( installDirVersion );
// Go versions less than 1.9 require GOROOT to be set
if ( semver . lt ( version , '1.9.0' )) {
core . info ( 'Setting GOROOT for Go version < 1.9' );
core . exportVariable ( 'GOROOT' , installDir );
}
core . info ( `Successfully set up Go version ${ versionSpec } ` );
} finally {
core . endGroup ();
2026-03-16 17:43:44 +00:00
}
2023-03-14 16:07:41 +01:00
} else {
core . info (
'[warning]go-version input was not specified. The action will try to use pre-installed version.'
);
2020-02-09 00:21:39 -05:00
}
2023-03-14 16:29:10 +01:00
const added = await addBinToPath ();
core . debug ( `add bin ${ added } ` );
2023-03-08 10:45:16 +02:00
const goPath = await io . which ( 'go' );
const goVersion = ( cp . execSync ( ` ${ goPath } version` ) || '' ). toString ();
2026-09-18 20:35:51 +05:30
const goEnvJson = readGoEnv ( goPath );
if ( goEnvJson ) {
setGoEnvOutputs ( goEnvJson );
}
2023-01-20 01:28:58 +01:00
2022-05-25 12:07:29 +02:00
if ( cache && isCacheFeatureAvailable ()) {
const packageManager = 'default' ;
const cacheDependencyPath = core . getInput ( 'cache-dependency-path' );
2023-03-10 16:25:35 +01:00
try {
await restoreCache (
parseGoVersion ( goVersion ),
packageManager ,
cacheDependencyPath
);
} catch ( error ) {
2023-12-05 17:50:42 +01:00
core . warning ( `Restore cache failed: ${ ( error as Error ). message } ` );
2023-03-10 16:25:35 +01:00
}
2022-05-25 12:07:29 +02:00
}
2020-02-09 00:21:39 -05:00
// add problem matchers
2026-07-16 02:04:36 +05:30
const matchersPath = path . join (
path . dirname ( fileURLToPath ( import . meta . url )),
'../..' ,
'matchers.json'
);
2020-06-29 18:41:13 +03:00
core . info ( `##[add-matcher] ${ matchersPath } ` );
2020-03-31 10:32:03 -04:00
// output the version actually being used
2020-06-29 18:41:13 +03:00
core . info ( goVersion );
2020-04-06 08:42:55 -04:00
2022-04-08 12:23:10 -04:00
core . setOutput ( 'go-version' , parseGoVersion ( goVersion ));
2020-04-06 08:42:55 -04:00
core . startGroup ( 'go env' );
2023-03-08 10:45:16 +02:00
const goEnv = ( cp . execSync ( ` ${ goPath } env` ) || '' ). toString ();
2020-06-29 18:41:13 +03:00
core . info ( goEnv );
2020-04-06 08:42:55 -04:00
core . endGroup ();
2020-02-09 00:21:39 -05:00
} catch ( error ) {
2023-12-05 17:50:42 +01:00
core . setFailed (( error as Error ). message );
2020-02-09 00:21:39 -05:00
}
2020-02-09 00:29:21 -05:00
}
2020-03-26 12:02:52 -04:00
2026-09-25 21:05:28 +05:30
export function readGoEnv ( goPath : string ) : GoEnv | undefined {
2026-09-18 20:35:51 +05:30
try {
const rawGoEnv = cp . execFileSync ( goPath , [ 'env' , '-json' ], {
encoding : 'utf8' ,
stdio : [ 'ignore' , 'pipe' , 'pipe' ]
});
const parsed : unknown = JSON . parse ( rawGoEnv );
if (
typeof parsed !== 'object' ||
parsed === null ||
Array . isArray ( parsed )
) {
throw new Error ( "'go env -json' did not return a JSON object" );
}
2026-09-25 21:05:28 +05:30
return parsed as GoEnv ;
2026-09-18 20:35:51 +05:30
} catch ( error ) {
core . info (
`Unable to read 'go env -json', the Go environment outputs will not be set: ${
( error as Error ). message
} `
);
return undefined ;
}
}
2026-09-25 21:05:28 +05:30
export function setGoEnvOutputs ( goEnv : GoEnv ) : void {
for ( const name of GO_ENV_OUTPUTS ) {
core . setOutput ( name , goEnv [ name ] ?? '' );
2026-09-18 20:35:51 +05:30
}
2026-09-25 21:05:28 +05:30
core . setOutput ( Outputs . GoBinPath , goEnv . GOBIN || goPathBin ( goEnv ));
2026-09-18 20:35:51 +05:30
}
2026-09-25 21:05:28 +05:30
function goPathBin ( goEnv : GoEnv ) : string {
const goPath = ( goEnv . GOPATH ?? '' ). split ( path . delimiter )[ 0 ];
2026-09-18 20:35:51 +05:30
return goPath ? path . join ( goPath , 'bin' ) : '' ;
}
2020-03-27 00:55:12 -04:00
export async function addBinToPath () : Promise < boolean > {
2020-03-26 12:02:52 -04:00
let added = false ;
2023-03-08 10:45:16 +02:00
const g = await io . which ( 'go' );
2020-06-29 18:41:13 +03:00
core . debug ( `which go : ${ g } :` );
2020-03-26 12:40:41 -04:00
if ( ! g ) {
2020-06-29 18:41:13 +03:00
core . debug ( 'go not in the path' );
2020-03-26 12:40:41 -04:00
return added ;
}
2023-03-08 10:45:16 +02:00
const buf = cp . execSync ( 'go env GOPATH' );
2022-04-17 17:36:51 +02:00
if ( buf . length > 1 ) {
2023-03-08 10:45:16 +02:00
const gp = buf . toString (). trim ();
2020-06-29 18:41:13 +03:00
core . debug ( `go env GOPATH : ${ gp } :` );
2020-03-26 13:00:45 -04:00
if ( ! fs . existsSync ( gp )) {
// some of the hosted images have go install but not profile dir
2020-06-29 18:41:13 +03:00
core . debug ( `creating ${ gp } ` );
2022-03-28 10:54:44 +01:00
await io . mkdirP ( gp );
2020-03-26 12:54:21 -04:00
}
2020-03-26 13:00:45 -04:00
2023-03-08 10:45:16 +02:00
const bp = path . join ( gp , 'bin' );
2020-03-26 13:00:45 -04:00
if ( ! fs . existsSync ( bp )) {
2020-06-29 18:41:13 +03:00
core . debug ( `creating ${ bp } ` );
2022-03-28 10:54:44 +01:00
await io . mkdirP ( bp );
2020-03-26 13:00:45 -04:00
}
core . addPath ( bp );
added = true ;
2020-03-26 12:02:52 -04:00
}
return added ;
}
2020-03-27 00:55:12 -04:00
2022-04-08 12:23:10 -04:00
export function parseGoVersion ( versionString : string ) : string {
// get the installed version as an Action output
// based on go/src/cmd/go/internal/version/version.go:
// fmt.Printf("go version %s %s/%s\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)
// expecting go<version> for runtime.Version()
return versionString . split ( ' ' )[ 2 ]. slice ( 'go' . length );
}
2022-05-12 17:04:39 +09:00
function resolveVersionInput () : string {
let version = core . getInput ( 'go-version' );
const versionFilePath = core . getInput ( 'go-version-file' );
if ( version && versionFilePath ) {
core . warning (
'Both go-version and go-version-file inputs are specified, only go-version will be used'
);
}
if ( version ) {
2026-11-03 00:19:42 +05:30
const customBaseUrl =
core . getInput ( 'go-download-base-url' ) ||
process . env [ 'GO_DOWNLOAD_BASE_URL' ];
if (
version . startsWith ( 'go' ) &&
! customBaseUrl &&
! installer . isGoNativeVersion ( version )
) {
throw new Error (
`Invalid Go version " ${ version } ". Go-native versions must look like go1.21, go1.21.5, go1.18beta2, or go1.21rc2. For version ranges, use SemVer syntax (e.g. ~1.21, ^1.21).`
);
}
2022-05-12 17:04:39 +09:00
return version ;
}
if ( versionFilePath ) {
if ( ! fs . existsSync ( versionFilePath )) {
throw new Error (
`The specified go version file at: ${ versionFilePath } does not exist`
);
}
version = installer . parseGoVersionFile ( versionFilePath );
}
return version ;
}
2025-08-29 04:21:56 +01:00
function setGoToolchain() {
// docs: https://go.dev/doc/toolchain
// "local indicates the bundled Go toolchain (the one that shipped with the go command being run)"
// this is so any 'go' command is run with the selected Go version
// and doesn't trigger a toolchain download and run commands with that
// see e.g. issue #424
// and a similar discussion: https://github.com/docker-library/golang/issues/472.
// Set the value in process env so any `go` commands run as child-process
// don't cause toolchain downloads
process . env [ installer . GOTOOLCHAIN_ENV_VAR ] = installer . GOTOOLCHAIN_LOCAL_VAL ;
// and in the runner env so e.g. a user running `go mod tidy` won't cause it
core . exportVariable (
installer . GOTOOLCHAIN_ENV_VAR ,
installer . GOTOOLCHAIN_LOCAL_VAL
);
}