actions/golangci-lint-action
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: restrict patched version to v1 (#1158)

Browse Source
This commit is contained in:
Ludovic Fernandez
2025-02-09 02:03:24 +01:00
committed by GitHub
parent 1cc4e007f0
commit 3e6beafdff
7 changed files with 200 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
src/install.ts
View File

@@ -5,14 +5,13 @@ import os from "os"
import path from "path"
import { promisify } from "util"
import { VersionConfig } from "./version"
import { VersionInfo } from "./version"
const execShellCommand = promisify(exec)
const downloadURL = "https://github.com/golangci/golangci-lint/releases/download"
const getAssetURL = (versionConfig: VersionConfig): string => {
const getAssetURL = (versionInfo: VersionInfo): string => {
let ext = "tar.gz"
let platform = os.platform().toString()
switch (platform) {
case "win32":
@@ -20,6 +19,7 @@ const getAssetURL = (versionConfig: VersionConfig): string => {
ext = "zip"
break
}
let arch = os.arch()
switch (arch) {
case "arm64":
@@ -33,9 +33,10 @@ const getAssetURL = (versionConfig: VersionConfig): string => {
arch = "386"
break
}
const noPrefix = versionConfig.TargetVersion.slice(1)
return `${downloadURL}/${versionConfig.TargetVersion}/golangci-lint-${noPrefix}-${platform}-${arch}.${ext}`
const noPrefix = versionInfo.TargetVersion.slice(1)
return `https://github.com/golangci/golangci-lint/releases/download/${versionInfo.TargetVersion}/golangci-lint-${noPrefix}-${platform}-${arch}.${ext}`
}
export enum InstallMode {
@@ -61,31 +62,31 @@ const printOutput = (res: ExecRes): void => {
/**
* Install golangci-lint.
*
* @param versionConfig information about version to install.
* @param versionInfo information about version to install.
* @param mode installation mode.
* @returns path to installed binary of golangci-lint.
*/
export async function installLint(versionConfig: VersionConfig, mode: InstallMode): Promise<string> {
export async function installLint(versionInfo: VersionInfo, mode: InstallMode): Promise<string> {
core.info(`Installation mode: ${mode}`)
switch (mode) {
case InstallMode.Binary:
return installBin(versionConfig)
return installBin(versionInfo)
case InstallMode.GoInstall:
return goInstall(versionConfig)
return goInstall(versionInfo)
default:
return installBin(versionConfig)
return installBin(versionInfo)
}
}
/**
* Install golangci-lint via `go install`.
*
* @param versionConfig information about version to install.
* @param versionInfo information about version to install.
* @returns path to installed binary of golangci-lint.
*/
export async function goInstall(versionConfig: VersionConfig): Promise<string> {
core.info(`Installing golangci-lint ${versionConfig.TargetVersion}...`)
export async function goInstall(versionInfo: VersionInfo): Promise<string> {
core.info(`Installing golangci-lint ${versionInfo.TargetVersion}...`)
const startedAt = Date.now()
@@ -93,43 +94,43 @@ export async function goInstall(versionConfig: VersionConfig): Promise<string> {
// TODO(ldez): it should be updated for v2.
const exres = await execShellCommand(
`go install github.com/golangci/golangci-lint/cmd/golangci-lint@${versionConfig.TargetVersion}`,
`go install github.com/golangci/golangci-lint/cmd/golangci-lint@${versionInfo.TargetVersion}`,
options
)
printOutput(exres)
// TODO(ldez): it should be updated for v2.
const res = await execShellCommand(
`go install -n github.com/golangci/golangci-lint/cmd/golangci-lint@${versionConfig.TargetVersion}`,
`go install -n github.com/golangci/golangci-lint/cmd/golangci-lint@${versionInfo.TargetVersion}`,
options
)
printOutput(res)
// The output of `go install -n` when the binary is already installed is `touch <path_to_the_binary>`.
const lintPath = res.stderr
const binPath = res.stderr
.split(/\r?\n/)
.map((v) => v.trimStart().trimEnd())
.filter((v) => v.startsWith("touch "))
.reduce((a, b) => a + b, "")
.split(` `, 2)[1]
core.info(`Installed golangci-lint into ${lintPath} in ${Date.now() - startedAt}ms`)
core.info(`Installed golangci-lint into ${binPath} in ${Date.now() - startedAt}ms`)
return lintPath
return binPath
}
/**
* Install golangci-lint via the precompiled binary.
*
* @param versionConfig information about version to install.
* @param versionInfo information about version to install.
* @returns path to installed binary of golangci-lint.
*/
export async function installBin(versionConfig: VersionConfig): Promise<string> {
core.info(`Installing golangci-lint binary ${versionConfig.TargetVersion}...`)
export async function installBin(versionInfo: VersionInfo): Promise<string> {
core.info(`Installing golangci-lint binary ${versionInfo.TargetVersion}...`)
const startedAt = Date.now()
const assetURL = getAssetURL(versionConfig)
const assetURL = getAssetURL(versionInfo)
core.info(`Downloading binary ${assetURL} ...`)
@@ -151,9 +152,9 @@ export async function installBin(versionConfig: VersionConfig): Promise<string>
const urlParts = assetURL.split(`/`)
const dirName = urlParts[urlParts.length - 1].replace(repl, ``)
const lintPath = path.join(extractedDir, dirName, `golangci-lint`)
const binPath = path.join(extractedDir, dirName, `golangci-lint`)
core.info(`Installed golangci-lint into ${lintPath} in ${Date.now() - startedAt}ms`)
core.info(`Installed golangci-lint into ${binPath} in ${Date.now() - startedAt}ms`)
return lintPath
return binPath
}

24
src/run.ts
View File

@@ -11,7 +11,7 @@ import which from "which"
import { restoreCache, saveCache } from "./cache"
import { installLint, InstallMode } from "./install"
import { alterDiffPatch } from "./utils/diffUtils"
import { findLintVersion } from "./version"
import { getVersion } from "./version"
const execShellCommand = promisify(exec)
const writeFile = promisify(fs.writeFile)
@@ -25,16 +25,16 @@ async function prepareLint(): Promise<string> {
const mode = core.getInput("install-mode").toLowerCase()
if (mode === InstallMode.None) {
const bin = await which("golangci-lint", { nothrow: true })
if (!bin) {
const binPath = await which("golangci-lint", { nothrow: true })
if (!binPath) {
throw new Error("golangci-lint binary not found in the PATH")
}
return bin
return binPath
}
const versionConfig = await findLintVersion(<InstallMode>mode)
const versionInfo = await getVersion(<InstallMode>mode)
return await installLint(versionConfig, <InstallMode>mode)
return await installLint(versionInfo, <InstallMode>mode)
}
async function fetchPatch(): Promise<string> {
@@ -141,7 +141,7 @@ async function fetchPushPatch(ctx: Context): Promise<string> {
}
type Env = {
lintPath: string
binPath: string
patchPath: string
}
@@ -151,12 +151,12 @@ async function prepareEnv(): Promise<Env> {
// Prepare cache, lint and go in parallel.
await restoreCache()
const lintPath = await prepareLint()
const binPath = await prepareLint()
const patchPath = await fetchPatch()
core.info(`Prepared env in ${Date.now() - startedAt}ms`)
return { lintPath, patchPath }
return { binPath: binPath, patchPath }
}
type ExecRes = {
@@ -292,9 +292,9 @@ async function runLint(lintPath: string, patchPath: string): Promise<void> {
export async function run(): Promise<void> {
try {
const { lintPath, patchPath } = await core.group(`prepare environment`, prepareEnv)
core.addPath(path.dirname(lintPath))
await core.group(`run golangci-lint`, () => runLint(lintPath, patchPath))
const { binPath, patchPath } = await core.group(`prepare environment`, prepareEnv)
core.addPath(path.dirname(binPath))
await core.group(`run golangci-lint`, () => runLint(binPath, patchPath))
} catch (error) {
core.error(`Failed to run: ${error}, ${error.stack}`)
core.setFailed(error.message)

72
src/version.ts
View File

@@ -1,7 +1,6 @@
import * as core from "@actions/core"
import * as httpm from "@actions/http-client"
import * as fs from "fs"
import os from "os"
import path from "path"
import { InstallMode } from "./install"
@@ -14,6 +13,7 @@ export type Version = {
} | null
const versionRe = /^v(\d+)\.(\d+)(?:\.(\d+))?$/
// TODO(ldez): it should be updated to match v2 module name.
const modVersionRe = /github.com\/golangci\/golangci-lint\s(v.+)/
const parseVersion = (s: string): Version => {
@@ -64,8 +64,8 @@ const isLessVersion = (a: Version, b: Version): boolean => {
return a.minor < b.minor
}
const getRequestedLintVersion = (): Version => {
let requestedLintVersion = core.getInput(`version`)
const getRequestedVersion = (): Version => {
let requestedVersion = core.getInput(`version`)
const workingDirectory = core.getInput(`working-directory`)
let goMod = "go.mod"
@@ -73,44 +73,43 @@ const getRequestedLintVersion = (): Version => {
goMod = path.join(workingDirectory, goMod)
}
if (requestedLintVersion == "" && fs.existsSync(goMod)) {
if (requestedVersion == "" && fs.existsSync(goMod)) {
const content = fs.readFileSync(goMod, "utf-8")
const match = content.match(modVersionRe)
if (match) {
requestedLintVersion = match[1]
core.info(`Found golangci-lint version '${requestedLintVersion}' in '${goMod}' file`)
requestedVersion = match[1]
core.info(`Found golangci-lint version '${requestedVersion}' in '${goMod}' file`)
}
}
const parsedRequestedLintVersion = parseVersion(requestedLintVersion)
if (parsedRequestedLintVersion == null) {
const parsedRequestedVersion = parseVersion(requestedVersion)
if (parsedRequestedVersion == null) {
return null
}
if (isLessVersion(parsedRequestedLintVersion, minVersion)) {
if (isLessVersion(parsedRequestedVersion, minVersion)) {
throw new Error(
`requested golangci-lint version '${requestedLintVersion}' isn't supported: we support only ${stringifyVersion(
`requested golangci-lint version '${requestedVersion}' isn't supported: we support only ${stringifyVersion(
minVersion
)} and later versions`
)
}
return parsedRequestedLintVersion
return parsedRequestedVersion
}
export type VersionConfig = {
export type VersionInfo = {
Error?: string
TargetVersion: string
AssetURL: string
}
type Config = {
type VersionMapping = {
MinorVersionToConfig: {
[minorVersion: string]: VersionConfig
[minorVersion: string]: VersionInfo
}
}
const getConfig = async (): Promise<Config> => {
const fetchVersionMapping = async (): Promise<VersionMapping> => {
const http = new httpm.HttpClient(`golangci/golangci-lint-action`, [], {
allowRetries: true,
maxRetries: 5,
@@ -130,55 +129,48 @@ const getConfig = async (): Promise<Config> => {
}
}
export async function findLintVersion(mode: InstallMode): Promise<VersionConfig> {
export async function getVersion(mode: InstallMode): Promise<VersionInfo> {
core.info(`Finding needed golangci-lint version...`)
if (mode == InstallMode.GoInstall) {
const v: string = core.getInput(`version`)
// TODO(ldez): latest should be replaced with an explicit version (ex: v1.64.0).
// TODO(ldez): AssetURL should be updated for v2.
return { TargetVersion: v ? v : "latest", AssetURL: "github.com/golangci/golangci-lint" }
return { TargetVersion: v ? v : "latest" }
}
const reqLintVersion = getRequestedLintVersion()
const reqVersion = getRequestedVersion()
// if the patched version is passed, just use it
if (reqLintVersion?.major !== null && reqLintVersion?.minor != null && reqLintVersion?.patch !== null) {
// TODO(ldez): should be updated to `reqVersion?.major === 2`.
if (reqVersion?.major === 1 && reqVersion?.minor != null && reqVersion?.patch !== null) {
return new Promise((resolve) => {
let arch: string = "amd64"
if (os.arch() === "arm64") {
arch = "arm64"
}
const versionWithoutV = `${reqLintVersion.major}.${reqLintVersion.minor}.${reqLintVersion.patch}`
resolve({
TargetVersion: `v${versionWithoutV}`,
AssetURL: `https://github.com/golangci/golangci-lint/releases/download/v${versionWithoutV}/golangci-lint-${versionWithoutV}-linux-${arch}.tar.gz`,
})
const versionWithoutV = `${reqVersion.major}.${reqVersion.minor}.${reqVersion.patch}`
resolve({ TargetVersion: `v${versionWithoutV}` })
})
}
const startedAt = Date.now()
const config = await getConfig()
if (!config.MinorVersionToConfig) {
core.warning(JSON.stringify(config))
const mapping = await fetchVersionMapping()
if (!mapping.MinorVersionToConfig) {
core.warning(JSON.stringify(mapping))
throw new Error(`invalid config: no MinorVersionToConfig field`)
}
const versionConfig = config.MinorVersionToConfig[stringifyVersion(reqLintVersion)]
if (!versionConfig) {
throw new Error(`requested golangci-lint version '${stringifyVersion(reqLintVersion)}' doesn't exist`)
const versionInfo = mapping.MinorVersionToConfig[stringifyVersion(reqVersion)]
if (!versionInfo) {
throw new Error(`requested golangci-lint version '${stringifyVersion(reqVersion)}' doesn't exist`)
}
if (versionConfig.Error) {
throw new Error(`failed to use requested golangci-lint version '${stringifyVersion(reqLintVersion)}': ${versionConfig.Error}`)
if (versionInfo.Error) {
throw new Error(`failed to use requested golangci-lint version '${stringifyVersion(reqVersion)}': ${versionInfo.Error}`)
}
core.info(
`Requested golangci-lint '${stringifyVersion(reqLintVersion)}', using '${versionConfig.TargetVersion}', calculation took ${
`Requested golangci-lint '${stringifyVersion(reqVersion)}', using '${versionInfo.TargetVersion}', calculation took ${
Date.now() - startedAt
}ms`
)
return versionConfig
return versionInfo
}