chore: improve architecture detection and logic

pkg/apk/apk.go

@@ -30,6 +30,7 @@ func (a *Apk) BuildPackage(artifactsPath string) error {
 // It initializes the apkDir, cleans up any existing directory, creates the necessary packer directory,
 // and generates the APKBUILD and post-installation script files. The method returns an error if any step fails.
 func (a *Apk) PrepareFakeroot(_ string) error {
+	a.PKGBUILD.ArchComputed = APKArchs[a.PKGBUILD.ArchComputed]
 	a.apkDir = filepath.Join(a.PKGBUILD.StartDir, "apk")
 
 	if err := utils.RemoveAll(a.apkDir); err != nil {
@@ -62,24 +63,22 @@ func (a *Apk) PrepareFakeroot(_ string) error {
 // It takes a string parameter `artifactsPath` which specifies the path where the artifacts are located.
 // It returns an error if there was an error during the installation process.
 func (a *Apk) Install(artifactsPath string) error {
-	for _, arch := range a.PKGBUILD.Arch {
-		pkgName := a.PKGBUILD.PkgName + "-" +
-			a.PKGBUILD.PkgVer +
-			"-" +
-			"r" + a.PKGBUILD.PkgRel +
-			"-" +
-			arch +
-			".apk"
-
-		pkgFilePath := filepath.Join(artifactsPath, a.PKGBUILD.PkgName, arch, pkgName)
-
-		if err := utils.Exec(true,
-			"apk",
-			"add",
-			"--allow-untrusted",
-			pkgFilePath); err != nil {
-			return err
-		}
+	pkgName := a.PKGBUILD.PkgName + "-" +
+		a.PKGBUILD.PkgVer +
+		"-" +
+		"r" + a.PKGBUILD.PkgRel +
+		"-" +
+		a.PKGBUILD.ArchComputed +
+		".apk"
+
+	pkgFilePath := filepath.Join(artifactsPath, a.PKGBUILD.PkgName, a.PKGBUILD.ArchComputed, pkgName)
+
+	if err := utils.Exec(true,
+		"apk",
+		"add",
+		"--allow-untrusted",
+		pkgFilePath); err != nil {
+		return err
 	}
 
 	return nil

pkg/apk/constants.go

@@ -1,8 +1,19 @@
 package apk
 
-var buildEnvironmentDeps = []string{
-	"alpine-sdk",
-}
+var (
+	APKArchs = map[string]string{
+		"x86_64":  "x86_64",
+		"i686":    "x86",
+		"aarch64": "aarch64",
+		"armv7h":  "armv7h",
+		"armv6h":  "armv6h",
+		"any":     "all",
+	}
+
+	buildEnvironmentDeps = []string{
+		"alpine-sdk",
+	}
+)
 
 const postInstall = `
 {{- if .PreInst}}
@@ -51,7 +62,9 @@ epoch={{.Epoch}}
 pkgver={{.PkgVer}}
 pkgrel={{.PkgRel}}
 pkgdesc="{{.PkgDesc}}"
-arch="all"
+{{- if .ArchComputed}}
+arch="{{.ArchComputed}}"
+{{- end}}
 {{- if .Depends}}
 depends="
 {{ range .Depends }}{{ . }} 

pkg/constants/constants.go

@@ -27,11 +27,11 @@ var (
 
 	DistroToPackageManager = map[string]string{
 		"alpine": "alpine",
-		"arch":   "pacman",
 		"amazon": "redhat",
-		"fedora": "redhat",
+		"arch":   "pacman",
 		"centos": "redhat",
 		"debian": "debian",
+		"fedora": "redhat",
 		"oracle": "redhat",
 		"rocky":  "redhat",
 		"ubuntu": "debian",

pkg/dpkg/constants.go

@@ -33,8 +33,8 @@ Version: {{ if .Epoch}}{{ .Epoch }}:{{ end }}{{.PkgVer}}
          {{- if .PkgRel}}-{{ .PkgRel }}{{- end }}
 Section: {{.Section}}
 Priority: {{.Priority}}
-{{- with .Arch}}
-Architecture: {{join .}}
+{{- if .ArchComputed}}
+Architecture: {{.ArchComputed}}
 {{- end }}
 {{- /* Optional fields */ -}}
 {{- if .Maintainer}}

pkg/dpkg/dpkg.go

@@ -26,17 +26,12 @@ type Deb struct {
 	PKGBUILD *pkgbuild.PKGBUILD
 }
 
-// getArch updates the architecture field in the Deb struct.
-//
-// It iterates over the architecture values in the PKGBUILD field of the Deb struct
-// and replaces them with the corresponding values from the DebArchs map.
-func (d *Deb) getArch() {
-	for index, arch := range d.PKGBUILD.Arch {
-		d.PKGBUILD.Arch[index] = DebArchs[arch]
-	}
-}
-
+// createTarZst creates a compressed tar.zst archive from the specified source directory.
+// It takes the source directory and the output file path as arguments and returns an error if any occurs.
 func createTarZst(sourceDir, outputFile string) error {
+	// Retrieve the list of files from the source directory on disk.
+	// The map specifies that the files should be read from the sourceDir
+	// and the output path in the archive should be empty.
 	files, err := archiver.FilesFromDisk(nil, map[string]string{
 		sourceDir + string(os.PathSeparator): "",
 	})
@@ -61,13 +56,10 @@ func createTarZst(sourceDir, outputFile string) error {
 	return format.Archive(context.Background(), out, files)
 }
 
-// createConfFiles creates the conffiles file in the Deb package.
-//
-// It iterates over the Backup field of the PKGBUILD struct and adds each name
-// to the data string. The data string is then written to the conffiles file
-// located at the debDir path.
-//
-// Returns an error if there was a problem creating or writing to the file.
+// createConfFiles creates the configuration files for the Debian package.
+// It generates a file located at the debDir path containing the backup
+// files specified in the PKGBUILD. Returns an error if there was a
+// problem creating or writing to the file.
 func (d *Deb) createConfFiles() error {
 	if len(d.PKGBUILD.Backup) == 0 {
 		return nil
@@ -88,6 +80,10 @@ func (d *Deb) createConfFiles() error {
 	return utils.CreateWrite(path, data)
 }
 
+// createCopyrightFile generates a copyright file for the Debian package.
+// It checks if there is a license specified in the PKGBUILD and creates
+// the copyright file accordingly. Returns an error if there was an
+// issue creating the file.
 func (d *Deb) createCopyrightFile() error {
 	if len(d.PKGBUILD.License) == 0 {
 		return nil
@@ -99,13 +95,10 @@ func (d *Deb) createCopyrightFile() error {
 	return d.PKGBUILD.CreateSpec(copyrightFilePath, tmpl)
 }
 
-// createDebconfFile creates a debconf file with the given variable and name.
-//
-// Parameters:
-// - variable: the variable used to create the debconf asset.
-// - name: the name of the debconf asset.
-//
-// Return type: error.
+// createDebconfFile creates a debconf file with the given variable and
+// name. It takes parameters for the variable used to create the debconf
+// asset and the name of the debconf asset. Returns an error if there
+// was an issue during the creation.
 func (d *Deb) createDebconfFile(name, variable string) error {
 	if variable == "" {
 		return nil
@@ -118,9 +111,8 @@ func (d *Deb) createDebconfFile(name, variable string) error {
 }
 
 // createScripts generates and writes the scripts for the Deb package.
-//
-// It takes no parameters.
-// It returns an error if there was an issue generating or writing the scripts.
+// It takes no parameters and returns an error if there was an issue
+// generating or writing the scripts.
 func (d *Deb) createScripts() error {
 	scripts := map[string]string{
 		"preinst":  d.PKGBUILD.PreInst,
@@ -153,18 +145,15 @@ func (d *Deb) createScripts() error {
 }
 
 // createDeb generates Deb package files from the given artifact path.
-//
-// It takes a string parameter `artifactPath` which represents the path where the
-// Deb package files will be generated.
-//
-// The function returns an error if there was an issue generating the Deb package
-// files.
+// It takes a string parameter `artifactPath` which represents the path
+// where the Deb package files will be generated. The function returns
+// an error if there was an issue generating the Deb package files.
 func (d *Deb) createDeb(artifactPath, control, data string) error {
 	// Create the .deb package
 	artifactFilePath := filepath.Join(artifactPath,
 		fmt.Sprintf("%s_%s-%s_%s.deb",
 			d.PKGBUILD.PkgName, d.PKGBUILD.PkgVer, d.PKGBUILD.PkgRel,
-			d.PKGBUILD.Arch[0]))
+			d.PKGBUILD.ArchComputed))
 
 	cleanFilePath := filepath.Clean(artifactFilePath)
 	debianBinary := []byte(binaryContent)
@@ -346,8 +335,8 @@ func (d *Deb) BuildPackage(artifactsPath string) error {
 // It retrieves architecture and release information, cleans up the debDir, creates necessary
 // resources, and strips binaries. The method returns an error if any step fails.
 func (d *Deb) PrepareFakeroot(_ string) error {
-	d.getArch()
 	d.getRelease()
+	d.PKGBUILD.ArchComputed = DebArchs[d.PKGBUILD.ArchComputed]
 
 	if err := utils.RemoveAll(d.debDir); err != nil {
 		return err
@@ -365,15 +354,13 @@ func (d *Deb) PrepareFakeroot(_ string) error {
 }
 
 func (d *Deb) Install(artifactsPath string) error {
-	for _, arch := range d.PKGBUILD.Arch {
-		artifactFilePath := filepath.Join(artifactsPath,
-			fmt.Sprintf("%s_%s-%s_%s.deb",
-				d.PKGBUILD.PkgName, d.PKGBUILD.PkgVer, d.PKGBUILD.PkgRel,
-				arch))
+	artifactFilePath := filepath.Join(artifactsPath,
+		fmt.Sprintf("%s_%s-%s_%s.deb",
+			d.PKGBUILD.PkgName, d.PKGBUILD.PkgVer, d.PKGBUILD.PkgRel,
+			d.PKGBUILD.ArchComputed))
 
-		if err := utils.Exec(false, "", "apt-get", "install", "-y", artifactFilePath); err != nil {
-			return err
-		}
+	if err := utils.Exec(false, "", "apt-get", "install", "-y", artifactFilePath); err != nil {
+		return err
 	}
 
 	return nil

pkg/pacman/constants.go

@@ -56,11 +56,8 @@ epoch={{.Epoch}}
 pkgver={{.PkgVer}}
 pkgrel={{.PkgRel}}
 pkgdesc="{{.PkgDesc}}"
-{{- if .Arch}}
-arch=(
-  {{ range .Arch }}"{{ . }}"
-  {{ end }}
-)
+{{- if .ArchComputed}}
+arch=({{.ArchComputed}})
 {{- end }}
 {{- if .Depends}}
 depends=(

pkg/pacman/pacman.go

@@ -63,24 +63,22 @@ func (p *Pacman) PrepareFakeroot(artifactsPath string) error {
 // artifactsPath: the path where the package artifacts are located.
 // error: an error if the installation fails.
 func (p *Pacman) Install(artifactsPath string) error {
-	for _, arch := range p.PKGBUILD.Arch {
-		pkgName := p.PKGBUILD.PkgName + "-" +
-			p.PKGBUILD.PkgVer +
-			"-" +
-			p.PKGBUILD.PkgRel +
-			"-" +
-			arch +
-			".pkg.tar.zst"
-
-		pkgFilePath := filepath.Join(artifactsPath, pkgName)
-
-		if err := utils.Exec(false, "",
-			"pacman",
-			"-U",
-			"--noconfirm",
-			pkgFilePath); err != nil {
-			return err
-		}
+	pkgName := p.PKGBUILD.PkgName + "-" +
+		p.PKGBUILD.PkgVer +
+		"-" +
+		p.PKGBUILD.PkgRel +
+		"-" +
+		p.PKGBUILD.ArchComputed +
+		".pkg.tar.zst"
+
+	pkgFilePath := filepath.Join(artifactsPath, pkgName)
+
+	if err := utils.Exec(false, "",
+		"pacman",
+		"-U",
+		"--noconfirm",
+		pkgFilePath); err != nil {
+		return err
 	}
 
 	return nil

pkg/pkgbuild/pkgbuild.go

@@ -20,6 +20,7 @@ var Verbose bool
 // templating and other rpm/deb descriptors.
 type PKGBUILD struct {
 	Arch           []string
+	ArchComputed   string
 	Backup         []string
 	Build          string
 	Codename       string
@@ -340,6 +341,31 @@ func (pkgBuild *PKGBUILD) parseDirective(input string) (string, int, error) {
 	return key, priority, nil
 }
 
+// ValidateArchitecture checks if the architecture specified in the PKGBUILD
+// is supported. If the architecture is "any", it sets the computed architecture
+// to "any". If the architecture is not "any", it checks if the current architecture
+// is in the list of supported architectures. If the current architecture is not
+// supported, it logs a fatal error with the package name. Finally, it sets the
+// computed architecture to the current architecture if it is supported.
+func (pkgBuild *PKGBUILD) ValidateArchitecture() {
+	isSupported := utils.Contains(pkgBuild.Arch, "any")
+	if isSupported {
+		pkgBuild.ArchComputed = "any"
+
+		return
+	}
+
+	currentArch := utils.GetArchitecture()
+
+	isSupported = utils.Contains(pkgBuild.Arch, currentArch)
+	if !isSupported {
+		utils.Logger.Fatal("unsupported architecture",
+			utils.Logger.Args("pkgname", pkgBuild.PkgName))
+	}
+
+	pkgBuild.ArchComputed = currentArch
+}
+
 // setMainFolders sets the main folders for the PKGBUILD.
 //
 // It takes no parameters.

pkg/project/project.go

@@ -126,7 +126,7 @@ func (mpc *MultipleProject) BuildAll() error {
 		}
 
 		if !NoBuild {
-			if err := mpc.createPackages(proj); err != nil {
+			if err := mpc.createPackage(proj); err != nil {
 				return err
 			}
 		}
@@ -249,11 +249,11 @@ func (mpc *MultipleProject) checkPkgsRange(fromPkgName, toPkgName string) {
 	}
 }
 
-// createPackages creates packages for the MultipleProject.
+// createPackage creates packages for the MultipleProject.
 //
 // It takes a pointer to a MultipleProject as a receiver and a pointer to a Project as a parameter.
 // It returns an error.
-func (mpc *MultipleProject) createPackages(proj *Project) error {
+func (mpc *MultipleProject) createPackage(proj *Project) error {
 	if mpc.Output != "" {
 		absOutput, err := filepath.Abs(mpc.Output)
 		if err != nil {
@@ -337,6 +337,8 @@ func (mpc *MultipleProject) populateProjects(distro, release, path string) error
 			return err
 		}
 
+		pkgbuildFile.ValidateArchitecture()
+
 		packageManager = packer.GetPackageManager(pkgbuildFile, distro)
 
 		proj := &Project{

pkg/project/project_test.go

@@ -19,7 +19,7 @@ pkgdesc__fedora="Http file server written with Go for Fedora"
 pkgdesc__rocky="Http file server written with Go for Rocky"
 pkgdesc__ubuntu="Http file server written with Go for Ubuntu"
 maintainer="Example <[email protected]>"
-arch=("all")
+arch=("x86_64")
 license=("GPL-3.0-only")
 section="utils"
 priority="optional"

pkg/rpm/constants.go

@@ -86,8 +86,8 @@ Epoch: {{.Epoch}}
 {{- end }}
 Version: {{.PkgVer}}
 Release: {{.PkgRel}}
-{{- with .Arch}}
-BuildArch: {{join .}}
+{{- if .ArchComputed}}
+BuildArch: {{.ArchComputed}}
 {{- end }}
 {{- if .Section}}
 Group: {{.Section}}