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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
import json
import os
import subprocess
from typing import Optional, Sequence, List, Tuple
from debputy import DEBPUTY_ROOT_DIR
from debputy.commands.debputy_cmd.context import CommandContext
from debputy.deb_packaging_support import setup_control_files
from debputy.debhelper_emulation import dhe_dbgsym_root_dir
from debputy.filesystem_scan import FSRootDir
from debputy.highlevel_manifest import HighLevelManifest
from debputy.intermediate_manifest import IntermediateManifest
from debputy.plugin.api.impl_types import PackageDataTable
from debputy.util import (
escape_shell,
_error,
compute_output_filename,
scratch_dir,
ensure_dir,
_warn,
assume_not_none,
)
_RRR_DEB_ASSEMBLY_KEYWORD = "debputy/deb-assembly"
_WARNED_ABOUT_FALLBACK_ASSEMBLY = False
def _serialize_intermediate_manifest(members: IntermediateManifest) -> str:
serial_format = [m.to_manifest() for m in members]
return json.dumps(serial_format)
def determine_assembly_method(
package: str,
intermediate_manifest: IntermediateManifest,
) -> Tuple[bool, bool, List[str]]:
paths_needing_root = (
tm for tm in intermediate_manifest if tm.owner != "root" or tm.group != "root"
)
matched_path = next(paths_needing_root, None)
if matched_path is None:
return False, False, []
rrr = os.environ.get("DEB_RULES_REQUIRES_ROOT")
if rrr and _RRR_DEB_ASSEMBLY_KEYWORD in rrr:
gain_root_cmd = os.environ.get("DEB_GAIN_ROOT_CMD")
if not gain_root_cmd:
_error(
"DEB_RULES_REQUIRES_ROOT contains a debputy keyword but DEB_GAIN_ROOT_CMD does not contain a "
'"gain root" command'
)
return True, False, gain_root_cmd.split()
if rrr == "no":
global _WARNED_ABOUT_FALLBACK_ASSEMBLY
if not _WARNED_ABOUT_FALLBACK_ASSEMBLY:
_warn(
'Using internal assembly method due to "Rules-Requires-Root" being "no" and dpkg-deb assembly would'
" require (fake)root for binary packages that needs it."
)
_WARNED_ABOUT_FALLBACK_ASSEMBLY = True
return True, True, []
_error(
f'Due to the path "{matched_path.member_path}" in {package}, the package assembly will require (fake)root.'
" However, this command is not run as root nor was debputy requested to use a root command via"
f' "Rules-Requires-Root". Please consider adding "{_RRR_DEB_ASSEMBLY_KEYWORD}" to "Rules-Requires-Root"'
" in debian/control. Though, due to #1036865, you may have to revert to"
' "Rules-Requires-Root: binary-targets" depending on which version of dpkg you need to support.'
' Alternatively, you can set "Rules-Requires-Root: no" in debian/control and debputy will assemble'
" the package anyway. In this case, dpkg-deb will not be used, but the output should be bit-for-bit"
" compatible with what debputy would have produced with dpkg-deb (and root/fakeroot)."
)
def assemble_debs(
context: CommandContext,
manifest: HighLevelManifest,
package_data_table: PackageDataTable,
is_dh_rrr_only_mode: bool,
) -> None:
parsed_args = context.parsed_args
output_path = parsed_args.output
upstream_args = parsed_args.upstream_args
deb_materialize = str(DEBPUTY_ROOT_DIR / "deb_materialization.py")
mtime = context.mtime
for dctrl_bin in manifest.active_packages:
package = dctrl_bin.name
dbgsym_package_name = f"{package}-dbgsym"
dctrl_data = package_data_table[package]
fs_root = dctrl_data.fs_root
control_output_dir = assume_not_none(dctrl_data.control_output_dir)
package_metadata_context = dctrl_data.package_metadata_context
if (
dbgsym_package_name in package_data_table
or "noautodbgsym" in manifest.build_env.deb_build_options
or "noddebs" in manifest.build_env.deb_build_options
):
# Discard the dbgsym part if it conflicts with a real package, or
# we were asked not to build it.
dctrl_data.dbgsym_info.dbgsym_fs_root = FSRootDir()
dctrl_data.dbgsym_info.dbgsym_ids.clear()
dbgsym_fs_root = dctrl_data.dbgsym_info.dbgsym_fs_root
dbgsym_ids = dctrl_data.dbgsym_info.dbgsym_ids
intermediate_manifest = manifest.finalize_data_tar_contents(
package, fs_root, mtime
)
setup_control_files(
dctrl_data,
manifest,
dbgsym_fs_root,
dbgsym_ids,
package_metadata_context,
allow_ctrl_file_management=not is_dh_rrr_only_mode,
)
needs_root, use_fallback_assembly, gain_root_cmd = determine_assembly_method(
package, intermediate_manifest
)
if not dctrl_bin.is_udeb and any(
f for f in dbgsym_fs_root.all_paths() if f.is_file
):
# We never built udebs due to #797391. We currently do not generate a control
# file for it either for the same reason.
dbgsym_root = dhe_dbgsym_root_dir(dctrl_bin)
if not os.path.isdir(output_path):
_error(
"Cannot produce a dbgsym package when output path is not a directory."
)
dbgsym_intermediate_manifest = manifest.finalize_data_tar_contents(
dbgsym_package_name,
dbgsym_fs_root,
mtime,
)
_assemble_deb(
dbgsym_package_name,
deb_materialize,
dbgsym_intermediate_manifest,
mtime,
os.path.join(dbgsym_root, "DEBIAN"),
output_path,
upstream_args,
is_udeb=dctrl_bin.is_udeb, # Review this if we ever do dbgsyms for udebs
use_fallback_assembly=False,
needs_root=False,
)
_assemble_deb(
package,
deb_materialize,
intermediate_manifest,
mtime,
control_output_dir,
output_path,
upstream_args,
is_udeb=dctrl_bin.is_udeb,
use_fallback_assembly=use_fallback_assembly,
needs_root=needs_root,
gain_root_cmd=gain_root_cmd,
)
def _assemble_deb(
package: str,
deb_materialize_cmd: str,
intermediate_manifest: IntermediateManifest,
mtime: int,
control_output_dir: str,
output_path: str,
upstream_args: Optional[List[str]],
is_udeb: bool = False,
use_fallback_assembly: bool = False,
needs_root: bool = False,
gain_root_cmd: Optional[Sequence[str]] = None,
) -> None:
scratch_root_dir = scratch_dir()
materialization_dir = os.path.join(
scratch_root_dir, "materialization-dirs", package
)
ensure_dir(os.path.dirname(materialization_dir))
materialize_cmd: List[str] = []
assert not use_fallback_assembly or not gain_root_cmd
if needs_root and gain_root_cmd:
# Only use the gain_root_cmd if we absolutely need it.
# Note that gain_root_cmd will be empty unless R³ is set to the relevant keyword
# that would make us use targeted promotion. Therefore, we do not need to check other
# conditions than the package needing root. (R³: binary-targets implies `needs_root=True`
# without a gain_root_cmd)
materialize_cmd.extend(gain_root_cmd)
materialize_cmd.extend(
[
deb_materialize_cmd,
"materialize-deb",
"--intermediate-package-manifest",
"-",
"--may-move-control-files",
"--may-move-data-files",
"--source-date-epoch",
str(mtime),
"--discard-existing-output",
control_output_dir,
materialization_dir,
]
)
output = output_path
if is_udeb:
materialize_cmd.append("--udeb")
output = os.path.join(
output_path, compute_output_filename(control_output_dir, True)
)
assembly_method = "debputy" if needs_root and use_fallback_assembly else "dpkg-deb"
combined_materialization_and_assembly = not needs_root
if combined_materialization_and_assembly:
materialize_cmd.extend(
["--build-method", assembly_method, "--assembled-deb-output", output]
)
if upstream_args:
materialize_cmd.append("--")
materialize_cmd.extend(upstream_args)
if combined_materialization_and_assembly:
print(
f"Materializing and assembling {package} via: {escape_shell(*materialize_cmd)}"
)
else:
print(f"Materializing {package} via: {escape_shell(*materialize_cmd)}")
proc = subprocess.Popen(materialize_cmd, stdin=subprocess.PIPE)
proc.communicate(
_serialize_intermediate_manifest(intermediate_manifest).encode("utf-8")
)
if proc.returncode != 0:
_error(f"{escape_shell(deb_materialize_cmd)} exited with a non-zero exit code!")
if not combined_materialization_and_assembly:
build_materialization = [
deb_materialize_cmd,
"build-materialized-deb",
materialization_dir,
assembly_method,
"--output",
output,
]
print(f"Assembling {package} via: {escape_shell(*build_materialization)}")
try:
subprocess.check_call(build_materialization)
except subprocess.CalledProcessError as e:
exit_code = f" with exit code {e.returncode}" if e.returncode else ""
_error(
f"Assembly command for {package} failed{exit_code}. Please review the output of the command"
f" for more details on the problem."
)
|
