feat: support installing multiple dnf packages

src/bazel/bazel.ts

@@ -23,9 +23,9 @@ export async function setupBazel(version: string, _setupDir: string, _arch: stri
         throw new Error("installing bazel on Arch linux is not supported yet")
       } else if (hasDnf()) {
         // https://bazel.build/install/redhat
-        setupDnfPack("dnf-plugins-core", undefined)
+        await setupDnfPack([{ name: "dnf-plugins-core" }])
         execRootSync("dnf", ["copr", "enable", "vbatts/bazel"])
-        return setupDnfPack("bazel4", undefined)
+        return setupDnfPack([{ name: "bazel4" }])
       } else if (isUbuntu()) {
         // https://bazel.build/install/ubuntu
         const keyFileName = await addAptKeyViaDownload(

src/ccache/ccache.ts

@@ -20,7 +20,7 @@ export function setupCcache(version: string, _setupDir: string, _arch: string) {
       if (isArch()) {
         return setupPacmanPack("ccache", version)
       } else if (hasDnf()) {
-        return setupDnfPack("ccache", version)
+        return setupDnfPack([{ name: "ccache", version }])
       } else if (isUbuntu()) {
         return setupAptPack([{ name: "ccache", version }])
       }

src/cppcheck/cppcheck.ts

@@ -23,7 +23,7 @@ export async function setupCppcheck(version: string | undefined, _setupDir: stri
       if (isArch()) {
         return setupPacmanPack("cppcheck", version)
       } else if (hasDnf()) {
-        return setupDnfPack("ccache", version)
+        return setupDnfPack([{ name: "ccache", version }])
       } else if (isUbuntu()) {
         return setupAptPack([{ name: "cppcheck", version }])
       }

src/doxygen/doxygen.ts

@@ -73,7 +73,7 @@ export async function setupDoxygen(version: string, setupDir: string, arch: stri
         if (isArch()) {
           installationInfo = await setupPacmanPack("doxygen", version)
         } else if (hasDnf()) {
-          return setupDnfPack("doxygen", version)
+          return setupDnfPack([{ name: "doxygen", version }])
         } else if (isUbuntu()) {
           installationInfo = await setupAptPack([{ name: "doxygen", version }])
         } else {

src/gcc/gcc.ts

@@ -98,9 +98,11 @@ export async function setupGcc(version: string, setupDir: string, arch: string)
         if (isArch()) {
           installationInfo = await setupPacmanPack("gcc", version)
         } else if (hasDnf()) {
-          installationInfo = setupDnfPack("gcc", version)
+          installationInfo = await setupDnfPack([
-          setupDnfPack("gcc-c++", version)
+            { name: "gcc", version },
-          setupDnfPack("libstdc++-devel", undefined)
+            { name: "gcc-c++", version },
+            { name: "libstdc++-devel" },
+          ])
         } else if (isUbuntu()) {
           installationInfo = await setupAptPack([
             { name: "gcc", version, repositories: ["ppa:ubuntu-toolchain-r/test"] },

src/graphviz/graphviz.ts

@@ -23,7 +23,7 @@ export async function setupGraphviz(version: string, _setupDir: string, _arch: s
       if (isArch()) {
         return setupPacmanPack("graphviz", version)
       } else if (hasDnf()) {
-        return setupDnfPack("graphviz", version)
+        return setupDnfPack([{ name: "graphviz", version }])
       } else if (isUbuntu()) {
         return setupAptPack([{ name: "graphviz", version }])
       }

src/kcov/kcov.ts

@@ -47,8 +47,7 @@ async function buildKcov(file: string, dest: string) {
     if (isArch()) {
       await Promise.all([setupPacmanPack("libdwarf"), setupPacmanPack("libcurl-openssl")])
     } else if (hasDnf()) {
-      setupDnfPack("libdwarf-devel")
+      await setupDnfPack([{ name: "libdwarf-devel" }, { name: "libcurl-devel" }])
-      setupDnfPack("libcurl-devel")
     } else if (isUbuntu()) {
       await setupAptPack([{ name: "libdw-dev" }, { name: "libcurl4-openssl-dev" }])
     }
@@ -116,7 +115,7 @@ export async function setupKcov(versionGiven: string, setupDir: string, arch: st
     if (isArch()) {
       await setupPacmanPack("binutils")
     } else if (hasDnf()) {
-      setupDnfPack("binutils")
+      await setupDnfPack([{ name: "binutils" }])
     } else if (isUbuntu()) {
       await setupAptPack([{ name: "libbinutils" }])
     }

src/make/make.ts

@@ -23,7 +23,7 @@ export async function setupMake(version: string, _setupDir: string, _arch: strin
       if (isArch()) {
         return setupPacmanPack("make", version)
       } else if (hasDnf()) {
-        return setupDnfPack("make", version)
+        return setupDnfPack([{ name: "make", version }])
       } else if (isUbuntu()) {
         return setupAptPack([{ name: "make", version }])
       }

src/powershell/powershell.ts

@@ -26,12 +26,12 @@ export async function setupPowershell(version: string | undefined, _setupDir: st
       if (isArch()) {
         return setupPacmanPack("powershell-bin", version, "yay")
       } else if (hasDnf()) {
-        setupDnfPack("curl")
+        setupDnfPack([{ name: "curl" }])
         execRootSync("/bin/bash", [
           "-c",
           `curl https://packages.microsoft.com/config/rhel/8/prod.repo | sudo tee /etc/yum.repos.d/microsoft.repo`,
         ])
-        return setupDnfPack("powershell", version)
+        return setupDnfPack([{ name: "powershell", version }])
       } else if (isUbuntu()) {
         await setupAptPack([{ name: "curl" }])
         const ubuntuVerSplitted = (await ubuntuVersion())!

src/python/python.ts

@@ -112,7 +112,7 @@ async function setupPythonSystem(setupDir: string, version: string) {
       if (isArch()) {
         installInfo = await setupPacmanPack("python", version)
       } else if (hasDnf()) {
-        installInfo = setupDnfPack("python3", version)
+        installInfo = await setupDnfPack([{ name: "python3", version }])
       } else if (isUbuntu()) {
         installInfo = await setupAptPack([{ name: "python3", version }, { name: "python-is-python3" }])
       } else {
@@ -234,7 +234,7 @@ function setupPipSystem() {
     if (isArch()) {
       return setupPacmanPack("python-pip")
     } else if (hasDnf()) {
-      return setupDnfPack("python3-pip")
+      return setupDnfPack([{ name: "python3-pip" }])
     } else if (isUbuntu()) {
       return setupAptPack([{ name: "python3-pip" }])
     }

src/sevenzip/sevenzip.ts

@@ -20,8 +20,10 @@ export function setupSevenZip(version: string, _setupDir: string, _arch: string)
       if (isArch()) {
         return setupPacmanPack("p7zip", version)
       } else if (hasDnf()) {
-        setupDnfPack("p7zip", version)
+        return setupDnfPack([
-        return setupDnfPack("p7zip-plugins", version)
+          { name: "p7zip", version },
+          { name: "p7zip-plugins", version },
+        ])
       } else if (isUbuntu()) {
         return setupAptPack([{ name: "p7zip-full", version }])
       }

src/utils/setup/setupBin.ts

@@ -107,9 +107,7 @@ export async function setupBin(
           if (isArch()) {
             await Promise.all([setupPacmanPack("unzip"), setupPacmanPack("tar"), setupPacmanPack("xz")])
           } else if (hasDnf()) {
-            setupDnfPack("unzip")
+            await setupDnfPack([{ name: "unzip" }, { name: "tar" }, { name: "xz" }])
-            setupDnfPack("tar")
-            setupDnfPack("xz")
           } else if (isUbuntu()) {
             await setupAptPack([{ name: "unzip" }, { name: "tar" }, { name: "xz-utils" }])
           }

src/utils/setup/setupDnfPack.ts

@@ -1,31 +1,35 @@
-/* eslint-disable require-atomic-updates */
 import { InstallationInfo } from "./setupBin"
 import { execRootSync } from "admina"
 import { info, warning } from "ci-log"
+import { execa } from "execa"
 
-// let didUpdate: boolean = false
+export type DnfPackage = {
+  name: string
+  version?: string
+}
 
 /** A function that installs a package using dnf */
-export function setupDnfPack(name: string, version?: string): InstallationInfo {
+export async function setupDnfPack(packages: DnfPackage[]): Promise<InstallationInfo> {
+  for (const { name, version } of packages) {
     info(`Installing ${name} ${version ?? ""} via dnf`)
-
-  const dnf = "dnf"
-
-  // if (!didUpdate) {
-  //   execRootSync(dnf, ["-y", "check-update"])
-  //   didUpdate = true
-  // }
-
-  if (version !== undefined && version !== "") {
-    try {
-      execRootSync(dnf, ["-y", "install", `${name}-${version}`])
-    } catch (err) {
-      warning(`${(err as Error).toString()}\nInstalling the default version available via dnf`)
-      execRootSync(dnf, ["-y", "install", name])
-    }
-  } else {
-    execRootSync(dnf, ["-y", "install", name])
   }
 
+  const dnfArgs = await Promise.all(packages.map((pack) => getDnfArg(pack.name, pack.version)))
+  execRootSync("dnf", ["-y", "install", ...dnfArgs])
+
   return { binDir: "/usr/bin/" }
 }
+
+async function getDnfArg(name: string, version: string | undefined) {
+  if (version !== undefined && version !== "") {
+    // check if name-version is available
+    const { stdout } = await execa("dnf", ["search", `${name}-${version}`, "--exact", "--quiet"])
+
+    if (stdout.trim() !== "") {
+      return `${name}-${version}`
+    } else {
+      warning(`Failed to install ${name} ${version} via dnf, trying without version`)
+    }
+  }
+  return name
+}

src/vcpkg/vcpkg.ts

@@ -30,12 +30,14 @@ export async function setupVcpkg(_version: string, setupDir: string, _arch: stri
           setupPacmanPack("pkg-config"),
         ])
       } else if (hasDnf()) {
-        setupDnfPack("curl")
+        await setupDnfPack([
-        setupDnfPack("zip")
+          { name: "curl" },
-        setupDnfPack("unzip")
+          { name: "zip" },
-        setupDnfPack("tar")
+          { name: "unzip" },
-        setupDnfPack("git")
+          { name: "tar" },
-        setupDnfPack("pkg-config")
+          { name: "git" },
+          { name: "pkg-config" },
+        ])
       } else if (isUbuntu()) {
         await setupAptPack([
           { name: "curl" },