Adding upstream version 2.19.5+deb10u1.upstream/2.19.5+deb10u1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 196 insertions, 0 deletions

diff --git a/scripts/reproducible-check b/scripts/reproducible-check
new file mode 100755
index 0000000..64b6617
--- /dev/null
+++ b/scripts/reproducible-check
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2017 Chris Lamb <lamby@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 3 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 bz2
+import collections
+import json
+import logging
+import os
+import sys
+import time
+
+import apt
+import requests
+
+try:
+    from xdg.BaseDirectory import xdg_cache_home
+except ImportError:
+    print("This script requires the xdg python3 module.", file=sys.stderr)
+    print("Please install the python3-xdg Debian package in order to use"
+          "this utility.", file=sys.stderr)
+    sys.exit(1)
+
+
+class ReproducibleCheck:
+    HELP = """
+        Reports on the reproducible status of installed packages.
+        For more details please see <https://reproducible-builds.org>.
+    """
+
+    NAME = os.path.basename(__file__)
+    VERSION = 1
+
+    STATUS_URL = 'https://tests.reproducible-builds.org/debian/' \
+        'reproducible-tracker.json.bz2'
+
+    CACHE = os.path.join(xdg_cache_home, NAME, os.path.basename(STATUS_URL))
+    CACHE_AGE_SECONDS = 86400
+
+    @classmethod
+    def parse(cls):
+        parser = argparse.ArgumentParser(description=cls.HELP)
+
+        parser.add_argument(
+            '-d',
+            '--debug',
+            help="show debugging messages",
+            default=False,
+            action='store_true',
+        )
+
+        parser.add_argument(
+            '-r',
+            '--raw',
+            help="print unreproducible binary packages only (for dd-list -i)",
+            default=False,
+            action='store_true',
+        )
+
+        parser.add_argument(
+            '--version',
+            help="print version and exit",
+            default=False,
+            action='store_true',
+        )
+
+        return cls(parser.parse_args())
+
+    def __init__(self, args):
+        self.args = args
+
+        logging.basicConfig(
+            format='%(asctime).19s %(levelname).1s: %(message)s',
+            level=logging.DEBUG if args.debug else logging.INFO,
+        )
+
+        self.log = logging.getLogger()
+
+    def main(self):
+        if self.args.version:
+            print("{} version {}".format(self.NAME, self.VERSION))
+            return 0
+
+        self.update_cache()
+
+        data = self.get_data()
+        installed = self.get_installed_packages()
+        unreproducible = {x: y for x, y in installed.items() if x in data}
+
+        if self.args.raw:
+            self.output_raw(unreproducible, installed)
+        else:
+            self.output_by_source(unreproducible, installed)
+
+        return 0
+
+    def update_cache(self):
+        self.log.debug("Checking cache file %s ...", self.CACHE)
+
+        try:
+            if os.path.getmtime(self.CACHE) >= \
+                    time.time() - self.CACHE_AGE_SECONDS:
+                self.log.debug("Cache is up to date")
+                return
+        except OSError:
+            pass
+
+        self.log.info("Updating cache...")
+
+        response = requests.get(self.STATUS_URL)
+
+        os.makedirs(os.path.dirname(self.CACHE), exist_ok=True)
+
+        with open(self.CACHE, 'wb+') as f:
+            f.write(response.content)
+
+    def get_data(self):
+        self.log.debug("Loading data from cache %s", self.CACHE)
+
+        with bz2.open(self.CACHE) as f:
+            return {
+                (x['package'], y['architecture'], x['version'])
+                for x in json.loads(f.read().decode('utf-8'))
+                for y in x['architecture_details']
+                if y['status'] == 'unreproducible'
+            }
+
+    @staticmethod
+    def get_installed_packages():
+        result = collections.defaultdict(list)
+
+        for x in apt.Cache():
+            for y in x.versions:
+                if not y.is_installed:
+                    continue
+
+                key = (y.source_name, y.architecture, y.version)
+                result[key].append(x.shortname)
+
+        return result
+
+    @staticmethod
+    def output_by_source(unreproducible, installed):
+        num_installed = sum(len(x) for x in installed.keys())
+        num_unreproducible = sum(len(x) for x in unreproducible.keys())
+        default_architecture = apt.apt_pkg.config.find('APT::Architecture')
+
+        for key, binaries in sorted(unreproducible.items()):
+            source, architecture, version = key
+
+            binaries_fmt = '({}) '.format(', '.join(binaries)) \
+                if binaries != [source] else ''
+
+            print("{}{} ({}) is unreproducible {}".format(
+                source,
+                '/{}'.format(architecture)
+                if architecture != default_architecture else '',
+                version,
+                binaries_fmt,
+            ), end='')
+            print("<https://tests.reproducible-builds.org/debian/{}>".format(
+                source,
+            ))
+
+        msg = "{}/{} ({:.2f}%) of installed binary packages are unreproducible."
+        print(msg.format(
+            num_unreproducible,
+            num_installed,
+            100. * num_unreproducible / num_installed,
+        ))
+
+    @staticmethod
+    def output_raw(unreproducible, installed):  # pylint: disable=unused-argument
+        for x in sorted(x for xs in unreproducible.values() for x in set(xs)):
+            print(x)
+
+
+if __name__ == '__main__':
+    try:
+        sys.exit(ReproducibleCheck.parse().main())
+    except (KeyboardInterrupt, BrokenPipeError):
+        sys.exit(1)