Resolved multiple issues and made some improvements related to low memory situations

- Added a section to the README on how to detect failed package builds because of low memory
- Adjusted the builder OOM score to make it more likely the builder will be killed in low RAM situations instead of (potentially more crucial) applications on the host machine
- Fixed issue that could cause the builder docker image build to fail due to an outdated archlinux-keyring when you have really unfortunate timing
- Unpromisified a couple of functions that were synchronous inside, as this has no added benefit
- AUR packages that have a different package base are now cloned correctly
  - Example: The rog-control-center AUR package has asusctl set as it's base, causing the GIT clone URL to be different
- Fixed a dependency resolve loop in very specific cases
  - Example: The rog-control-center AUR package has asusctl as a dependency, but the rog-control-center package is provided by the asusctl package, causing an infinite loop

Author: CrazyVito11

README.md

@@ -116,6 +116,16 @@ Simply download the package from there and then install it manually with `pacman
 > Older versions of packages are automatically cleaned up after 30 days to preserve storage space on your server.
 
 
+### Package build fails with a SIGKILL
+Chances are that the build process consumed too much memory and was killed by the Docker engine or the host operating system.
+The builder process has been given a high OOM score to make sure it is killed first, instead of other _(potentially more crucial)_ applications.
+
+To resolve this, you will have to raise the builder memory limit, free up more RAM on the host machine or upgrade the host machine to have more RAM.
+
+> [!TIP]
+> Sometimes the AUR also provides `-bin` _(precompiled binary)_ variants of a package, this could also be a solution to work around the issue.
+
+
 ### Access the build reports
 The application generates a report every time it runs the build process, allowing you to more easily troubleshoot troublesome packages.
 

build-manager/docker/Dockerfile

@@ -2,6 +2,7 @@ FROM --platform=linux/amd64 archlinux:multilib-devel
 
 # Update the image and install dependencies
 RUN pacman-key --init
+RUN pacman -Sy --noconfirm archlinux-keyring
 RUN pacman -Syu --noconfirm fcron nodejs-lts-iron npm docker
 
 # Create the builder user

build-manager/src/build-manager.ts

@@ -214,6 +214,7 @@ const handlePackageList = async (aurPackageListPath: string) => {
                 User: 'builder',
                 Cmd: ['/bin/bash', '-c', command],
                 HostConfig: {
+                    OomScoreAdj: 1000, // Make it more likely the builder will be killed in low RAM situations instead of (potentially more crucial) applications
                     Mounts: BuilderHelper.getBuilderMounts(),
                     CpusetCpus: packageListConfiguration.builderLimit.cpusetCpus,
                     Memory: FilesystemHelper.stringifiedSizeToBytes(packageListConfiguration.builderLimit.memory)

builder/Dockerfile

@@ -3,6 +3,7 @@ FROM --platform=linux/amd64 archlinux:multilib-devel
 # Update the image and install dependencies
 ENV CARCH=x86_64
 RUN pacman-key --init
+RUN pacman -Sy --noconfirm archlinux-keyring
 RUN pacman -Syu --noconfirm git base-devel fcron nodejs-lts-iron npm
 
 # Create the builder user

builder/src/Helpers/MakepkgHelper.ts

@@ -3,37 +3,35 @@ import { execSync } from "child_process";
 export default class MakepkgHelper {
     private static makepkgPrintSrcRegex = new RegExp(/^\s*([a-z0-9]+)\ \=\ (.+)$/gm);
 
-    public static parsePkgbuildFile(pkgbuildFilePath: string): Promise<object> {
-        return new Promise(async (resolve) => {
-            const consoleOutput = execSync(`cd $(dirname $(readlink -f "${pkgbuildFilePath}")); makepkg --printsrcinfo`);
-            const matches       = consoleOutput.toString().matchAll(MakepkgHelper.makepkgPrintSrcRegex);
+    public static parsePkgbuildFile(pkgbuildFilePath: string): object {
+        const consoleOutput = execSync(`cd $(dirname $(readlink -f "${pkgbuildFilePath}")); makepkg --printsrcinfo`);
+        const matches       = consoleOutput.toString().matchAll(MakepkgHelper.makepkgPrintSrcRegex);
 
-            const parsedData: Record<string, any> = {};
+        const parsedData: Record<string, any> = {};
 
-            for (const match of matches) {
-                const key = match[1];
-                const value = match[2];
+        for (const match of matches) {
+            const key = match[1];
+            const value = match[2];
 
-                // Does the key already exist and is it not an array yet?
-                // If so, wrap it into an array
-                if (key in parsedData && ! (parsedData[key] instanceof Array)) {
-                    parsedData[key] = [parsedData[key]];
-                }
-
-                // Does the key already exist and is it already an array?
-                // If so, push the item
-                if (key in parsedData && parsedData[key] instanceof Array) {
-                    parsedData[key].push(value);
+            // Does the key already exist and is it not an array yet?
+            // If so, wrap it into an array
+            if (key in parsedData && ! (parsedData[key] instanceof Array)) {
+                parsedData[key] = [parsedData[key]];
+            }
 
-                    continue;
-                }
+            // Does the key already exist and is it already an array?
+            // If so, push the item
+            if (key in parsedData && parsedData[key] instanceof Array) {
+                parsedData[key].push(value);
 
-                // It's a "regular" item, simply push it
-                parsedData[key] = value;
+                continue;
             }
 
-            resolve(parsedData);
-        });
+            // It's a "regular" item, simply push it
+            parsedData[key] = value;
+        }
+
+        return parsedData;
     }
 
     public static getDependsFromPkgbuildData(pkgbuildData: object): Array<string> {

builder/src/Helpers/PackageHelper.ts

@@ -14,50 +14,53 @@ export default class PackageHelper {
         return PackageHelper.validPackageNameRegex.test(packageName);
     }
 
-    public static isSystemPackage(packageName: string): Promise<boolean> {
-        return new Promise(async (resolve, reject) => {
-            if (! PackageHelper.isValidPackageName(packageName)) {
-                console.warn(`[builder] System package "${packageName}" has an invalid name`);
+    public static isSystemPackage(packageName: string): boolean {
+        if (! PackageHelper.isValidPackageName(packageName)) {
+            console.warn(`[builder] System package "${packageName}" has an invalid name`);
 
-                return resolve(false);
-            }
+            return false;
+        }
 
-            try {
-                execSync(`pacman -Si ${packageName}`);
+        try {
+            execSync(`pacman -Si ${packageName}`);
 
-                return resolve(true);
-            } catch (error: any) {
-                const errorStatus = error.status;
-                const errorOutput = error?.stderr?.toString();
+            return true;
+        } catch (error: any) {
+            const errorStatus = error.status;
+            const errorOutput = error?.stderr?.toString();
 
-                // Check if the error is it telling us the package doesn't exist
-                if (errorStatus === 1 && PackageHelper.packageNotFoundRegex.test(errorOutput)) {
-                    console.warn(`[builder] System package ${packageName} doesn't exist`);
-                    return resolve(false);
-                }
+            // Check if the error is it telling us the package doesn't exist
+            if (errorStatus === 1 && PackageHelper.packageNotFoundRegex.test(errorOutput)) {
+                console.warn(`[builder] System package ${packageName} doesn't exist`);
 
-                reject(error);
+                return false;
             }
-        });
+
+            throw error;
+        }
     }
 
-    public static isAurPackage(params: Parameters, packageName: string): Promise<boolean> {
-        return new Promise(async (resolve, reject) => {
-            if (! PackageHelper.isValidPackageName(packageName)) {
-                console.warn(`[builder] AUR package "${packageName}" has an invalid name`);
+    public static isAurPackage(params: Parameters, packageName: string): boolean {
+        return !! PackageHelper.getAurPackageInformationByPackageName(params, packageName);
+    }
 
-                return resolve(false);
-            }
+    public static getAurPackageInformationByPackageName(params: Parameters, packageName: string): AurRpcApiPackage | null {
+        if (! PackageHelper.isValidPackageName(packageName)) {
+            console.warn(`[builder] AUR package "${packageName}" has an invalid name`);
 
-            const jsonRaw = fs.readFileSync(params.aur_package_list_path, 'utf8');
-            const jsonParsed: Array<AurRpcApiPackage> = JSON.parse(jsonRaw);
+            return null;
+        }
 
-            const foundPackage = !! jsonParsed.find((packageItem) => packageItem.Name === packageName);
+        const jsonRaw = fs.readFileSync(params.aur_package_list_path, 'utf8');
+        const jsonParsed: Array<AurRpcApiPackage> = JSON.parse(jsonRaw);
 
-            resolve(foundPackage);
+        const foundPackage = jsonParsed.find((packageItem) => packageItem.Name === packageName);
 
-            return;
-        });
+        if (! foundPackage) {
+            return null;
+        }
+
+        return foundPackage;
     }
 
     public static getPackagesInDirectory(directoryPath: string): Array<string> {
@@ -84,7 +87,7 @@ export default class PackageHelper {
                 console.log(`[builder] AUR package ${packageName} directory doesn't seem to exist yet`);
 
                 // Make sure it's a valid AUR package
-                if (! await PackageHelper.isAurPackage(params, packageName)) {
+                if (! PackageHelper.isAurPackage(params, packageName)) {
                     console.error(`[builder] isAurPackage reports ${packageName} to not be an existing AUR package!`);
 
                     return reject("Invalid AUR package");
@@ -97,7 +100,7 @@ export default class PackageHelper {
 
 
             const pkgbuildPath = `${fullPackagePath}/PKGBUILD`;
-            const pkgbuildData = await MakepkgHelper.parsePkgbuildFile(pkgbuildPath);
+            const pkgbuildData = MakepkgHelper.parsePkgbuildFile(pkgbuildPath);
 
             const dependsPackages      = MakepkgHelper.getDependsFromPkgbuildData(pkgbuildData);
             const makeDependsPackages  = MakepkgHelper.getMakeDependsFromPkgbuildData(pkgbuildData);
@@ -106,23 +109,23 @@ export default class PackageHelper {
             console.log(`[builder] Installing make dependencies for ${packageName}`);
             await Promise.all(
                 makeDependsPackages.map((dependencyPackageName: string) => 
-                    PackageHelper.installPackage(params, dependencyPackageName)
+                    PackageHelper.installPackage(params, dependencyPackageName, packageName)
                 )
             );
             console.log(`[builder] Done installing make dependencies for ${packageName}`);
 
             console.log(`[builder] Installing check dependencies for ${packageName}`);
             await Promise.all(
                 checkDependsPackages.map((dependencyPackageName: string) => 
-                    PackageHelper.installPackage(params, dependencyPackageName)
+                    PackageHelper.installPackage(params, dependencyPackageName, packageName)
                 )
             );
             console.log(`[builder] Done installing check dependencies for ${packageName}`);
 
             console.log(`[builder] Installing dependencies for ${packageName}`);
             await Promise.all(
                 dependsPackages.map((dependencyPackageName: string) => 
-                    PackageHelper.installPackage(params, dependencyPackageName)
+                    PackageHelper.installPackage(params, dependencyPackageName, packageName)
                 )
             );
             console.log(`[builder] Done installing dependencies for ${packageName}`);
@@ -168,7 +171,7 @@ export default class PackageHelper {
         });
     }
 
-    public static installPackage(params: Parameters, packageName: string): Promise<void> {
+    public static installPackage(params: Parameters, packageName: string, dependencyOf: string | null = null): Promise<void> {
         return new Promise(async (resolve, reject) => {
             const packageConfiguration = params.package_configuration;
             let realPackageName = packageName;
@@ -189,6 +192,14 @@ export default class PackageHelper {
                 return;
             }
 
+            if (packageType.packageToInstall === dependencyOf) {
+                console.warn(`[builder] The package "${dependencyOf}" tells us it requires "${packageType.packageToInstall}" as a dependency, which would cause an endless loop. We will just ignore this request.`);
+
+                resolve();
+
+                return;
+            }
+
             if (packageType.type === 'system') {
                 console.log(`[builder] Installing system package "${packageType.packageToInstall}"`);
 

builder/src/Helpers/PackageTypeHelper.ts

@@ -20,6 +20,10 @@ export default class PackageTypeHelper {
 
             const aurResult = await PackageTypeHelper.checkAURPackage(params, packageName);
             if (aurResult) {
+                if (aurResult.packageToInstall !== packageName) {
+                    console.warn(`[builder] Package "${packageName}" has a different package base according to the AUR, building "${aurResult.packageToInstall}" instead`);
+                }
+
                 resolve(aurResult);
 
                 return;
@@ -54,7 +58,7 @@ export default class PackageTypeHelper {
     }
 
     private static async checkSystemPackageViaPacman(packageName: string): Promise<PackageType | null> {
-        const result = await PackageHelper.isSystemPackage(packageName);
+        const result = PackageHelper.isSystemPackage(packageName);
 
         if (result) {
             return {
@@ -67,12 +71,14 @@ export default class PackageTypeHelper {
     }
 
     private static async checkAURPackage(params: Parameters, packageName: string): Promise<PackageType | null> {
-        const result = await PackageHelper.isAurPackage(params, packageName);
+        const result = PackageHelper.getAurPackageInformationByPackageName(params, packageName);
 
         if (result) {
+            const packageBaseIsDifferent = packageName !== result.PackageBase;
+
             return {
                 type: 'aur',
-                packageToInstall: packageName
+                packageToInstall: packageBaseIsDifferent ? result.PackageBase : packageName
             };
         }