#!/usr/bin/env python3 # build.py - Build packages in a Docker wrapper # # Part of the Jellyfin CI system ############################################################################### from datetime import datetime from email.utils import format_datetime, localtime from os import system import os.path from subprocess import run, PIPE import sys from git import Repo # Determine top level directory of this repository ("jellyfin-packaging") revparse = run(["git", "rev-parse", "--show-toplevel"], stdout=PIPE) repo_root_dir = revparse.stdout.decode().strip() # Base Docker commands docker_build_cmd = "docker build --progress=plain --no-cache" docker_run_cmd = "docker run --rm" def build_package_deb(jellyfin_version, build_type, build_arch, build_version): try: os_type = build_type if build_type in configurations.keys() else None if os_type is None: raise ValueError(f"{build_type} is not a valid OS type in {configurations.keys()}") os_version = configurations[build_type]['releases'][build_version] if build_version in configurations[build_type]['releases'].keys() else None if os_version is None: raise ValueError(f"{build_version} is not a valid {build_type} version in {configurations[build_type]['releases'].keys()}") PACKAGE_ARCH = configurations[build_type]['archmaps'][build_arch]['PACKAGE_ARCH'] if build_arch in configurations[build_type]['archmaps'].keys() else None if PACKAGE_ARCH is None: raise ValueError(f"{build_arch} is not a valid {build_type} {build_version} architecture in {configurations[build_type]['archmaps'].keys()}") except Exception as e: print(f"Invalid/unsupported arguments: {e}") exit(1) # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Set the cross-gcc version crossgccvers = configurations[build_type]['cross-gcc'][build_version] # Prepare the debian changelog file changelog_src = f"{repo_root_dir}/debian/changelog.in" changelog_dst = f"{repo_root_dir}/debian/changelog" with open(changelog_src) as fh: changelog = fh.read() if "v" in jellyfin_version: comment = f"Jellyfin release {jellyfin_version}, see https://github.com/jellyfin/jellyfin/releases/{jellyfin_version} for details." else: comment = f"Jellyin unstable release {jellyfin_version}." jellyfin_version = jellyfin_version.replace('v', '') changelog = changelog.format( package_version=jellyfin_version, package_build=f"{build_type[:3]}{os_version.replace('.', '')}", release_comment=comment, release_date=format_datetime(localtime()) ) with open(changelog_dst, "w") as fh: fh.write(changelog) # Use a unique docker image name for consistency imagename = f"{configurations[build_type]['imagename']}-{jellyfin_version}_{build_arch}-{build_type}-{build_version}" # Build the dockerfile and packages os.system(f"{docker_build_cmd} --build-arg PACKAGE_TYPE={os_type} --build-arg PACKAGE_VERSION={os_version} --build-arg PACKAGE_ARCH={PACKAGE_ARCH} --build-arg GCC_VERSION={crossgccvers} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"{docker_run_cmd} --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{build_type}:/dist --name {imagename} {imagename}") def build_package_rpm(jellyfin_version, build_type, build_arch, build_version): pass def build_linux(jellyfin_version, build_type, build_arch, _build_version): try: PACKAGE_ARCH = configurations[build_type]['archmaps'][build_arch]['PACKAGE_ARCH'] if build_arch in configurations[build_type]['archmaps'].keys() else None if PACKAGE_ARCH is None: raise ValueError(f"{build_arch} is not a valid {build_type} {build_version} architecture in {configurations[build_type]['archmaps'].keys()}") DOTNET_ARCH = configurations[build_type]['archmaps'][build_arch]['DOTNET_ARCH'] except Exception as e: print(f"Invalid/unsupported arguments: {e}") exit(1) jellyfin_version = jellyfin_version.replace('v', '') # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Use a unique docker image name for consistency imagename = f"{configurations[build_type]['imagename']}-{jellyfin_version}_{build_arch}-{build_type}" # Set the archive type (tar-gz or zip) archivetypes = f"{configurations[build_type]['archivetypes']}" # Build the dockerfile and packages os.system(f"{docker_build_cmd} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"{docker_run_cmd} --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{build_type}:/dist --env JELLYFIN_VERSION={jellyfin_version} --env BUILD_TYPE={build_type} --env PACKAGE_ARCH={PACKAGE_ARCH} --env DOTNET_TYPE=linux --env DOTNET_ARCH={DOTNET_ARCH} --env ARCHIVE_TYPES={archivetypes} --name {imagename} {imagename}") def build_windows(jellyfin_version, build_type, _build_arch, _build_version): try: PACKAGE_ARCH = configurations[build_type]['archmaps'][build_arch]['PACKAGE_ARCH'] if build_arch in configurations[build_type]['archmaps'].keys() else None if PACKAGE_ARCH is None: raise ValueError(f"{build_arch} is not a valid {build_type} {build_version} architecture in {configurations[build_type]['archmaps'].keys()}") DOTNET_ARCH = configurations[build_type]['archmaps'][build_arch]['DOTNET_ARCH'] except Exception as e: print(f"Invalid/unsupported arguments: {e}") exit(1) jellyfin_version = jellyfin_version.replace('v', '') # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Use a unique docker image name for consistency imagename = f"{configurations[build_type]['imagename']}-{jellyfin_version}_{build_arch}-{build_type}" # Set the archive type (tar-gz or zip) archivetypes = f"{configurations[build_type]['archivetypes']}" # Build the dockerfile and packages os.system(f"{docker_build_cmd} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"{docker_run_cmd} --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{build_type}:/dist --env JELLYFIN_VERSION={jellyfin_version} --env BUILD_TYPE={build_type} --env PACKAGE_ARCH={PACKAGE_ARCH} --env DOTNET_TYPE=win --env DOTNET_ARCH={DOTNET_ARCH} --env ARCHIVE_TYPES={archivetypes} --name {imagename} {imagename}") def build_macos(jellyfin_version, build_type, build_arch, _build_version): try: PACKAGE_ARCH = configurations[build_type]['archmaps'][build_arch]['PACKAGE_ARCH'] if build_arch in configurations[build_type]['archmaps'].keys() else None if PACKAGE_ARCH is None: raise ValueError(f"{build_arch} is not a valid {build_type} {build_version} architecture in {configurations[build_type]['archmaps'].keys()}") DOTNET_ARCH = configurations[build_type]['archmaps'][build_arch]['DOTNET_ARCH'] except Exception as e: print(f"Invalid/unsupported arguments: {e}") exit(1) jellyfin_version = jellyfin_version.replace('v', '') # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Use a unique docker image name for consistency imagename = f"{configurations[build_type]['imagename']}-{jellyfin_version}_{build_arch}-{build_type}" # Set the archive type (tar-gz or zip) archivetypes = f"{configurations[build_type]['archivetypes']}" # Build the dockerfile and packages os.system(f"{docker_build_cmd} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"{docker_run_cmd} --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{build_type}:/dist --env JELLYFIN_VERSION={jellyfin_version} --env BUILD_TYPE={build_type} --env PACKAGE_ARCH={PACKAGE_ARCH} --env DOTNET_TYPE=osx --env DOTNET_ARCH={DOTNET_ARCH} --env ARCHIVE_TYPES={archivetypes} --name {imagename} {imagename}") def build_portable(jellyfin_version, build_type, _build_arch, _build_version): jellyfin_version = jellyfin_version.replace('v', '') # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Use a unique docker image name for consistency imagename = f"{configurations[build_type]['imagename']}-{jellyfin_version}_{build_type}" # Set the archive type (tar-gz or zip) archivetypes = f"{configurations[build_type]['archivetypes']}" # Build the dockerfile and packages os.system(f"{docker_build_cmd} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"{docker_run_cmd} --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{build_type}:/dist --env JELLYFIN_VERSION={jellyfin_version} --env BUILD_TYPE={build_type} --env ARCHIVE_TYPES={archivetypes} --name {imagename} {imagename}") def build_docker(jellyfin_version, build_type, _build_arch, _build_version): print("> Building Docker images...") print() # We build all architectures simultaneously to push a single tag, so no conditional checks architectures = configurations['docker']['archmaps'].keys() # Set the dockerfile dockerfile = configurations[build_type]["dockerfile"] # Determine if this is a "latest"-type image (v in jellyfin_version) or not if "v" in jellyfin_version: is_latest = True version_suffix = True else: is_latest = False version_suffix = False jellyfin_version = jellyfin_version.replace('v', '') # Set today's date in a convenient format for use as an image suffix date = datetime.now().strftime("%Y%m%d-%H%M%S") images = list() for _build_arch in architectures: print(f">> Building Docker image for {_build_arch}...") print() # Get our ARCH variables from the archmaps PACKAGE_ARCH = configurations['docker']['archmaps'][_build_arch]['PACKAGE_ARCH'] DOTNET_ARCH = configurations['docker']['archmaps'][_build_arch]['DOTNET_ARCH'] QEMU_ARCH = configurations['docker']['archmaps'][_build_arch]['QEMU_ARCH'] IMAGE_ARCH = configurations['docker']['archmaps'][_build_arch]['IMAGE_ARCH'] # Use a unique docker image name for consistency if version_suffix: imagename = f"{configurations['docker']['imagename']}:{jellyfin_version}-{_build_arch}.{date}" else: imagename = f"{configurations['docker']['imagename']}:{jellyfin_version}-{_build_arch}" # Clean up any existing qemu static image os.system(f"{docker_run_cmd} --privileged multiarch/qemu-user-static:register --reset") print() # Build the dockerfile os.system(f"{docker_build_cmd} --build-arg PACKAGE_ARCH={PACKAGE_ARCH} --build-arg DOTNET_ARCH={DOTNET_ARCH} --build-arg QEMU_ARCH={QEMU_ARCH} --build-arg IMAGE_ARCH={IMAGE_ARCH} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") images.append(imagename) print() # Build the manifests print(f">> Building Docker manifests...") manifests = list() if version_suffix: print(f">>> Building dated version manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:{jellyfin_version}.{date} {' '.join(images)}") manifests.append(f"{configurations['docker']['imagename']}:{jellyfin_version}.{date}") print(f">>> Building version manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:{jellyfin_version} {' '.join(images)}") manifests.append(f"{configurations['docker']['imagename']}:{jellyfin_version}") if is_latest: print(f">>> Building latest manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:latest {' '.join(images)}") manifests.append(f"{configurations['docker']['imagename']}:latest") # Push the images and manifests to DockerHub (we are already logged in from GH Actions) for image in images: os.system(f"docker push {image}") for manifest in manifests: os.system(f"docker manifest push --purge {manifest}") # Push the images and manifests to GHCR (we are already logged in from GH Actions) for image in images: os.system(f"docker push ghcr.io/{image}") for manifest in manifests: os.system(f"docker manifest push --purge ghcr.io/{manifest}") # Define a map of possible configurations configurations = { "debian": { "def": build_package_deb, "dockerfile": "debian/docker/Dockerfile", "imagename": "jellyfin-builder", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", }, "arm64": { "PACKAGE_ARCH": "arm64", }, "armhf": { "PACKAGE_ARCH": "armhf", }, }, "releases": { "bullseye": "11", "bookworm": "12", }, "cross-gcc": { "bullseye": "10", "bookworm": "12", }, }, "ubuntu": { "def": build_package_deb, "dockerfile": "debian/docker/Dockerfile", "imagename": "jellyfin-builder", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", }, "arm64": { "PACKAGE_ARCH": "arm64", }, "armhf": { "PACKAGE_ARCH": "armhf", }, }, "releases": { "focal": "20.04", "jammy": "22.04", "noble": "24.04", }, "cross-gcc": { "focal": "10", "jammy": "12", "noble": "12", }, }, "fedora": { "def": build_package_rpm, }, "centos": { "def": build_package_rpm, }, "linux": { "def": build_linux, "dockerfile": "portable/Dockerfile", "imagename": "jellyfin-builder", "archivetypes": "tar", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", "DOTNET_ARCH": "x64", }, "amd64-musl": { "PACKAGE_ARCH": "amd64-musl", "DOTNET_ARCH": "musl-x64", }, "arm64": { "PACKAGE_ARCH": "arm64", "DOTNET_ARCH": "arm64", }, "arm64-musl": { "PACKAGE_ARCH": "arm64-musl", "DOTNET_ARCH": "musl-arm64", }, "armhf": { "PACKAGE_ARCH": "armhf", "DOTNET_ARCH": "arm", }, }, }, "windows": { "def": build_windows, "dockerfile": "portable/Dockerfile", "imagename": "jellyfin-builder", "archivetypes": "zip", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", "DOTNET_ARCH": "x64", }, "arm64": { "PACKAGE_ARCH": "arm64", "DOTNET_ARCH": "arm64", }, }, }, "macos": { "def": build_macos, "dockerfile": "portable/Dockerfile", "imagename": "jellyfin-builder", "archivetypes": "tar", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", "DOTNET_ARCH": "x64", }, "arm64": { "PACKAGE_ARCH": "arm64", "DOTNET_ARCH": "arm64", }, }, }, "portable": { "def": build_portable, "dockerfile": "portable/Dockerfile", "imagename": "jellyfin-builder", "archivetypes": "tar,zip", }, "docker": { "def": build_docker, "dockerfile": "docker/Dockerfile", "imagename": "jellyfin/jellyfin", "archmaps": { "amd64": { "PACKAGE_ARCH": "amd64", "DOTNET_ARCH": "x64", "QEMU_ARCH": "x86_64", "IMAGE_ARCH": "amd64", }, "arm64": { "PACKAGE_ARCH": "arm64", "DOTNET_ARCH": "arm64", "QEMU_ARCH": "aarch64", "IMAGE_ARCH": "arm64v8", }, "armhf": { "PACKAGE_ARCH": "armhf", "DOTNET_ARCH": "arm", "QEMU_ARCH": "arm", "IMAGE_ARCH": "arm32v7", }, } }, } def usage(): print(f"{sys.argv[0]} JELLYFIN_VERSION BUILD_TYPE [BUILD_ARCH] [BUILD_VERSION]") print(f" JELLYFIN_VERSION: The Jellyfin version being built; stable releases should be tag names with a 'v' e.g. v10.9.0") print(f" BUILD_TYPE: A valid build OS type (debian, ubuntu, fedora, centos, docker, portable, linux, windows, macos)") print(f" BUILD_ARCH: A valid build OS CPU architecture (empty [portable/docker], amd64, arm64, or armhf)") print(f" BUILD_VERSION: A valid build OS version (packaged OS types only)") try: jellyfin_version = sys.argv[1] build_type = sys.argv[2] except IndexError: usage() exit(1) try: build_arch = sys.argv[3] except IndexError: build_arch = None try: build_version = sys.argv[4] except IndexError: build_version = None if jellyfin_version == "master": jellyfin_version = datetime.now().strftime("%Y%m%d%H") configurations[build_type]['def'](jellyfin_version, build_type, build_arch, build_version)