Repository navigation
Expand file tree
/
Copy pathbuild.py
More file actions
executable file
·179 lines (143 loc) · 6.62 KB
/
Copy pathbuild.py
File metadata and controls
executable file
·179 lines (143 loc) · 6.62 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
#!/usr/bin/env python3
import os
import json
import subprocess
import argparse
PLATFORMS = [
"linux/arm64",
"linux/amd64",
]
def create_builder(build_dir, builder_name, platform):
check_exists_command = ["docker", "buildx", "inspect", builder_name]
if subprocess.run(check_exists_command, stderr=subprocess.DEVNULL).returncode != 0:
create_command = ["docker", "buildx", "create", "--platform", platform, "--name", builder_name]
try:
subprocess.run(create_command, cwd=build_dir, check=True)
except subprocess.CalledProcessError:
print("Creating builder failed")
exit(1)
def build_and_push_multiarch(build_dir, build_args, push, builder_suffix=""):
builder_name = f"factoriotools{builder_suffix}-multiarch"
platform = ",".join(PLATFORMS)
create_builder(build_dir, builder_name, platform)
build_command = ["docker", "buildx", "build", "--platform", platform, "--builder", builder_name] + build_args
if push:
build_command.append("--push")
try:
subprocess.run(build_command, cwd=build_dir, check=True)
except subprocess.CalledProcessError:
print(f"Build and push of {builder_suffix or 'regular'} image failed")
exit(1)
def build_singlearch(build_dir, build_args, image_type="regular"):
build_command = ["docker", "build"] + build_args
try:
subprocess.run(build_command, cwd=build_dir, check=True)
except subprocess.CalledProcessError:
print(f"Build of {image_type} image failed")
exit(1)
def push_singlearch(tags):
for tag in tags:
try:
subprocess.run(["docker", "push", f"factoriotools/factorio:{tag}"],
check=True)
except subprocess.CalledProcessError:
print("Docker push failed")
exit(1)
def build_and_push(sha256, version, tags, push, multiarch, dockerfile="Dockerfile", builder_suffix="",
sha256_arm64=None):
build_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "docker")
build_args = ["-f", dockerfile, "--build-arg", f"VERSION={version}", "--build-arg", f"SHA256={sha256}"]
if sha256_arm64:
# Native ARM64 archive available: the arm64 image runs it instead of the x64 build under box64
build_args.extend(["--build-arg", f"SHA256_ARM64={sha256_arm64}"])
build_args.append(".")
for tag in tags:
build_args.extend(["-t", f"factoriotools/factorio:{tag}"])
image_type = "rootless" if "rootless" in dockerfile.lower() else "regular"
if multiarch:
build_and_push_multiarch(build_dir, build_args, push, builder_suffix)
else:
build_singlearch(build_dir, build_args, image_type)
if push:
push_singlearch(tags)
def login():
try:
username = os.environ["DOCKER_USERNAME"]
password = os.environ["DOCKER_PASSWORD"]
subprocess.run(["docker", "login", "-u", username, "-p", password], check=True)
except KeyError:
print("Username and password need to be given")
exit(1)
except subprocess.CalledProcessError:
print("Docker login failed")
exit(1)
def generate_rootless_tags(original_tags):
"""Generate rootless-specific tags from original tags"""
return [f"{tag}-rootless" for tag in original_tags]
def load_previous_buildinfo(ref):
"""Read release metadata at a git ref without changing the checkout."""
contents = subprocess.check_output(
["git", "show", "--end-of-options", f"{ref}:buildinfo.json"],
cwd=os.path.dirname(os.path.abspath(__file__)), text=True,
)
data = json.loads(contents)
if not isinstance(data, dict):
raise ValueError("Previous buildinfo.json must be an object")
return data
def release_changed(version, info, previous):
old = previous.get(version)
if old is None:
return True
# Removing an alias needs no rebuild: the new owner will publish that tag.
return (any(info.get(key) != old.get(key) for key in ("sha256", "sha256_arm64"))
or bool(set(info["tags"]) - set(old["tags"])))
def main():
parser = argparse.ArgumentParser(description='Build Factorio Docker images')
parser.add_argument('--push-tags', action='store_true', help='Push images to Docker Hub')
parser.add_argument('--multiarch', action='store_true', help='Build multi-architecture images')
parser.add_argument('--rootless', action='store_true', help='Build only rootless images')
parser.add_argument('--both', action='store_true', help='Build both regular and rootless images')
parser.add_argument('--changed-from', metavar='GIT_REF',
help='Build only versions with new archives or added tags since this ref')
args = parser.parse_args()
# Default behavior: build regular images unless specified otherwise
build_regular = not args.rootless or args.both
build_rootless = args.rootless or args.both
with open(os.path.join(os.path.dirname(__file__), "buildinfo.json")) as file_handle:
builddata = json.load(file_handle)
previous = None
if args.changed_from:
try:
previous = load_previous_buildinfo(args.changed_from)
except (subprocess.CalledProcessError, OSError, ValueError) as error:
parser.error(f"Cannot read previous release metadata: {error}")
versions_to_build = [
(version, buildinfo)
for version, buildinfo in sorted(builddata.items(), key=lambda item: item[0], reverse=True)
if previous is None or release_changed(version, buildinfo, previous)
]
if not versions_to_build:
print("No changed releases to build.")
return
if args.push_tags:
login()
# Build regular images
if build_regular:
print("Building regular images...")
for version, buildinfo in versions_to_build:
sha256 = buildinfo["sha256"]
tags = buildinfo["tags"]
build_and_push(sha256, version, tags, args.push_tags, args.multiarch,
sha256_arm64=buildinfo.get("sha256_arm64"))
# Build rootless images
if build_rootless:
print("Building rootless images...")
for version, buildinfo in versions_to_build:
sha256 = buildinfo["sha256"]
original_tags = buildinfo["tags"]
rootless_tags = generate_rootless_tags(original_tags)
build_and_push(sha256, version, rootless_tags, args.push_tags, args.multiarch,
dockerfile="Dockerfile.rootless", builder_suffix="-rootless",
sha256_arm64=buildinfo.get("sha256_arm64"))
if __name__ == '__main__':
main()