From 66648c1a03159e3d9ed8588e5539d0ad004ba0b7 Mon Sep 17 00:00:00 2001 From: Ivo De Decker Date: Thu, 17 Jan 2019 20:21:03 +0000 Subject: [PATCH] Add BuiltUsingPolicy Signed-off-by: Ivo De Decker --- britney2/__init__.py | 1 + britney2/policies/policy.py | 101 ++++++++++++++++++++++++++++++++++++ 2 files changed, 102 insertions(+) diff --git a/britney2/__init__.py b/britney2/__init__.py index 9fa3050..9ddf36b 100644 --- a/britney2/__init__.py +++ b/britney2/__init__.py @@ -6,6 +6,7 @@ class DependencyType(Enum): # BUILD_DEPENDS includes BUILD_DEPENDS_ARCH BUILD_DEPENDS = ('Build-Depends(-Arch)', 'build-depends', 'build-dependency') BUILD_DEPENDS_INDEP = ('Build-Depends-Indep', 'build-depends-indep', 'build-dependency (indep)') + BUILT_USING = ('Built-Using', 'built-using', 'built-using') def __str__(self): return self.value[0] diff --git a/britney2/policies/policy.py b/britney2/policies/policy.py index dc55604..c922579 100644 --- a/britney2/policies/policy.py +++ b/britney2/policies/policy.py @@ -933,6 +933,107 @@ class BuildDependsPolicy(BasePolicy): return verdict +class BuiltUsingPolicy(BasePolicy): + """Built-Using policy + + Binaries that incorporate (part of) another source package must list these + sources under 'Built-Using'. + + This policy checks if the corresponding sources are available in the + target suite. If they are not, but they are candidates for migration, a + dependency is added. + + If the binary incorporates a newer version of a source, that is not (yet) + a candidate, we don't want to accept that binary. A rebuild later in the + primary suite wouldn't fix the issue, because that would incorporate the + newer version again. + + If the binary incorporates an older version of the source, a newer version + will be accepted as a replacement. We assume that this can be fixed by + rebuilding the binary at some point during the development cycle. + + Requiring exact version of the source would not be useful in practice. A + newer upload of that source wouldn't be blocked by this policy, so the + built-using would be outdated anyway. + + """ + + def __init__(self, options, suite_info): + super().__init__('built-using', options, suite_info, + {SuiteClass.PRIMARY_SOURCE_SUITE, SuiteClass.ADDITIONAL_SOURCE_SUITE}, + ApplySrcPolicy.RUN_ON_EVERY_ARCH_ONLY) + self._britney = None + + def initialise(self, britney): + super().initialise(britney) + self._britney = britney + + def apply_srcarch_policy_impl(self, build_deps_info, suite, source_name, arch, source_data_tdist, source_data_srcdist, excuse, + get_dependency_solvers=get_dependency_solvers): + verdict = PolicyVerdict.PASS + britney = self._britney + + source_suite = self.suite_info[suite] + target_suite = self.suite_info.target_suite + binaries_s = source_suite.binaries + provides_s = source_suite.provides_table + binaries_t = target_suite.binaries + provides_t = target_suite.provides_table + + sources_t = target_suite.sources + + def check_bu_in_suite(bu_source, bu_version, source_suite): + found = False + if not bu_source in source_suite.sources: + return found + s_source = source_suite.sources[bu_source] + s_ver = s_source.version + if apt_pkg.version_compare(s_ver, bu_version) >= 0: + found = True + item_name = compute_item_name(sources_t, source_suite.sources, bu_source, arch) + if arch in self.options.break_arches: + excuse.addhtml("Ignoring Built-Using for %s/%s on %s" % (pkg_name,arch,item_name)) + else: + excuse.add_dependency(DependencyType.BUILT_USING, item_name, arch) + excuse.addhtml("%s/%s has Built-Using on %s" % (pkg_name,arch,item_name)) + + return found + + + for pkg_id in sorted(x for x in source_data_srcdist.binaries if x.architecture == arch): + pkg_name = pkg_id.package_name + + # retrieve the testing (if present) and unstable corresponding binary packages + binary_t = binaries_t[arch][pkg_name] if pkg_name in binaries_t[arch] else None + binary_s = binaries_s[arch][pkg_name] + + for bu in binary_s.builtusing: + bu_source = bu[0] + bu_version = bu[1] + found = False + if bu_source in target_suite.sources: + t_source = target_suite.sources[bu_source] + t_ver = t_source.version + if apt_pkg.version_compare(t_ver, bu_version) >= 0: + found = True + + if not found: + found = check_bu_in_suite(bu_source, bu_version, source_suite) + + if not found and source_suite.suite_class.is_additional_source: + found = check_bu_in_suite(bu_source, bu_version, self.suite_info.primary_source_suite) + + if not found: + if arch in self.options.break_arches: + excuse.addhtml("Ignoring unsatisfiable Built-Using for %s/%s on %s %s" % (pkg_name,arch, bu_source, bu_version)) + else: + excuse.addhtml("%s/%s has unsatisfiable Built-Using on %s %s" % (pkg_name,arch, bu_source, bu_version)) + if verdict.value < PolicyVerdict.REJECTED_PERMANENTLY.value: + verdict = PolicyVerdict.REJECTED_PERMANENTLY + + return verdict + + class BlockPolicy(BasePolicy): BLOCK_HINT_REGEX = re.compile('^(un)?(block-?.*)$')