Edit File: debdiff-apply
#!/usr/bin/python3 # Copyright (c) 2016-2017, Ximin Luo <infinity0@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. # # See file /usr/share/common-licenses/GPL-3 for more details. # # pylint: disable=invalid-name # pylint: enable=invalid-name """ Apply a debdiff to a Debian source package. It handles d/changelog hunks specially, to avoid conflicts. Depends on dpkg-dev, devscripts, python3-unidiff, quilt. """ import argparse import email.utils import hashlib import logging import os import shutil import subprocess import sys import tempfile import time try: import unidiff except ImportError: print( "Please install 'python3-unidiff' in order to use this utility.", file=sys.stderr, ) sys.exit(1) from debian.changelog import ChangeBlock, Changelog # this can be any valid value, it doesn't appear in the final output DCH_DUMMY_TAIL = ( "\n -- debdiff-apply dummy tool <infinity0@debian.org> " "Thu, 01 Jan 1970 00:00:00 +0000\n\n" ) CHBLOCK_DUMMY_PACKAGE = "debdiff-apply PLACEHOLDER" TRY_ENCODINGS = ["utf-8", "latin-1"] DISTRIBUTION_DEFAULT = "experimental" def workaround_dpkg_865430(dscfile, origdir, stdout): filename = subprocess.check_output(["dcmd", "--tar", "echo", dscfile]).rstrip() if not os.path.exists( os.path.join(origdir.encode("utf-8"), os.path.basename(filename)) ): subprocess.check_call(["dcmd", "--tar", "cp", dscfile, origdir], stdout=stdout) def is_dch(path): dirname = os.path.dirname(path) return ( os.path.basename(path) == "changelog" and os.path.basename(dirname) == "debian" and os.path.dirname(os.path.dirname(dirname)) == "" ) def hunk_lines_to_str(hunk_lines): return "".join(map(lambda x: str(x)[1:], hunk_lines)) def read_dch_patch(dch_patch): if len(dch_patch) > 1: raise ValueError( "don't know how to deal with debian/changelog patch " "that has more than one hunk" ) hunk = dch_patch[0] source_str = hunk_lines_to_str(hunk.source_lines()) + DCH_DUMMY_TAIL target_str = hunk_lines_to_str(hunk.target_lines()) # here we assume the debdiff has enough context to see the previous version # this should be true all the time in practice source_version = str(Changelog(source_str, 1)[0].version) target = Changelog(target_str, 1)[0] return source_version, target def apply_dch_patch(source_file, current, old_version, target, dry_run): target_version = str(target.version) if not old_version or not target_version.startswith(old_version): logging.warning( "don't know how to rebase version-change (%s => %s) onto %s", old_version, target_version, old_version, ) newlog = subprocess.getoutput("EDITOR=cat dch -n 2>/dev/null").rstrip() version = str(Changelog(newlog, 1)[0].version) logging.warning( "using version %s based on `dch -n`; feel free to make me smarter", version ) else: version_suffix = target_version[len(old_version) :] version = str(current[0].version) + version_suffix logging.info("using version %s based on suffix %s", version, version_suffix) if dry_run: return version current._blocks.insert(0, target) # pylint: disable=protected-access current.set_version(version) shutil.copy(source_file, source_file + ".new") try: # disable unspecified-encoding, as in Mattia's opinion this should # likely be rewritten to use pure binary instead of encode/decode. # pylint: disable=unspecified-encoding with open(source_file + ".new", "w") as fp: current.write_to_open_file(fp) os.rename(source_file + ".new", source_file) except Exception: logging.warning("failed to patch %s", source_file) logging.warning("half-applied changes in %s", source_file + ".new") logging.warning("current working directory is %s", os.getcwd()) raise return version def call_patch(patch_str, *args, check=True, **kwargs): return subprocess.run( ["patch", "-p1"] + list(args), input=patch_str, universal_newlines=True, check=check, **kwargs, ) def check_patch(patch_str, *args, **kwargs): patch = call_patch( patch_str, "--dry-run", "-f", "--silent", *args, check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, **kwargs, ) return patch.returncode == 0 def debdiff_apply(patch, patch_name, args): # don't change anything if... dry_run = args.target_version or args.source_version changelog = list(filter(lambda x: is_dch(x.path), patch)) if not changelog: logging.info("no debian/changelog in patch: %s", args.patch_file) old_version = None target = ChangeBlock( package=CHBLOCK_DUMMY_PACKAGE, author=f"{os.getenv('DEBFULLNAME')} <{os.getenv('DEBEMAIL')}>", date=email.utils.formatdate(time.time(), localtime=True), version=None, distributions=args.distribution, urgency="low", changes=["", f" * Rebase patch {patch_name}.", ""], ) target.add_trailing_line("") elif len(changelog) > 1: raise ValueError("more than one debian/changelog patch???") else: patch.remove(changelog[0]) old_version, target = read_dch_patch(changelog[0]) if args.source_version: if old_version: print(old_version) return False # read this here so --source-version can work even without a d/changelog with open(args.changelog, encoding="utf8") as fp: current = Changelog(fp.read()) if target.package == CHBLOCK_DUMMY_PACKAGE: target.package = current[0].package if not dry_run: patch_str = str(patch) if check_patch(patch_str, "-N"): call_patch(patch_str) logging.info("patch %s applies!", patch_name) elif check_patch(patch_str, "-R"): logging.warning("patch %s already applied", patch_name) return False else: call_patch(patch_str, "--dry-run", "-f") raise ValueError(f"patch {patch_name} doesn't apply!") # only apply d/changelog patch if the rest of the patch applied new_version = apply_dch_patch(args.changelog, current, old_version, target, dry_run) if args.target_version: print(new_version) return False if args.repl: import code # pylint: disable=import-outside-toplevel code.interact(local=locals()) return True def parse_args(args): parser = argparse.ArgumentParser( description="Apply a debdiff to a Debian source package" ) parser.add_argument( "-v", "--verbose", action="store_true", help="Output more information" ) parser.add_argument( "-c", "--changelog", default="debian/changelog", help="Path to debian/changelog; default: %(default)s", ) parser.add_argument( "-D", "--distribution", default="experimental", help="Distribution to use, if the patch doesn't already " "contain a changelog; default: %(default)s", ) parser.add_argument( "--repl", action="store_true", help="Run the python REPL after processing." ) parser.add_argument( "--source-version", action="store_true", help="Don't apply the patch; instead print out the version of the " "package that it is supposed to be applied to, or nothing if " "the patch does not specify a source version.", ) parser.add_argument( "--target-version", action="store_true", help="Don't apply the patch; instead print out the new version of the " "package debdiff-apply(1) would generate, when the patch is applied to the " "the given target package, as specified by the other arguments.", ) parser.add_argument( "orig_dsc_or_dir", nargs="?", default=".", help="Target to apply the patch to. This can either be an unpacked " "source tree, or a .dsc file. In the former case, the directory is " "modified in-place; in the latter case, a second .dsc is created. " "Default: %(default)s", ) parser.add_argument( "patch_file", nargs="?", default="/dev/stdin", help="Patch file to apply, in the format output by debdiff(1)." " Default: %(default)s", ) group1 = parser.add_argument_group("Options for .dsc patch targets") group1.add_argument( "--no-clean", action="store_true", help="Don't clean temporary directories after a failure, so you can " "examine what failed.", ) group1.add_argument( "--quilt-refresh", action="store_true", help="If the building of the new source package fails, try to refresh " "patches using quilt(1) then try building it again.", ) group1.add_argument( "-d", "--directory", default=None, help="Extract the .dsc into this directory, which won't be cleaned up " "after debdiff-apply(1) exits. If not given, then it will be extracted to a " "temporary directory.", ) return parser.parse_args(args) def main(args): # Split this function! # pylint: disable=too-many-branches,too-many-locals,too-many-statements args = parse_args(args) if args.verbose: logging.getLogger().setLevel(logging.DEBUG) with open(args.patch_file, "rb") as fp: data = fp.read() for enc in TRY_ENCODINGS: try: patch = unidiff.PatchSet(data.splitlines(keepends=True), encoding=enc) break except Exception: # pylint: disable=broad-except if enc == TRY_ENCODINGS[-1]: raise continue hex_digest = hashlib.sha256(data).hexdigest()[ : 20 if args.patch_file == "/dev/stdin" else 8 ] patch_name = f"{os.path.basename(args.patch_file)}:{hex_digest}" quiet = args.source_version or args.target_version dry_run = args.source_version or args.target_version # user can redirect stderr themselves stdout = subprocess.DEVNULL if quiet else None # change directory before applying patches if os.path.isdir(args.orig_dsc_or_dir): os.chdir(args.orig_dsc_or_dir) debdiff_apply(patch, patch_name, args) elif os.path.isfile(args.orig_dsc_or_dir): dscfile = args.orig_dsc_or_dir parts = os.path.splitext(os.path.basename(dscfile)) if parts[1] != ".dsc": raise ValueError(f"unrecognised patch target: {dscfile}") extractdir = args.directory if args.directory else tempfile.mkdtemp() if not os.path.isdir(extractdir): os.makedirs(extractdir) try: # dpkg-source doesn't like existing dirs builddir = os.path.join(extractdir, parts[0]) subprocess.check_call( ["dpkg-source", "-x", "--skip-patches", dscfile, builddir], stdout=stdout, ) origdir = os.getcwd() workaround_dpkg_865430(dscfile, origdir, stdout) os.chdir(builddir) did_patch = debdiff_apply(patch, patch_name, args) if dry_run or not did_patch: return os.chdir(origdir) try: subprocess.check_call(["dpkg-source", "-b", builddir]) except subprocess.CalledProcessError: if args.quilt_refresh: subprocess.check_call( [ "sh", "-c", """ set -ex export QUILT_PATCHES=debian/patches while quilt push; do quilt refresh; done """, ], cwd=builddir, ) subprocess.check_call(["dpkg-source", "-b", builddir]) else: raise finally: cleandir = builddir if args.directory else extractdir if args.no_clean: logging.warning("you should clean up temp files in %s", cleandir) else: shutil.rmtree(cleandir) if __name__ == "__main__": sys.exit(main(sys.argv[1:]))