275 lines
9.0 KiB
Python
Executable File
275 lines
9.0 KiB
Python
Executable File
#!/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)
|