Debian Codegraph @

debian/lib/python/debian_linux/config_v2.py

raw
1 from __future__ import annotations
2
3 import dataclasses
4 import functools
5 import re
6 import subprocess
7 import tomllib
8 from collections.abc import (
9 Iterable,
10 )
11 from pathlib import Path
12 from typing import (
13 Optional,
14 Self,
15 )
16
17 import dacite
18
19 from . import dataclasses_extra
20 from .debian import PackageRelationGroup
21
22
23 # Wrapper for regex objects, whose type is not a documented API
24 class _RegexWrapper:
25 def __init__(self, s):
26 self._re = re.compile(s)
27
28 def __getattr__(self, name):
29 return getattr(self._re, name)
30
31
32 _dacite_config = dacite.Config(
33 cast=[
34 PackageRelationGroup,
35 Path,
36 _RegexWrapper,
37 ],
38 strict=True,
39 )
40
41
42 @dataclasses.dataclass
43 class ConfigBuild:
44 cflags: Optional[str] = None
45 c_compiler: Optional[str] = None
46 compiler_gnutype: Optional[str] = None
47 compiler_gnutype_compat: Optional[str] = None
48 rust_build_depends: list[PackageRelationGroup] = dataclasses.field(default_factory=list)
49 enable_rust: Optional[bool] = None
50 config: list[Path] = dataclasses.field(default_factory=list)
51 config_default: list[Path] = dataclasses.field(default_factory=list, repr=False)
52 enable_dtb: Optional[bool] = None
53 enable_signed: Optional[bool] = None
54 kernel_file: Optional[str] = None
55 kernel_stem: Optional[str] = None
56
57
58 @dataclasses.dataclass
59 class ConfigDescription:
60 hardware: Optional[str] = None
61 hardware_long: Optional[str] = None
62 parts: list[str] = dataclasses.field(default_factory=list)
63 short: dict[str, str] = dataclasses.field(default_factory=dict)
64 long: dict[str, str] = dataclasses.field(default_factory=dict)
65
66
67 @dataclasses.dataclass
68 class ConfigPackages:
69 docs: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
70 installer: Optional[bool] = dataclasses.field(default=None, metadata={'default': False})
71 libc_dev: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
72 libc_dev_cross_only: Optional[bool] = dataclasses.field(
73 default=None, metadata={'default': False})
74 meta: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
75 source: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
76 tools_unversioned: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
77 tools_versioned: Optional[bool] = dataclasses.field(default=None, metadata={'default': True})
78
79
80 @dataclasses.dataclass
81 class ConfigRelationsSingle:
82 depends: list[PackageRelationGroup] = dataclasses.field(default_factory=list)
83 recommends: list[PackageRelationGroup] = dataclasses.field(default_factory=list)
84 suggests: list[PackageRelationGroup] = dataclasses.field(default_factory=list)
85 breaks: list[PackageRelationGroup] = dataclasses.field(default_factory=list)
86
87
88 @dataclasses.dataclass
89 class ConfigRelations:
90 image: ConfigRelationsSingle = dataclasses.field(default_factory=ConfigRelationsSingle)
91
92
93 @dataclasses.dataclass
94 class ConfigDebianarchDefs:
95 __arch: Optional[str] = dataclasses.field(default=None, init=False)
96
97 def __post_init_defs__(self, parent: ConfigDebianarch) -> None:
98 self.__arch = parent.name
99
100 @staticmethod
101 @functools.cache
102 def __dpkg_architecture(arch: str, query: str) -> str:
103 return subprocess.check_output(
104 [
105 'dpkg-architecture',
106 '-f',
107 '-a', arch,
108 '-q', query,
109 ],
110 stderr=subprocess.DEVNULL,
111 encoding='ascii',
112 ).strip()
113
114 @property
115 def gnutype(self) -> str:
116 assert self.__arch is not None
117 return self.__dpkg_architecture(self.__arch, 'DEB_HOST_GNU_TYPE')
118
119 @property
120 def gnutype_package(self) -> str:
121 return self.gnutype.replace("_", "-")
122
123 @property
124 def multiarch(self) -> str:
125 assert self.__arch is not None
126 return self.__dpkg_architecture(self.__arch, 'DEB_HOST_MULTIARCH')
127
128
129 @dataclasses.dataclass
130 class ConfigFlavourDefs:
131 is_default: bool = False
132 is_test: bool = False
133
134
135 @dataclasses.dataclass
136 class ConfigDebianrelease:
137 name_regex: _RegexWrapper
138 abi_version_full: bool = True
139 abi_suffix: str = ''
140 revision_regex: _RegexWrapper = _RegexWrapper('.*')
141
142
143 @dataclasses.dataclass
144 class ConfigBase:
145 name: str
146 enable: bool = True
147 path: Optional[Path] = None
148
149 build: ConfigBuild = dataclasses.field(default_factory=ConfigBuild)
150 description: ConfigDescription = dataclasses.field(default_factory=ConfigDescription)
151 packages: ConfigPackages = dataclasses.field(default_factory=ConfigPackages)
152 relations: ConfigRelations = dataclasses.field(default_factory=ConfigRelations)
153
154 def __post_init_hierarchy__(self, path: Path) -> None:
155 '''
156 Setup path and default config in the complete hierarchy
157 '''
158 self.path = path
159 self.build.config_default = [path / 'config']
160
161 def read_replace(self, bases: Iterable[Path], path: Path) -> Self:
162 '''
163 Read defines.toml at specified path in all bases and merged them
164 '''
165 config = self
166
167 try:
168 for base in bases:
169 if (file := base / path / 'defines.toml').exists():
170 with file.open('rb') as f:
171 data = dataclasses.asdict(self) | tomllib.load(f)
172
173 config = dataclasses_extra.merge(config, dacite.from_dict(
174 data_class=self.__class__,
175 data=data,
176 config=_dacite_config,
177 ))
178 except tomllib.TOMLDecodeError as e:
179 raise RuntimeError(f'{file}: {e}') from None
180
181 return config
182
183
184 @dataclasses.dataclass
185 class Config(ConfigBase):
186 # Disable basic fields
187 name: str = dataclasses.field(init=False, repr=False, default='')
188 enable: bool = dataclasses.field(init=False, repr=False, default=True)
189
190 featureset: list[ConfigFeatureset] = dataclasses.field(
191 default_factory=list, metadata={'merge': 'assoclist'},
192 )
193 kernelarch: list[ConfigKernelarch] = dataclasses.field(
194 default_factory=list, metadata={'merge': 'assoclist'},
195 )
196 debianrelease: list[ConfigDebianrelease] = dataclasses.field(
197 default_factory=list,
198 )
199
200 def __post_init_hierarchy__(self, path: Path) -> None:
201 super().__post_init_hierarchy__(path)
202
203 for featureset in self.featureset:
204 featureset.__post_init_hierarchy_featureset__(
205 Path(f'featureset-{featureset.name}'),
206 None,
207 )
208 for kernelarch in self.kernelarch:
209 kernelarch.__post_init_hierarchy__(
210 Path(f'kernelarch-{kernelarch.name}'),
211 )
212
213 @property
214 def merged(self) -> ConfigMerged:
215 return ConfigMerged(root=self)
216
217 @classmethod
218 def read_orig(cls, bases: Iterable[Path]) -> Config:
219 '''
220 Read defines.toml at the root in all bases and merge them
221 '''
222 config = cls()
223 found = False
224
225 try:
226 for base in bases:
227 if (file := base / 'defines.toml').exists():
228 with file.open('rb') as f:
229 data = tomllib.load(f)
230 found = True
231
232 config = dataclasses_extra.merge(config, dacite.from_dict(
233 data_class=cls,
234 data=data,
235 config=_dacite_config,
236 ))
237 except (tomllib.TOMLDecodeError, dacite.exceptions.UnexpectedDataError) as e:
238 raise RuntimeError(f'{file}: {e}') from None
239 if not found:
240 raise FileNotFoundError('Did not find defines.toml in any directory')
241
242 config.__post_init_hierarchy__(Path())
243
244 config.featureset = list(cls._read_hierarchy(bases, config.featureset))
245 config.kernelarch = list(cls._read_hierarchy(bases, config.kernelarch))
246 for kernelarch in config.kernelarch:
247 kernelarch.debianarch = list(cls._read_hierarchy(bases, kernelarch.debianarch))
248
249 config.__post_init_hierarchy__(Path())
250
251 return config
252
253 @classmethod
254 def _read_hierarchy[T: ConfigBase](
255 cls, bases: Iterable[Path], orig: Iterable[T],
256 ) -> Iterable[T]:
257 for i in orig:
258 try:
259 assert i.path is not None
260 yield i.read_replace(bases, i.path)
261 except FileNotFoundError:
262 yield i
263
264
265 @dataclasses.dataclass
266 class ConfigKernelarch(ConfigBase):
267 debianarch: list[ConfigDebianarch] = dataclasses.field(
268 default_factory=list, metadata={'merge': 'assoclist'},
269 )
270
271 def __post_init_hierarchy__(self, path: Path) -> None:
272 super().__post_init_hierarchy__(path)
273
274 for debianarch in self.debianarch:
275 debianarch.__post_init_hierarchy__(
276 Path(debianarch.name),
277 )
278
279
280 @dataclasses.dataclass
281 class ConfigDebianarch(ConfigBase):
282 defs: ConfigDebianarchDefs = dataclasses.field(default_factory=ConfigDebianarchDefs)
283
284 featureset: list[ConfigFeatureset] = dataclasses.field(
285 default_factory=list, metadata={'merge': 'assoclist'},
286 )
287 flavour: list[ConfigFlavour] = dataclasses.field(
288 default_factory=list, metadata={'merge': 'assoclist'},
289 )
290
291 def __post_init__(self) -> None:
292 self.defs.__post_init_defs__(self)
293
294 def __post_init_hierarchy__(self, path: Path) -> None:
295 super().__post_init_hierarchy__(path)
296
297 for featureset in self.featureset:
298 featureset.__post_init_hierarchy_featureset__(
299 Path(path / featureset.name),
300 self,
301 )
302
303 for flavour in self.flavour:
304 flavour.__post_init_hierarchy__(path)
305
306
307 @dataclasses.dataclass
308 class ConfigFeatureset(ConfigBase):
309 flavour: list[ConfigFlavour] = dataclasses.field(default_factory=list)
310
311 def __post_init_hierarchy__(self, path: Path) -> None:
312 super().__post_init_hierarchy__(path)
313
314 for flavour in self.flavour:
315 flavour.__post_init_hierarchy__(path)
316
317 def __post_init_hierarchy_featureset__(
318 self,
319 path: Path,
320 debianarch: Optional[ConfigDebianarch],
321 ) -> None:
322 # If we have no flavours defined within a featureset, we copy it from debianarch
323 if not self.flavour and debianarch:
324 self.flavour = [
325 ConfigFlavour(name=flavour.name, defs=flavour.defs)
326 for flavour in debianarch.flavour
327 ]
328
329 if self.flavour:
330 # XXX: Remove special case of name
331 if self.name != 'none':
332 for flavour in self.flavour:
333 flavour.defs.is_default = False
334
335 self.__post_init_hierarchy__(path)
336
337
338 @dataclasses.dataclass
339 class ConfigFlavour(ConfigBase):
340 defs: ConfigFlavourDefs = dataclasses.field(default_factory=ConfigFlavourDefs)
341
342 def __post_init_hierarchy__(self, path: Path) -> None:
343 self.path = path
344 self.build.config_default = [path / f'config.{self.name}']
345
346
347 class ConfigMergedBase:
348 _entries: list[ConfigBase]
349
350 def __init__(self) -> None:
351 self._entries = []
352
353 @property
354 def enable(self) -> bool:
355 for entry in self._entries:
356 if not entry.enable:
357 return False
358 return True
359
360 @property
361 def build(self) -> ConfigBuild:
362 return dataclasses_extra.merge_default(
363 ConfigBuild, *(i.build for i in self._entries)
364 )
365
366 @property
367 def config(self) -> list[Path]:
368 ret: list[Path] = []
369 for entry in self._entries:
370 ret += entry.build.config + entry.build.config_default
371 return ret
372
373 @property
374 def config_nodefault(self) -> list[Path]:
375 ret: list[Path] = []
376 for entry in self._entries:
377 ret += entry.build.config
378 return ret
379
380 @property
381 def description(self) -> ConfigDescription:
382 return dataclasses_extra.merge_default(
383 ConfigDescription, *(i.description for i in self._entries)
384 )
385
386 @property
387 def packages(self) -> ConfigPackages:
388 return dataclasses_extra.merge_default(
389 ConfigPackages, *(i.packages for i in self._entries)
390 )
391
392 @property
393 def relations(self) -> ConfigRelations:
394 return dataclasses_extra.merge_default(
395 ConfigRelations, *(i.relations for i in self._entries)
396 )
397
398
399 class ConfigMerged(ConfigMergedBase):
400 _root: Config
401
402 def __init__(
403 self, *,
404 root: Optional[ConfigBase],
405 **kw: Optional[ConfigBase],
406 ) -> None:
407 super().__init__(**kw)
408
409 assert isinstance(root, Config)
410 self._root = root
411 self._entries.append(root)
412
413 @property
414 def root_featuresets(self) -> Iterable[ConfigMergedFeatureset]:
415 for featureset in self._root.featureset:
416 yield ConfigMergedFeatureset(
417 root=self._root,
418 root_featureset=None,
419 kernelarch=None,
420 debianarch=None,
421 debianarch_flavour=None,
422 featureset=featureset,
423 )
424
425 @property
426 def kernelarchs(self) -> Iterable[ConfigMergedKernelarch]:
427 for kernelarch in self._root.kernelarch:
428 yield ConfigMergedKernelarch(
429 root=self._root,
430 kernelarch=kernelarch,
431 )
432
433 @property
434 def debianreleases(self) -> Iterable[ConfigDebianrelease]:
435 return self._root.debianrelease
436
437
438 class ConfigMergedKernelarch(ConfigMerged):
439 _kernelarch: ConfigKernelarch
440
441 def __init__(
442 self, *,
443 kernelarch: Optional[ConfigBase],
444 **kw: Optional[ConfigBase],
445 ) -> None:
446 super().__init__(**kw)
447
448 if kernelarch is not None:
449 assert isinstance(kernelarch, ConfigKernelarch)
450 self._kernelarch = kernelarch
451 self._entries.append(kernelarch)
452
453 @property
454 def name(self) -> str:
455 return self._kernelarch.name
456
457 @property
458 def name_kernelarch(self) -> str:
459 return self._kernelarch.name
460
461 @property
462 def debianarchs(self) -> Iterable[ConfigMergedDebianarch]:
463 for debianarch in self._kernelarch.debianarch:
464 yield ConfigMergedDebianarch(
465 root=self._root,
466 kernelarch=self._kernelarch,
467 debianarch=debianarch,
468 )
469
470
471 class ConfigMergedDebianarch(ConfigMergedKernelarch):
472 _debianarch: ConfigDebianarch
473
474 def __init__(
475 self, *,
476 debianarch: Optional[ConfigBase],
477 **kw: Optional[ConfigBase],
478 ) -> None:
479 super().__init__(**kw)
480
481 if debianarch is not None:
482 assert isinstance(debianarch, ConfigDebianarch)
483 self._debianarch = debianarch
484 self._entries.append(debianarch)
485
486 @property
487 def name(self) -> str:
488 return self._debianarch.name
489
490 @property
491 def name_debianarch(self) -> str:
492 return self._debianarch.name
493
494 @property
495 def defs_debianarch(self) -> ConfigDebianarchDefs:
496 return self._debianarch.defs
497
498 @property
499 def featuresets(self) -> Iterable[ConfigMergedFeatureset]:
500 root_featureset = {
501 i.name: i
502 for i in self._root.featureset
503 }
504
505 for featureset in self._debianarch.featureset:
506 yield ConfigMergedFeatureset(
507 root=self._root,
508 root_featureset=root_featureset[featureset.name],
509 kernelarch=self._kernelarch,
510 debianarch=self._debianarch,
511 debianarch_flavour=None,
512 featureset=featureset,
513 )
514
515
516 class ConfigMergedFeatureset(ConfigMergedDebianarch):
517 _featureset: ConfigFeatureset
518 _root_featureset: Optional[ConfigFeatureset] = None
519 _debianarch_flavour: Optional[ConfigFlavour] = None
520
521 def __init__(
522 self, *,
523 featureset: Optional[ConfigBase],
524 root_featureset: Optional[ConfigBase],
525 debianarch_flavour: Optional[ConfigBase],
526 **kw: Optional[ConfigBase],
527 ) -> None:
528 super().__init__(**kw)
529
530 if debianarch_flavour is not None:
531 assert isinstance(debianarch_flavour, ConfigFlavour)
532 self._debianarch_flavour = debianarch_flavour
533 self._entries.append(debianarch_flavour)
534
535 if root_featureset is not None:
536 assert isinstance(root_featureset, ConfigFeatureset)
537 self._root_featureset = root_featureset
538 self._entries.append(root_featureset)
539
540 if featureset is not None:
541 assert isinstance(featureset, ConfigFeatureset)
542 self._featureset = featureset
543 self._entries.append(featureset)
544
545 @property
546 def name(self) -> str:
547 return self._featureset.name
548
549 @property
550 def name_featureset(self) -> str:
551 return self._featureset.name
552
553 @property
554 def flavours(self) -> Iterable[ConfigMergedFlavour]:
555 debianarch_flavour = {
556 i.name: i
557 for i in self._debianarch.flavour
558 }
559
560 for flavour in self._featureset.flavour:
561 yield ConfigMergedFlavour(
562 root=self._root,
563 root_featureset=self._root_featureset,
564 kernelarch=self._kernelarch,
565 debianarch=self._debianarch,
566 debianarch_flavour=debianarch_flavour[flavour.name],
567 featureset=self._featureset,
568 flavour=flavour,
569 )
570
571
572 class ConfigMergedFlavour(ConfigMergedFeatureset):
573 _flavour: ConfigFlavour
574
575 def __init__(
576 self, *,
577 flavour: Optional[ConfigBase],
578 **kw: Optional[ConfigBase],
579 ) -> None:
580 super().__init__(**kw)
581
582 if flavour is not None:
583 assert isinstance(flavour, ConfigFlavour)
584 self._flavour = flavour
585 self._entries.append(flavour)
586
587 @property
588 def name(self) -> str:
589 return self._flavour.name
590
591 @property
592 def name_flavour(self) -> str:
593 return self._flavour.name
594
595 @property
596 def defs_flavour(self) -> ConfigFlavourDefs:
597 return self._flavour.defs
598
599
600 if __name__ == "__main__":
601 import argparse
602
603 parser = argparse.ArgumentParser()
604 parser.add_argument(
605 'dir',
606 default=[Path('debian/config')],
607 nargs='+',
608 type=Path,
609 )
610 args = parser.parse_args()
611 config = Config.read_orig(args.dir)
612 merged = config.merged
613
614 # from pprint import pprint
615 # pprint(config)
616
617 def print_indent(indent: int, s: str, *args: str) -> None:
618 print(' ' * indent * 4 + s, *args)
619
620 for kernelarch in merged.kernelarchs:
621 print_indent(
622 0,
623 f'Kernelarch: {kernelarch.name}',
624 f'enable={kernelarch.enable}',
625 )
626
627 for debianarch in kernelarch.debianarchs:
628 print_indent(
629 1,
630 f'Debianarch: {debianarch.name}',
631 f'enable={debianarch.enable}',
632 )
633
634 for featureset in debianarch.featuresets:
635 print_indent(
636 2,
637 f'Featureset: {featureset.name}',
638 f'enable={featureset.enable}',
639 )
640
641 for flavour in featureset.flavours:
642 print_indent(
643 3,
644 f'Flavour: {flavour.name}',
645 f'enable={flavour.enable}',
646 f'is_default={flavour.defs_flavour.is_default}',
647 )
648 print_indent(4, f'Config: {" ".join(str(i) for i in flavour.config)}')
649
650 else:
651 print()