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
180
181
182
183
184
185
186
187
188
189
190
|
#!/usr/bin/python3
# SPDX-License-Identifier: GPL-2.0-or-later
#
# Copyright © 2020-2024 Christian Kastner <ckk@debian.org>
# 2024 Johannes Schauer Marin Rodrigues <josch@debian.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see
# <http://www.gnu.org/licenses/>.
#
#######################################################################
import argparse
import os
import subprocess
import sys
DEB_ARCH_TO_QEMU = {
'amd64': 'x86_64',
'arm64': 'aarch64',
'armhf': 'arm',
'i386': 'i386',
'ppc64el': 'ppc64le',
}
IMAGEDIR = os.environ.get(
'IMAGEDIR',
os.path.join(os.path.expanduser('~'), '.cache', 'sbuild'),
)
DEFAULT_ARCH = subprocess.check_output(
['dpkg', '--print-architecture'],
text=True,
).strip()
def main():
# init options
parser = argparse.ArgumentParser(
description="Build Debian packages with sbuild(1) using QEMU images",
epilog="All options other than the ones described below are passed on "
"through to sbuild(1), though the options --dist, --arch, and "
"--build are peeked at when looking for images. The image will "
"be started in snapshot mode, so the image is never modified. "
"Multiple processes can use the same image concurrently. The "
"architectures currently supported by sbuild-qemu are: "
f"{', '.join(DEB_ARCH_TO_QEMU.keys())}.",
)
parser.add_argument(
'--image',
action='store',
help="QEMU image file to use for building. If not specified, "
"sbuild-qemu will look for an image with the name "
"DIST-autopkgtest-ARCH.img, where DIST is taken from --dist "
"if present, and ARCH is taken from --arch or --build if "
"present. Otherwise, DIST defaults to 'unstable', and ARCH to "
"the host architecture. sbuild-qemu will first look in the "
"current directory for such an image, and then in the directory "
"$IMAGEDIR. A suitable image can be created with "
"qemu-sbuild-create(1).",
)
parser.add_argument(
'--ram-size',
metavar='MiB',
action='store',
default=2048,
help=f"VM memory size in MB. Default: 2048",
)
parser.add_argument(
'--cpus',
metavar='CPUs',
action='store',
default=2,
help="VM CPU count. Default: 2",
)
parser.add_argument(
'--overlay-dir',
action='store',
default='/tmp',
help="Directory for the temporary image overlay instead of "
"autopkgtest's default of /tmp (or $TMPDIR).",
)
parser.add_argument(
'--noexec',
action='store_true',
help="Don't actually do anything. Just print the sbuild(1) command "
"string that would be executed, and then exit.",
)
parser.add_argument(
'--autopkgtest-debug',
action='store_true',
help="Enable debug output for the autopkgtest-virt-qemu(1) driver.",
)
parser.add_argument(
'--boot',
choices=['auto', 'bios', 'efi', 'ieee1275', 'none'],
default='auto',
help="How to boot the image. Default is BIOS on amd64 and i386, EFI "
"on arm64 and armhf, and IEEE1275 on ppc64el.",
)
parsed_args, unparsed_args = parser.parse_known_args()
# These aren't options for us specifically, but we use them for guessing
# image locations
peeker = argparse.ArgumentParser()
peeker.add_argument(
'--dist',
action='store',
default='unstable',
)
peeker.add_argument(
'--arch',
action='store',
default=DEFAULT_ARCH,
)
peeker.add_argument(
'--build',
action='store',
)
peeked_args, _ = peeker.parse_known_args(unparsed_args)
build_arch = peeked_args.build or peeked_args.arch
try:
qemu_arch = DEB_ARCH_TO_QEMU[build_arch]
except KeyError:
print(f"Unsupported architecture: {build_arch}", file=sys.stderr)
print("Supported architectures are: ", file=sys.stderr, end="")
print(f"{', '.join(DEB_ARCH_TO_QEMU.keys())}", file=sys.stderr)
sys.exit(1)
if parsed_args.image:
if os.path.exists(os.path.abspath(parsed_args.image)):
image = parsed_args.image
else:
image = os.path.join(IMAGEDIR, parsed_args.image)
else:
guessed_name = f'{peeked_args.dist}-autopkgtest-{build_arch}.img'
if os.path.exists(os.path.abspath(guessed_name)):
images = os.path.abspath(guessed_name)
else:
image = os.path.join(
IMAGEDIR,
f'{peeked_args.dist}-autopkgtest-{build_arch}.img',
)
if not os.path.exists(image):
print(f"File {image} does not exist.", file=sys.stderr)
sys.exit(1)
args = [
'sbuild',
'--dist', peeked_args.dist,
'--purge-build=never',
'--purge-deps=never',
'--chroot-mode=autopkgtest',
'--autopkgtest-virt-server=qemu',
'--autopkgtest-virt-server-opt', f'--overlay-dir={parsed_args.overlay_dir}',
'--autopkgtest-virt-server-opt', f'--qemu-architecture={qemu_arch}',
'--autopkgtest-virt-server-opt', f'--ram-size={parsed_args.ram_size}',
'--autopkgtest-virt-server-opt', f'--cpus={parsed_args.cpus}',
'--autopkgtest-virt-server-opt', f'--boot={parsed_args.boot}',
'--autopkgtest-virt-server-opt', image,
# Worarkound -- dose can hang stuff in a qemu VM
'--bd-uninstallable-explainer', 'apt',
]
if parsed_args.autopkgtest_debug:
args += ['--autopkgtest-virt-server-opt', '--debug']
# Pass on the remaining (before peeking) arguments to sbuild
args += unparsed_args
print(' '.join(str(a) for a in args))
if not parsed_args.noexec:
os.execvp(args[0], args)
if __name__ == '__main__':
main()
|
