Support cross platform builds

Add support for cross building the following platforms:

- `linux/i386`
- `linux/amd64`
- `linux/arm`
- `linux/arm/v5`
- `linux/arm/v6`
- `linux/arm/v7`
- `linux/arm64`
- `linux/arm64/v8`
- `linux/ppc64le`
- `linux/s390x`

To build for a different platform other than the local native platform the
`qemu-user-static` package must be installed.

Example build for an ARM platform:
```
make PLATFORM=linux/arm all-images
```

Once the images are built it's necessary to clean the images before building
for another platform or the build will fail:
```
make clean-images
make PLATFORM=linux/ppc64le all-images
```

Author: mmartinv

Makefile

@@ -16,30 +16,50 @@
 #
 
 BUILDER ?= docker
+PLATFORM ?= linux/amd64
 VERSION ?= latest
 IMAGE ?= weechat
 
+ALPINE_BASE_IMAGE = alpine:3.15
+DEBIAN_BASE_IMAGE = debian:bullseye-slim
+
+TEST_IMAGE = $(IMAGE)
+ifeq ($(strip $(BUILDER)),podman)
+	TEST_IMAGE=localhost/$(IMAGE)
+endif
+
+TEST_VERSION = $(VERSION)
+ifeq ($(strip $(TEST_VERSION)),$(filter $(VERSION),latest stable))
+	TEST_VERSION=$(shell curl "https://weechat.org/dev/info/stable/")
+endif
+
 .PHONY: all debian debian-slim alpine alpine-slim
 
 all: debian
 
 all-images: debian debian-slim alpine alpine-slim
 
 debian:
-	./build.py -b "$(BUILDER)" -d "debian" "$(VERSION)"
+	./build.py -b "$(BUILDER)" -p "$(PLATFORM)" -d "debian" "$(VERSION)"
 
 debian-slim:
-	./build.py -b "$(BUILDER)" -d "debian" --slim "$(VERSION)"
+	./build.py -b "$(BUILDER)" -p "$(PLATFORM)" -d "debian" --slim "$(VERSION)"
 
 alpine:
-	./build.py -b "$(BUILDER)" -d "alpine" "$(VERSION)"
+	./build.py -b "$(BUILDER)" -p "$(PLATFORM)" -d "alpine" "$(VERSION)"
 
 alpine-slim:
-	./build.py -b "$(BUILDER)" -d "alpine" --slim "$(VERSION)"
+	./build.py -b "$(BUILDER)" -p "$(PLATFORM)" -d "alpine" --slim "$(VERSION)"
 
 test-container:
-	"$(BUILDER)" run "$(IMAGE)" weechat --version
-	"$(BUILDER)" run "$(IMAGE)" weechat-headless --version
+	$(BUILDER) run --rm --platform "$(PLATFORM)" "$(TEST_IMAGE):$(TEST_VERSION)" weechat --version
+	$(BUILDER) run --rm --platform "$(PLATFORM)" "$(TEST_IMAGE):$(TEST_VERSION)" weechat-headless --version
+
+clean-images:
+	$(BUILDER) images --format="{{.Repository}}:{{.Tag}}" $(IMAGE) | xargs --no-run-if-empty $(BUILDER) rmi -f
+	$(BUILDER) images --format="{{.Repository}}:{{.Tag}}" $(ALPINE_BASE_IMAGE) | xargs --no-run-if-empty $(BUILDER) rmi -f
+	$(BUILDER) images --format="{{.Repository}}:{{.Tag}}" $(DEBIAN_BASE_IMAGE) | xargs --no-run-if-empty $(BUILDER) rmi -f
+	$(BUILDER) image prune -f
 
 lint: flake8 pylint mypy bandit
 

README.md

@@ -31,6 +31,23 @@ The slim version includes all plugins except these ones:
 - scripting languages: perl, python, ruby, lua, tcl, guile, php
 - spell
 
+## Supported platforms
+
+It's possible to build for different linux platforms other than amd64,
+the only prerequisite is to have `qemu-user-static` package installed
+
+- `linux/i386`
+- `linux/amd64`
+- `linux/arm`
+- `linux/arm/v5`
+- `linux/arm/v6`
+- `linux/arm/v7`
+- `linux/arm64`
+- `linux/arm64/v8`
+- `linux/ppc64le`
+- `linux/s390x`
+
+
 ## Install from Docker Hub
 
 You can install directly the latest version from the Docker Hub:
@@ -72,6 +89,20 @@ Build all images with latest stable version of WeeChat:
 $ make all-images
 ```
 
+Build all images with latest stable version of WeeChat for ARM platform:
+
+```
+$ make PLATFORM=linux/arm all-images
+```
+
+Once the images are built it's necessary to clean the images before building
+for another platform or the build will fail:
+
+```
+$ make clean-images
+$ make PLATFORM=linux/ppc64le all-images
+```
+
 Build an Alpine-based image with Podman, slim version, WeeChat 3.6:
 
 ```

build.py

@@ -18,25 +18,53 @@
 
 """Build WeeChat container image."""
 
-from typing import List, Sequence, Tuple
+from typing import List, Sequence, Tuple, Dict
 
 import argparse
 import urllib.request
 import subprocess  # nosec
 
+BUILDERS: Sequence[str] = (
+    "docker",
+    "podman",
+)
+
 DISTROS: Sequence[str] = (
     "debian",
     "alpine",
 )
 
+SUPPORTED_PLATFORMS: Dict[str, Dict[str, List[str]]] = {
+  "linux": {
+    "i386": [],
+    "amd64": [],
+    "arm": ["v5", "v6", "v7"],
+    "arm64": ["v8"],
+    "ppc64le": [],
+    "s390x": [],
+  },
+}
+
+
+def generate_valid_platforms() -> list[str]:
+    """Return the list of supported platforms."""
+    valid_platforms = []
+    for os_name, archs in SUPPORTED_PLATFORMS.items():
+        for arch, variants in archs.items():
+            valid_platforms.append(f"{os_name}/{arch}")
+            for variant in variants:
+                valid_platforms.append(f"{os_name}/{arch}/{variant}")
+    return valid_platforms
+
 
 def get_parser() -> argparse.ArgumentParser:
     """Return the command line parser."""
     parser = argparse.ArgumentParser(description="Build of WeeChat container")
     parser.add_argument(
         "-b",
         "--builder",
-        default="docker",
+        choices=BUILDERS,
+        default=BUILDERS[0],
         help=(
             "program used to build the container image, "
             "like docker (default) or podman"
@@ -49,6 +77,13 @@ def get_parser() -> argparse.ArgumentParser:
         default=DISTROS[0],
         help="base Linux distribution for the container",
     )
+    parser.add_argument(
+        "-p",
+        "--platform",
+        default="linux/amd64",
+        choices=generate_valid_platforms(),
+        help="platform for the container",
+    )
     parser.add_argument(
         "-n",
         "--dry-run",
@@ -130,6 +165,8 @@ def main() -> None:
     command = [
         f"{args.builder}",
         "build",
+        "--platform",
+        f"{args.platform}",
         "-f",
         f"{args.distro}/Containerfile",
         "--build-arg",