Debian Codegraph @

debian/lib/python/debian_linux/gencontrol.py

raw
1 from __future__ import annotations
2
3 import contextlib
4 import itertools
5 import pathlib
6 import re
7 from collections.abc import (
8 Generator,
9 )
10 from typing import (
11 Any,
12 Iterable,
13 Iterator,
14 IO,
15 )
16
17 from .config_v2 import (
18 ConfigMerged,
19 ConfigMergedDebianarch,
20 ConfigMergedFeatureset,
21 ConfigMergedFlavour,
22 )
23 from .dataclasses_deb822 import write_deb822
24 from .debian import Changelog, PackageArchitecture, \
25 Version, SourcePackage, BinaryPackage
26 from .utils import Templates
27
28
29 class Makefile:
30 rules: dict[str, MakefileRule]
31
32 def __init__(self) -> None:
33 self.rules = {}
34
35 def add_cmds(self, name: str, cmds) -> None:
36 rule = self.rules.setdefault(name, MakefileRule(name))
37 rule.add_cmds(MakefileRuleCmdsSimple(cmds))
38
39 def add_deps(self, name: str, deps) -> None:
40 rule = self.rules.setdefault(name, MakefileRule(name))
41 rule.add_deps(deps)
42
43 for i in deps:
44 self.rules.setdefault(i, MakefileRule(i))
45
46 def add_rules(self, name: str, target, makeflags, packages=set(), packages_extra=set()) -> None:
47 rule = self.rules.setdefault(name, MakefileRule(name))
48 rule.add_cmds(MakefileRuleCmdsRules(target, makeflags, packages, packages_extra))
49
50 def write(self, out) -> None:
51 out.write('''\
52 .NOTPARALLEL:
53 .PHONY:
54 packages_enabled := $(shell dh_listpackages)
55 define if_package
56 $(if $(filter $(1),$(packages_enabled)),$(2))
57 endef
58 ''')
59 for k, rule in sorted(self.rules.items()):
60 rule.write(out)
61
62
63 class MakefileRule:
64 name: str
65 cmds: list[MakefileRuleCmds]
66 deps: set[str]
67
68 def __init__(self, name: str) -> None:
69 self.name = name
70 self.cmds = []
71 self.deps = set()
72
73 def add_cmds(self, cmds: MakefileRuleCmds) -> None:
74 self.cmds.append(cmds)
75
76 def add_deps(self, deps: Iterable[str]) -> None:
77 self.deps.update(deps)
78
79 def write(self, out: IO) -> None:
80 if self.cmds:
81 out.write(f'{self.name}:{" ".join(sorted(self.deps))}\n')
82 for c in self.cmds:
83 c.write(out)
84 else:
85 out.write(f'{self.name}:{" ".join(sorted(self.deps))}\n')
86
87
88 class MakefileRuleCmds:
89 def write(self, out: IO) -> None:
90 raise NotImplementedError
91
92
93 class MakefileRuleCmdsRules(MakefileRuleCmds):
94 def __init__(self, target, makeflags, packages, packages_extra) -> None:
95 self.target = target
96 self.makeflags = makeflags.copy()
97 self.packages = packages
98 self.packages_extra = packages_extra
99
100 packages_all = packages | packages_extra
101
102 if packages_all:
103 if len(packages_all) == 1:
104 package_name = list(packages_all)[0]
105 self.makeflags['PACKAGE_NAME'] = package_name
106 self.makeflags['DESTDIR'] = f'$(CURDIR)/debian/{package_name}'
107 else:
108 self.makeflags['DESTDIR'] = '$(CURDIR)/debian/tmp'
109
110 self.makeflags['DH_OPTIONS'] = ' '.join(f'-p{i}' for i in sorted(packages_all))
111
112 def write(self, out: IO) -> None:
113 cmd = f'$(MAKE) -f debian/rules.real {self.target} {self.makeflags}'
114 if self.packages:
115 out.write(f'\t$(call if_package, {" ".join(sorted(self.packages))}, {cmd})\n')
116 else:
117 out.write(f'\t{cmd}\n')
118
119
120 class MakefileRuleCmdsSimple(MakefileRuleCmds):
121 cmds: list[str]
122
123 def __init__(self, cmds: list[str]) -> None:
124 self.cmds = cmds
125
126 def write(self, out: IO) -> None:
127 for i in self.cmds:
128 out.write(f'\t{i}\n')
129
130
131 class MakeFlags(dict):
132 def __str__(self) -> str:
133 return ' '.join("%s='%s'" % i for i in sorted(self.items()))
134
135 def copy(self) -> MakeFlags:
136 return self.__class__(super(MakeFlags, self).copy())
137
138
139 class PackagesBundle:
140 class BinaryPackages(dict[str, BinaryPackage]):
141 def add(self, package: BinaryPackage) -> BinaryPackage:
142 return super().setdefault(package.name, package)
143
144 name: str | None
145 templates: Templates
146 base: pathlib.Path
147 makefile: Makefile
148 source: SourcePackage
149 packages: BinaryPackages
150
151 def __init__(
152 self,
153 name: str | None,
154 source_template: str,
155 replace: dict[str, str],
156 templates: Templates,
157 base: pathlib.Path = pathlib.Path('debian'),
158 override_name: str | None = None,
159 ) -> None:
160 self.name = name
161 self.templates = templates
162 self.base = base
163 self.makefile = Makefile()
164 self.source = list(self.templates.get_source_control(source_template, replace))[0]
165 self.packages = self.BinaryPackages()
166
167 if not self.source.name:
168 self.source.name = override_name
169
170 def add(
171 self,
172 pkgid: str,
173 ruleid: Iterable[str],
174 makeflags: MakeFlags,
175 replace: dict[str, str],
176 *,
177 arch: str | None = None,
178 check_packages: bool = True,
179 ) -> list[Any]:
180 ret = []
181 for raw_package in self.templates.get_control(f'{pkgid}.control', replace):
182 package = self.packages.add(raw_package)
183 package_name = package.name
184 ret.append(package)
185
186 package.meta_rules_ruleids[ruleid] = makeflags
187 if arch:
188 package.meta_architectures.add(arch)
189 package.meta_rules_check_packages = check_packages
190
191 for name in (
192 'NEWS',
193 'bug-control',
194 'bug-presubj',
195 'bug-script',
196 'install',
197 'links',
198 'lintian-overrides',
199 'maintscript',
200 'postinst',
201 'postrm',
202 'preinst',
203 'prerm',
204 ):
205 try:
206 template = self.templates.get(f'{pkgid}.{name}',
207 replace | {'package': package_name})
208 except KeyError:
209 pass
210 else:
211 if arch:
212 out = f'{package_name}.{name}.{arch}'
213 else:
214 out = f'{package_name}.{name}'
215 with self.open(out) as f:
216 f.write(template)
217
218 return ret
219
220 def add_packages(
221 self,
222 packages: Iterable[BinaryPackage],
223 ruleid: Iterable[str],
224 makeflags: MakeFlags,
225 *,
226 arch: str | None = None,
227 check_packages: bool = True,
228 ) -> None:
229 for package in packages:
230 package = self.packages.add(package)
231 package.meta_rules_ruleids[ruleid] = makeflags
232 if arch:
233 package.meta_architectures.add(arch)
234 package.meta_rules_check_packages = check_packages
235
236 def path(self, name) -> pathlib.Path:
237 if self.name:
238 return self.base / f'generated.{self.name}/{name}'
239 return self.base / name
240
241 @staticmethod
242 def __ruleid_deps(ruleid: tuple[str], name: str) -> Iterator[tuple[str, str]]:
243 """
244 Generate all the rules dependencies.
245 ```
246 build: build_a
247 build_a: build_a_b
248 build_a_b: build_a_b_image
249 ```
250 """
251 r = ruleid + (name, )
252 yield (
253 '',
254 '_' + '_'.join(r[:1]),
255 )
256 for i in range(1, len(r)):
257 yield (
258 '_' + '_'.join(r[:i]),
259 '_' + '_'.join(r[:i + 1]),
260 )
261
262 @contextlib.contextmanager
263 def open(self, name: str, mode: str = 'w') -> Generator[IO, None, None]:
264 path = self.path(name)
265 path.parent.mkdir(parents=True, exist_ok=True)
266 with path.open(mode=mode, encoding='utf-8') as f:
267 yield f
268
269 def extract_makefile(self) -> None:
270 targets: dict[frozenset[str], dict] = {}
271
272 for package_name, package in self.packages.items():
273 if not isinstance(package, BinaryPackage):
274 continue
275
276 target_name = package.meta_rules_target
277 ruleids = package.meta_rules_ruleids
278 makeflags = MakeFlags(package.meta_rules_makeflags)
279
280 if ruleids:
281 arches = package.meta_architectures
282 if arches:
283 package.architecture = arches
284 else:
285 arches = package.architecture
286
287 if target_name:
288 for ruleid, makeflags_package in ruleids.items():
289 target_key = frozenset(
290 [target_name, ruleid]
291 + [f'{k}_{v}' for (k, v) in makeflags.items()]
292 )
293 target = targets.setdefault(
294 target_key,
295 {
296 'name': target_name,
297 'ruleid': ruleid,
298 },
299 )
300
301 if package.meta_rules_check_packages:
302 target.setdefault('packages', set()).add(package_name)
303 else:
304 target.setdefault('packages_extra', set()).add(package_name)
305 makeflags_package = makeflags_package.copy()
306 makeflags_package.update(makeflags)
307 target['makeflags'] = makeflags_package
308
309 if arches == set(['all']):
310 target['type'] = 'indep'
311 else:
312 target['type'] = 'arch'
313
314 for target in targets.values():
315 name = target['name']
316 ruleid = target['ruleid']
317 packages = target.get('packages', set())
318 packages_extra = target.get('packages_extra', set())
319 makeflags = target['makeflags']
320 ttype = target['type']
321
322 rule = '_'.join(ruleid + (name, ))
323 self.makefile.add_rules(f'setup_{rule}',
324 f'setup_{name}', makeflags, packages, packages_extra)
325 self.makefile.add_rules(f'build-{ttype}_{rule}',
326 f'build_{name}', makeflags, packages, packages_extra)
327 self.makefile.add_rules(f'binary-{ttype}_{rule}',
328 f'binary_{name}', makeflags, packages, packages_extra)
329
330 for i, j in self.__ruleid_deps(ruleid, name):
331 self.makefile.add_deps(f'setup{i}',
332 [f'setup{j}'])
333 self.makefile.add_deps(f'build-{ttype}{i}',
334 [f'build-{ttype}{j}'])
335 self.makefile.add_deps(f'binary-{ttype}{i}',
336 [f'binary-{ttype}{j}'])
337
338 def merge_build_depends(self) -> None:
339 # Merge Build-Depends pseudo-fields from binary packages into the
340 # source package
341 arch_all = PackageArchitecture("all")
342 for name, package in self.packages.items():
343 dep = package.build_depends
344 if not dep:
345 continue
346 if package.architecture == arch_all:
347 build_dep = self.source.build_depends_indep
348 else:
349 build_dep = self.source.build_depends_arch
350 for group in dep:
351 for item in group:
352 if package.architecture != arch_all and not item.arches:
353 item.arches = package.architecture
354 item.restrictions &= package.build_profiles
355 build_dep.merge(group)
356
357 def write(self) -> None:
358 self.write_control()
359 self.write_makefile()
360
361 def write_control(self) -> None:
362 p = [self.source] + sorted(
363 self.packages.values(),
364 # Sort deb before udeb and then according to name
365 key=lambda i: (i.package_type or '', i.name),
366 )
367 with self.open('control') as f:
368 write_deb822(p, f)
369
370 def write_makefile(self) -> None:
371 with self.open('rules.gen') as f:
372 self.makefile.write(f)
373
374
375 class Gencontrol(object):
376 config: ConfigMerged
377 vars: dict[str, str]
378 bundles: dict[str, PackagesBundle]
379
380 def __init__(self, config: ConfigMerged, templates, version=Version) -> None:
381 self.config, self.templates = config, templates
382 self.changelog = Changelog(version=version)
383 self.vars = {}
384 self.bundles = {}
385
386 @property
387 def bundle(self) -> PackagesBundle:
388 return self.bundles['']
389
390 def __call__(self) -> None:
391 self.do_source()
392 self.do_main()
393 self.do_extra()
394
395 self.write()
396
397 def do_source(self) -> None:
398 self.bundles[''] = PackagesBundle(
399 None, 'source.control', self.vars, self.templates,
400 override_name=self.changelog[0].source,
401 )
402
403 def do_main(self) -> None:
404 vars = self.vars.copy()
405
406 makeflags = MakeFlags()
407
408 self.do_main_setup(self.config, vars, makeflags)
409 self.do_main_makefile(self.config, vars, makeflags)
410 self.do_main_packages(self.config, vars, makeflags)
411 self.do_main_recurse(self.config, vars, makeflags)
412
413 def do_main_setup(
414 self,
415 config: ConfigMerged,
416 vars: dict[str, str],
417 makeflags: MakeFlags,
418 ) -> None:
419 pass
420
421 def do_main_makefile(
422 self,
423 config: ConfigMerged,
424 vars: dict[str, str],
425 makeflags: MakeFlags,
426 ) -> None:
427 pass
428
429 def do_main_packages(
430 self,
431 config: ConfigMerged,
432 vars: dict[str, str],
433 makeflags: MakeFlags,
434 ) -> None:
435 pass
436
437 def do_main_recurse(
438 self,
439 config: ConfigMerged,
440 vars: dict[str, str],
441 makeflags: MakeFlags,
442 ) -> None:
443 for featureset in config.root_featuresets:
444 if featureset.enable:
445 self.do_indep_featureset(featureset, vars.copy(), makeflags.copy())
446
447 # Sort the output the same way as before
448 for arch in sorted(
449 itertools.chain.from_iterable(
450 i.debianarchs for i in config.kernelarchs
451 ),
452 key=lambda i: i.name
453 ):
454 if arch.enable:
455 self.do_arch(arch, vars.copy(), makeflags.copy())
456
457 def do_extra(self) -> None:
458 try:
459 packages_extra = self.templates.get_control("extra.control", self.vars)
460 except KeyError:
461 return
462
463 for package in packages_extra:
464 package.meta_rules_target = 'meta'
465 if not package.architecture:
466 raise RuntimeError('Require Architecture in debian/templates/extra.control')
467 for arch in package.architecture:
468 self.bundle.add_packages([package], (arch, ),
469 MakeFlags(), arch=arch, check_packages=False)
470
471 def do_indep_featureset(
472 self,
473 config: ConfigMergedFeatureset,
474 vars: dict[str, str],
475 makeflags: MakeFlags,
476 ) -> None:
477 vars['config'] = config
478 vars['localversion'] = ''
479 if config.name_featureset != 'none':
480 vars['localversion'] = '-' + config.name_featureset
481
482 self.do_indep_featureset_setup(config, vars, makeflags)
483 self.do_indep_featureset_makefile(config, vars, makeflags)
484 self.do_indep_featureset_packages(config, vars, makeflags)
485
486 def do_indep_featureset_setup(
487 self,
488 config: ConfigMergedFeatureset,
489 vars: dict[str, str],
490 makeflags: MakeFlags,
491 ) -> None:
492 pass
493
494 def do_indep_featureset_makefile(
495 self,
496 config: ConfigMergedFeatureset,
497 vars: dict[str, str],
498 makeflags: MakeFlags,
499 ) -> None:
500 makeflags['FEATURESET'] = config.name
501
502 def do_indep_featureset_packages(
503 self,
504 config: ConfigMergedFeatureset,
505 vars: dict[str, str],
506 makeflags: MakeFlags,
507 ) -> None:
508 pass
509
510 def do_arch(
511 self,
512 config: ConfigMergedDebianarch,
513 vars: dict[str, str],
514 makeflags: MakeFlags,
515 ) -> None:
516 vars['config'] = config
517 vars['arch'] = config.name
518
519 self.do_arch_setup(config, vars, makeflags)
520 self.do_arch_makefile(config, vars, makeflags)
521 self.do_arch_packages(config, vars, makeflags)
522 self.do_arch_recurse(config, vars, makeflags)
523
524 def do_arch_setup(
525 self,
526 config: ConfigMergedDebianarch,
527 vars: dict[str, str],
528 makeflags: MakeFlags,
529 ) -> None:
530 pass
531
532 def do_arch_makefile(
533 self,
534 config: ConfigMergedDebianarch,
535 vars: dict[str, str],
536 makeflags: MakeFlags,
537 ) -> None:
538 makeflags['ARCH'] = config.name
539
540 def do_arch_packages(
541 self,
542 config: ConfigMergedDebianarch,
543 vars: dict[str, str],
544 makeflags: MakeFlags,
545 ) -> None:
546 pass
547
548 def do_arch_recurse(
549 self,
550 config: ConfigMergedDebianarch,
551 vars: dict[str, str],
552 makeflags: MakeFlags,
553 ) -> None:
554 for featureset in config.featuresets:
555 if featureset.enable:
556 self.do_featureset(featureset, vars.copy(), makeflags.copy())
557
558 def do_featureset(
559 self,
560 config: ConfigMergedFeatureset,
561 vars: dict[str, str],
562 makeflags: MakeFlags,
563 ) -> None:
564 vars['config'] = config
565 vars['localversion'] = ''
566 if config.name_featureset != 'none':
567 vars['localversion'] = '-' + config.name_featureset
568
569 self.do_featureset_setup(config, vars, makeflags)
570 self.do_featureset_makefile(config, vars, makeflags)
571 self.do_featureset_packages(config, vars, makeflags)
572 self.do_featureset_recurse(config, vars, makeflags)
573
574 def do_featureset_setup(
575 self,
576 config: ConfigMergedFeatureset,
577 vars: dict[str, str],
578 makeflags: MakeFlags,
579 ) -> None:
580 pass
581
582 def do_featureset_makefile(
583 self,
584 config: ConfigMergedFeatureset,
585 vars: dict[str, str],
586 makeflags: MakeFlags,
587 ) -> None:
588 makeflags['FEATURESET'] = config.name
589
590 def do_featureset_packages(
591 self,
592 config: ConfigMergedFeatureset,
593 vars: dict[str, str],
594 makeflags: MakeFlags,
595 ) -> None:
596 pass
597
598 def do_featureset_recurse(
599 self,
600 config: ConfigMergedFeatureset,
601 vars: dict[str, str],
602 makeflags: MakeFlags,
603 ) -> None:
604 for flavour in config.flavours:
605 if flavour.enable:
606 self.do_flavour(flavour, vars.copy(), makeflags.copy())
607
608 def do_flavour(
609 self,
610 config: ConfigMergedFlavour,
611 vars: dict[str, str],
612 makeflags: MakeFlags,
613 ) -> None:
614 vars['config'] = config
615 vars['localversion'] += '-' + config.name_flavour
616
617 self.do_flavour_setup(config, vars, makeflags)
618 self.do_flavour_makefile(config, vars, makeflags)
619 self.do_flavour_packages(config, vars, makeflags)
620
621 def do_flavour_setup(
622 self,
623 config: ConfigMergedFlavour,
624 vars: dict[str, str],
625 makeflags: MakeFlags,
626 ) -> None:
627 for i in (
628 ('kernel-arch', 'KERNEL_ARCH'),
629 ('localversion', 'LOCALVERSION'),
630 ):
631 if i[0] in vars:
632 makeflags[i[1]] = vars[i[0]]
633
634 def do_flavour_makefile(
635 self,
636 config: ConfigMergedFlavour,
637 vars: dict[str, str],
638 makeflags: MakeFlags,
639 ) -> None:
640 makeflags['FLAVOUR'] = config.name
641
642 def do_flavour_packages(
643 self,
644 config: ConfigMergedFlavour,
645 vars: dict[str, str],
646 makeflags: MakeFlags,
647 ) -> None:
648 pass
649
650 def substitute(self, s: str, vars) -> str:
651 def subst(match) -> str:
652 return vars[match.group(1)]
653
654 return re.sub(r'@([-_a-z0-9]+)@', subst, str(s))
655
656 def write(self) -> None:
657 for bundle in self.bundles.values():
658 bundle.extract_makefile()
659 bundle.merge_build_depends()
660 bundle.write()
661
662
663 def merge_packages(packages, new, arch) -> None:
664 for new_package in new:
665 name = new_package['Package']
666 if name in packages:
667 package = packages.get(name)
668 package['Architecture'].add(arch)
669
670 for field in ('Depends', 'Provides', 'Suggests', 'Recommends',
671 'Conflicts'):
672 if field in new_package:
673 if field in package:
674 v = package[field]
675 v.extend(new_package[field])
676 else:
677 package[field] = new_package[field]
678
679 else:
680 new_package['Architecture'] = arch
681 packages.append(new_package)