#!/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 try: target_release = sys.argv[1] except IndexError: target_release = "master" # 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() def build_package_deb(jvers, btype, barch, bvers): try: ostype = btype if btype in configurations.keys() else None if ostype is None: raise ValueError(f"{btype} is not a valid OS type in {configurations.keys()}") osversion = bvers if bvers in configurations[btype]['releases'] else None if osversion is None: raise ValueError(f"{bvers} is not a valid {btype} version in {configurations[btype]['releases']}") PARCH = configurations[btype]['archmaps'][barch]['PARCH'] if barch in configurations[btype]['archmaps'].keys() else None if PARCH is None: raise ValueError(f"{barch} is not a valid {btype} {bvers} architecture in {configurations[btype]['archmaps'].keys()}") except Exception as e: print(f"Invalid/unsupported arguments: {e}") exit(1) # Set the dockerfile dockerfile = configurations[btype]["dockerfile"] # Set the cross-gcc version crossgccvers = configurations[btype]['cross-gcc'][bvers] # 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 jvers: comment = f"Jellyfin release {jvers}, see https://github.com/jellyfin/jellyfin/releases/{jvers} for details." else: comment = f"Jellyin unstable release {jvers}." changelog = changelog.format( package_version=jvers.replace('v', ''), package_build=f"{btype[:3]}{bvers.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[btype]['imagename']}-{jvers}_{barch}-{btype}-{bvers}" # Build the dockerfile and packages os.system(f"docker build --progress=plain --build-arg PTYPE={ostype} --build-arg PVERSION={osversion} --build-arg PARCH={PARCH} --build-arg GCC_VERSION={crossgccvers} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"docker run --rm --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{btype}:/dist --name {imagename} {imagename}") def build_package(jvers, btype, barch, bvers): pass def build_portable(jvers, btype, _barch, _bvers): # Set the dockerfile dockerfile = configurations[btype]["dockerfile"] # Use a unique docker image name for consistency imagename = f"{configurations[btype]['imagename']}-{jvers}_{btype}" # Set the archive type (tar-gz or zip) archivetypes = f"{configurations[btype]['archivetypes']}" # Build the dockerfile and packages os.system(f"docker build --progress=plain --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") os.system(f"docker run --rm --volume {repo_root_dir}:/jellyfin --volume {repo_root_dir}/out/{btype}:/dist --env JVERS={jvers} --env ARCHIVE_TYPES={archivetypes} --name {imagename} {imagename}") def build_docker(jvers, btype, _barch, _bvers): 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[btype]["dockerfile"] # Determine if this is a "latest"-type image (v in jvers) or not if "v" in jvers: is_latest = True version_suffix = True else: is_latest = False version_suffix = False # 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 _barch in architectures: print(f">> Building Docker image for {_barch}...") print() # Get our ARCH variables from the archmaps PARCH = configurations['docker']['archmaps'][_barch]['PARCH'] DARCH = configurations['docker']['archmaps'][_barch]['DARCH'] QARCH = configurations['docker']['archmaps'][_barch]['QARCH'] BARCH = configurations['docker']['archmaps'][_barch]['BARCH'] # Use a unique docker image name for consistency if version_suffix: imagename = f"{configurations['docker']['imagename']}:{jvers}-{_barch}.{date}" else: imagename = f"{configurations['docker']['imagename']}:{jvers}-{_barch}" # Clean up any existing qemu static image os.system(f"docker run --rm --privileged multiarch/qemu-user-static:register --reset") print() # Build the dockerfile os.system(f"docker build --no-cache --progress=plain --build-arg PARCH={PARCH} --build-arg DARCH={DARCH} --build-arg QARCH={QARCH} --build-arg BARCH={BARCH} --file {repo_root_dir}/{dockerfile} --tag {imagename} {repo_root_dir}") images.append(imagename) print() # Build the manifests print(f">> Building Docker manifests...") if version_suffix: print(f">>> Building dated version manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:{jvers}.{date} {' '.join(images)}") print(f">>> Building version manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:{jvers} {' '.join(images)}") if is_latest: print(f">>> Building latest manifest...") os.system(f"docker manifest create --amend {configurations['docker']['imagename']}:latest {' '.join(images)}") # Define a map of possible configurations configurations = { "debian": { "def": build_package_deb, "dockerfile": "debian/docker/Dockerfile", "imagename": "jellyfin-builder", "archmaps": { "amd64": { "PARCH": "amd64", }, "arm64": { "PARCH": "arm64", }, "armhf": { "PARCH": "armhf", }, }, "releases": [ "11", "12" ], "cross-gcc": { "11": "10", "12": "12", }, }, "ubuntu": { "def": build_package_deb, "dockerfile": "debian/docker/Dockerfile", "imagename": "jellyfin-builder", "archmaps": { "amd64": { "PARCH": "amd64", }, "arm64": { "PARCH": "arm64", }, "armhf": { "PARCH": "armhf", }, }, "releases": [ "20.04", "22.04" ], "cross-gcc": { "20.04": "10", "22.04": "12", "24.04": "12", }, }, "fedora": { "def": build_package, }, "centos": { "def": build_package, }, "linux": { "def": build_package, }, "windows": { "def": build_package, }, "macos": { "def": build_package, }, "portable": { "def": build_portable, "dockerfile": "portable/Dockerfile", "imagename": "jellyfin-builder", "archivetypes": "tar,zip", }, "docker": { "def": build_docker, "dockerfile": "docker/Dockerfile", "imagename": "jellyfin/jellyfin", "archmaps": { # This insanity is needed because no one can agree on how to name architectures :-( "amd64": { "PARCH": "amd64", "DARCH": "x64", "QARCH": "x86_64", "BARCH": "amd64", }, "arm64": { "PARCH": "arm64", "DARCH": "arm64", "QARCH": "aarch64", "BARCH": "arm64v8", }, "armhf": { "PARCH": "armhf", "DARCH": "arm", "QARCH": "arm", "BARCH": "arm32v7", }, } }, } def usage(): print(f"{sys.argv[0]} JVERS BTYPE [BARCH] [BVERS]") print(f" JVERS: The Jellyfin version being built") print(f" BTYPE: A valid build OS type") print(f" BARCH: A valid build OS CPU architecture (packaged OS types only)") print(f" BVERS: A valid build OS version (packaged OS types only)") try: jvers = sys.argv[1] btype = sys.argv[2] except IndexError: usage() exit(1) try: barch = sys.argv[3] except IndexError: barch = None try: bvers = sys.argv[4] except IndexError: bvers = None configurations[btype]['def'](jvers, btype, barch, bvers)