def test_import_30_additional_tarball_pristine_tar(self): """Test that importing a package with additional tarballs works""" def _dsc(version): return os.path.join(DEB_TEST_DATA_DIR, 'dsc-3.0-additional-tarballs', 'hello-debhelper_%s.dsc' % version) dscfile = _dsc('2.8-1') assert import_dsc([ 'arg0', '--verbose', '--pristine-tar', '--debian-branch=master', '--upstream-branch=upstream', dscfile ]) == 0 repo = ComponentTestGitRepository('hello-debhelper') self._check_repo_state(repo, 'master', ['master', 'pristine-tar', 'upstream']) commits, expected = len(repo.get_commits()), 2 commitmsg = repo.get_commit_info('HEAD')['body'] ok_("hello-debhelper (2.8-1) unstable; urgency=low" in commitmsg) ok_("hello (1.3-7) experimental; urgency=LOW" in commitmsg) for file in [b'foo/test1', b'foo/test2']: ok_( file in repo.ls_tree('HEAD'), "Could not find component tarball file %s in %s" % (file, repo.ls_tree('HEAD'))) ok_(commits == expected, "Found %d commit instead of %d" % (commits, expected)) dsc = DscFile.parse(dscfile) # Check if we can rebuild the tarball and component ptars = [('hello-debhelper_2.8.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.8.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.8', 'gzip', outdir, component=s) new = self.hash_file(os.path.join(outdir, f)) eq_( old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new))
def test_import_multiple_pristine_tar(self): """Test if importing a multiple tarball package works""" def _dsc(version): return os.path.join(DEB_TEST_DATA_DIR, 'dsc-3.0-additional-tarballs', 'hello-debhelper_%s.dsc' % version) dscfile = _dsc('2.8-1') assert import_dsc(['arg0', '--verbose', '--pristine-tar', '--debian-branch=master', '--upstream-branch=upstream', dscfile]) == 0 repo = ComponentTestGitRepository('hello-debhelper') self._check_repo_state(repo, 'master', ['master', 'pristine-tar', 'upstream']) commits, expected = len(repo.get_commits()), 2 commitmsg = repo.get_commit_info('HEAD')['body'] ok_("hello-debhelper (2.8-1) unstable; urgency=low" in commitmsg) ok_("hello (1.3-7) experimental; urgency=LOW" in commitmsg) for file in ['foo/test1', 'foo/test2']: ok_(file in repo.ls_tree('HEAD'), "Could not find component tarball file %s in %s" % (file, repo.ls_tree('HEAD'))) ok_(commits == expected, "Found %d commit instead of %d" % (commits, expected)) dsc = DscFile.parse(dscfile) # Check if we can rebuild the tarball and component ptars = [('hello-debhelper_2.8.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.8.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.8', 'gzip', outdir, component=s) new = self.hash_file(os.path.join(outdir, f)) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new))
def test_update_component_tarballs(self, repo): """ Test importing new version with additional tarballs works """ # Import 2.8 orig = self._orig('2.8', dir='dsc-3.0-additional-tarballs') ok_(import_orig(['arg0', '--component=foo', '--no-interactive', '--pristine-tar', orig]) == 0) self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'], tags=['debian/2.6-2', 'upstream/2.6', 'upstream/2.8']) self._check_component_tarballs(repo, [b'foo/test1', b'foo/test2']) ok_(os.path.exists('debian/changelog')) dsc = DscFile.parse(_dsc_file(self.pkg, '2.8-1', dir='dsc-3.0-additional-tarballs')) # Check if we can rebuild the upstream tarball and additional tarball ptars = [('hello-debhelper_2.8.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.8.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.8', 'gzip', outdir, component=s) out = os.path.join(outdir, f) new = self.hash_file(out) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new)) os.unlink(out) # Import 2.9 orig = self._orig('2.9', dir='dsc-3.0-additional-tarballs') ok_(import_orig(['arg0', '--component=foo', '--no-interactive', '--pristine-tar', orig]) == 0) self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'], tags=['debian/2.6-2', 'upstream/2.6', 'upstream/2.8', 'upstream/2.9']) self._check_component_tarballs(repo, ['foo/test1', 'foo/test2', 'foo/test3']) ok_(os.path.exists('debian/changelog')) dsc = DscFile.parse(_dsc_file(self.pkg, '2.9-1', dir='dsc-3.0-additional-tarballs')) # Check if we can rebuild the upstream tarball and additional tarball ptars = [('hello-debhelper_2.9.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.9.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.9', 'gzip', outdir, component=s) new = self.hash_file(os.path.join(outdir, f)) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new))
def test_import_multiple_pristine_tar(self): """Test if importing a multiple tarball package works""" def _dsc(version): return os.path.join(DEB_TEST_DATA_DIR, "dsc-3.0-additional-tarballs", "hello-debhelper_%s.dsc" % version) dscfile = _dsc("2.8-1") assert ( import_dsc( ["arg0", "--verbose", "--pristine-tar", "--debian-branch=master", "--upstream-branch=upstream", dscfile] ) == 0 ) repo = ComponentTestGitRepository("hello-debhelper") self._check_repo_state(repo, "master", ["master", "pristine-tar", "upstream"]) commits, expected = len(repo.get_commits()), 2 for file in ["foo/test1", "foo/test2"]: ok_( file in repo.ls_tree("HEAD"), "Could not find component tarball file %s in %s" % (file, repo.ls_tree("HEAD")), ) ok_(commits == expected, "Found %d commit instead of %d" % (commits, expected)) dsc = DscFile.parse(dscfile) # Check if we can rebuild the tarball and subtarball ptars = [ ("hello-debhelper_2.8.orig.tar.gz", "pristine-tar", "", dsc.tgz), ("hello-debhelper_2.8.orig-foo.tar.gz", "pristine-tar^", "foo", dsc.additional_tarballs["foo"]), ] p = DebianPristineTar(repo) outdir = os.path.abspath(".") for f, w, s, o in ptars: eq_(repo.get_subject(w), "pristine-tar data for %s" % f) old = self._hash_file(o) p.checkout("hello-debhelper", "2.8", "gzip", outdir, subtarball=s) new = self._hash_file(os.path.join(outdir, f)) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new))
def test_update_component_tarballs(self): """ Test importing new version with additional tarballs works """ dsc = self._dsc('2.6-2') ok_(import_dsc(['arg0', '--pristine-tar', dsc]) == 0) repo = ComponentTestGitRepository(self.pkg) os.chdir(self.pkg) self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar']) # Import 2.8 orig = self._orig('2.8', dir='dsc-3.0-additional-tarballs') ok_(import_orig(['arg0', '--component=foo', '--no-interactive', '--pristine-tar', orig]) == 0) self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'], tags=['debian/2.6-2', 'upstream/2.6', 'upstream/2.8']) self._check_component_tarballs(repo, ['foo/test1', 'foo/test2']) dsc = DscFile.parse(self._dsc('2.8-1', dir='dsc-3.0-additional-tarballs')) # Check if we can rebuild the upstream tarball and additional tarball ptars = [('hello-debhelper_2.8.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.8.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.8', 'gzip', outdir, component=s) out = os.path.join(outdir, f) new = self.hash_file(out) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new)) os.unlink(out) # Import 2.9 orig = self._orig('2.9', dir='dsc-3.0-additional-tarballs') ok_(import_orig(['arg0', '--component=foo', '--no-interactive', '--pristine-tar', orig]) == 0) self._check_repo_state(repo, 'master', ['master', 'upstream', 'pristine-tar'], tags=['debian/2.6-2', 'upstream/2.6', 'upstream/2.8', 'upstream/2.9']) self._check_component_tarballs(repo, ['foo/test1', 'foo/test2', 'foo/test3']) dsc = DscFile.parse(self._dsc('2.9-1', dir='dsc-3.0-additional-tarballs')) # Check if we can rebuild the upstream tarball and additional tarball ptars = [('hello-debhelper_2.9.orig.tar.gz', 'pristine-tar', '', dsc.tgz), ('hello-debhelper_2.9.orig-foo.tar.gz', 'pristine-tar^', 'foo', dsc.additional_tarballs['foo'])] p = DebianPristineTar(repo) outdir = os.path.abspath('.') for f, w, s, o in ptars: eq_(repo.get_subject(w), 'pristine-tar data for %s' % f) old = self.hash_file(o) p.checkout('hello-debhelper', '2.9', 'gzip', outdir, component=s) new = self.hash_file(os.path.join(outdir, f)) eq_(old, new, "Checksum %s of regenerated tarball %s does not match original %s" % (f, old, new))
def __init__(self, path): super(DebianGitRepository, self).__init__(path) self.pristine_tar = DebianPristineTar(self)
def __init__(self, *args, **kwargs): super(DebianGitRepository, self).__init__(*args, **kwargs) self.pristine_tar = DebianPristineTar(self)
class DebianGitRepository(PkgGitRepository): """A git repository that holds the source of a Debian package""" version_mangle_re = PkgPolicy.version_mangle_re def __init__(self, *args, **kwargs): super(DebianGitRepository, self).__init__(*args, **kwargs) self.pristine_tar = DebianPristineTar(self) def tree_drop_dirs(self, tree, dirs): """ Drop the given top level dirs from the given git tree returning a new tree object. """ objs = self.list_tree(tree) new_tree_objs = [] dirs = [to_bin(d) for d in dirs] for m, t, s, n in objs: if not (n in dirs and t == 'tree'): new_tree_objs.append((m, t, s, n)) new_tree = self.make_tree(new_tree_objs) return new_tree def tree_get_dir(self, tree, dir): """ Get the SHA1 of directory in a given tree """ dir = to_bin(dir) toplevel = self.list_tree(tree) for m, t, s, n in toplevel: if n == dir and t == 'tree': return s return None def find_version(self, format, version): """ Check if a certain version is stored in this repo and return the SHA1 of the related commit. That is, an annotated tag is dereferenced to the commit object it points to. For legacy tags don't only check the tag itself but also the commit message, since the former wasn't injective until release 0.5.5. You only need to use this function if you also need to check for legacy tags. @param format: tag pattern @type format: C{str} @param version: debian version number @type version: C{str} @return: sha1 of the commit the tag references to @rtype: C{str} """ tag = self.version_to_tag(format, version) legacy_tag = self._build_legacy_tag(format, version) if self.has_tag(tag): # new tags are injective # dereference to a commit object return self.rev_parse("%s^0" % tag) elif self.has_tag(legacy_tag): out, ret = self._git_getoutput('cat-file', args=['-p', legacy_tag]) if ret: return None for line in out: line = line.decode() if line.endswith(" %s\n" % version): # dereference to a commit object return self.rev_parse("%s^0" % legacy_tag) elif line.startswith('---'): # GPG signature start return None return None def debian_version_from_upstream(self, upstream_tag_format, upstream_branch, commit='HEAD', epoch=None, debian_release=True): """ Build the Debian version that a package based on upstream commit I{commit} would carry taking into account a possible epoch. @param upstream_tag_format: the tag format on the upstream branch @type upstream_tag_format: C{str} @param upstream_branch: the upstream branch @type upstream_branch: C{str} @param commit: the commit to search for the latest upstream version @param epoch: an epoch to use @param debian_release: If set to C{False} don't append a Debian release number to the version number @returns: a new debian version @raises GitRepositoryError: if no upstream tag was found """ pattern = self._unmangle_format(upstream_tag_format) % dict( version='*') tag = self.find_branch_tag(commit, upstream_branch, pattern=pattern) version = self.tag_to_version(tag, upstream_tag_format) if debian_release: version += "-1" if epoch: version = "%s:%s" % (epoch, version) return version @staticmethod def _build_legacy_tag(format, version): """ Legacy tags (prior to 0.5.5) dropped epochs and didn't honor the '~' >>> DebianGitRepository._build_legacy_tag('upstream/%(version)s', '1:2.0~3') 'upstream/2.0.3' """ if ':' in version: # strip of any epochs version = version.split(':', 1)[1] version = version.replace('~', '.') return format % dict(version=version) @classmethod def version_to_tag(cls, format, version): """Generate a tag from a given format and a version %(version)s provides a clean version that works as a git tag. %(hversion)s provides the same thing, but with '.' replaced with '-'. hversion is useful for upstreams with tagging policies that prohibit . characters. %(version%A%B)s provides %(version)s with string 'A' replaced by 'B'. This way, simple version mangling is possible via substitution. Inside the substition string, '%' needs to be escaped. See the examples below. >>> DebianGitRepository.version_to_tag("debian/%(version)s", "0:0~0") 'debian/0%0_0' >>> DebianGitRepository.version_to_tag("libfoo-%(hversion)s", "1.8.1") 'libfoo-1-8-1' >>> DebianGitRepository.version_to_tag("v%(version%.%_)s", "1.2.3") 'v1_2_3' >>> DebianGitRepository.version_to_tag(r'%(version%-%\\%)s', "0-1.2.3") '0%1.2.3' """ return PkgPolicy.version_subst(format, version, cls._sanitize_version) @classmethod def _mangle_version(cls, format, version): """ Basic version mangling to replace single characters >>> DebianGitRepository._mangle_version(r'%(version%-%\\%)s', "0-1.2.3") ('%(version)s', '0%1.2.3') """ r = re.search(cls.version_mangle_re, format) if r: f = re.sub(cls.version_mangle_re, "%(version)s", format) v = version.replace(r.group('M'), r.group('R').replace(r'\%', '%')) return f, v else: return format, version @classmethod def _unmangle_format(cls, format): """ Reverse of _mangle_version for format """ r = re.search(cls.version_mangle_re, format) if r: return re.sub(cls.version_mangle_re, "%(version)s", format) else: return format @classmethod def _unmangle_version(cls, format, tag): """ Reverse of _mangle_version for version """ r = re.search(cls.version_mangle_re, format) if r: v = tag.replace(r.group('R').replace(r'\%', '%'), r.group('M')) return v else: return tag @staticmethod def _sanitize_version(version): """sanitize a version so git accepts it as a tag as described in DEP14 >>> DebianGitRepository._sanitize_version("0.0.0") '0.0.0' >>> DebianGitRepository._sanitize_version("0.0~0") '0.0_0' >>> DebianGitRepository._sanitize_version("0:0.0") '0%0.0' >>> DebianGitRepository._sanitize_version("0%0~0") '0%0_0' >>> DebianGitRepository._sanitize_version("0....0") '0.#.#.#.0' >>> DebianGitRepository._sanitize_version("0.lock") '0.#lock' """ v = re.sub(r'\.(?=\.|$|lock$)', '.#', version) return v.replace('~', '_').replace(':', '%') @staticmethod def _unsanitize_version(tag): """Reverse _sanitize_version as described in DEP14 >>> DebianGitRepository._unsanitize_version("1%0_bpo3") '1:0~bpo3' >>> DebianGitRepository._unsanitize_version("1%0_bpo3.#.") '1:0~bpo3..' """ return tag.replace('_', '~').replace('%', ':').replace('#', '') @classmethod def tag_to_version(cls, tag, format): """Extract the version from a tag >>> DebianGitRepository.tag_to_version("upstream/1%2_3-4", "upstream/%(version)s") '1:2~3-4' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "foo/%(version)s") '2.3.4' >>> DebianGitRepository.tag_to_version("v1-2-3", "v%(version%.%-)s") '1.2.3' >>> DebianGitRepository.tag_to_version("v1.#.2", "v%(version%.%-)s") '1..2' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "upstream/%(version)s") """ f = cls._unmangle_format(format) version_re = f.replace('%(version)s', r'(?P<version>[\w_%+-.#]+)') r = re.match(version_re, tag) if r: v = cls._unsanitize_version(r.group('version')) return cls._unmangle_version(format, v) return None @property def pristine_tar_branch(self): """ The name of the pristine-tar branch, whether it already exists or not. """ return DebianPristineTar.branch def has_pristine_tar_branch(self): """ Whether the repo has a I{pristine-tar} branch. @return: C{True} if the repo has pristine-tar commits already, C{False} otherwise @rtype: C{Bool} """ return True if self.has_branch(self.pristine_tar_branch) else False def create_pristine_tar_commits(self, upstream_tree, sources): """ Create pristine-tar commits for a package with main tarball and (optional) component tarballs based on upstream_tree @param upstream_tree: the treeish in the git repo to create the commits against @param soures: C{list} of tarball as I{UpstreamSource}. First one being the main tarball the other ones additional tarballs. """ components = [t.component for t in sources[1:]] main_tree = self.tree_drop_dirs(upstream_tree, components) try: for source in sources[1:]: subtree = self.tree_get_dir(upstream_tree, source.component) if not subtree: raise GitRepositoryError( "No tree for '%s' found in '%s' to create " "pristine tar commit from" % (source.component, upstream_tree)) gbp.log.debug("Creating pristine tar commit '%s' from '%s'" % (source.path, subtree)) self.pristine_tar.commit(source.path, subtree, signaturefile=source.signaturefile, quiet=True) self.pristine_tar.commit(sources[0].path, main_tree, signaturefile=sources[0].signaturefile, quiet=True) except CommandExecFailed as e: raise GitRepositoryError(str(e)) def get_pristine_tar_commit(self, source, component=None): """ Get the pristine-tar commit for the given source package's latest version. """ def _esc(s): return s.replace('.', '\\.') comp = '-%s' % component if component else '' source_esc = _esc(source.sourcepkg) ver_esc = _esc(source.upstream_version) return self.pristine_tar.get_commit('%s_%s\\.orig%s\\.tar.*' % (source_esc, ver_esc, comp)) def create_upstream_tarball_via_pristine_tar(self, source, output_dir, comp, upstream_signatures, component=None): output = source.upstream_tarball_name(comp.type, component=component) gbp.log.debug("upstream signature state: %s" % upstream_signatures) commit, found_signature = self.get_pristine_tar_commit( source, component) if not commit and self.has_pristine_tar_branch(): raise GitRepositoryError( "Can not find pristine tar commit for archive '%s'" % output) if not found_signature and upstream_signatures.is_on(): raise GitRepositoryError( "Can not find requested upstream signature for archive '%s' in pristine tar commit." % output) try: signature = False if upstream_signatures.is_off( ) else found_signature self.pristine_tar.checkout(source.name, source.upstream_version, comp.type, output_dir, component=component, quiet=True, signature=signature) except Exception as e: raise GitRepositoryError( "Error creating %s%s: %s" % (output, " with attached signature file" if signature else "", e)) return True def create_upstream_tarball_via_git_archive(self, source, output_dir, treeish, comp, with_submodules, component=None): """ Create a compressed orig tarball in output_dir using git archive @param source: debian source package @type source: L{DebianSource} @param output_dir: output directory @param type: C{str} @param treeish: git treeish @type treeish: C{str} @param comp: compressor @type comp: L{Compressor} @param with_submodules: wether to add submodules @type with_submodules: C{bool} @param component: component to add to tarball name @type component: C{str} Raises GitRepositoryError in case of an error """ submodules = False output = os.path.join( output_dir, source.upstream_tarball_name(comp.type, component=component)) prefix = "%s-%s" % (source.name, source.upstream_version) try: if self.has_submodules() and with_submodules: submodules = True self.update_submodules() self.archive_comp(treeish, output, prefix, comp, submodules=submodules) except Exception as e: raise GitRepositoryError("Error creating %s: %s" % (output, e)) return True def vcs_tag_parent(self, vcs_tag_format, version): """If linking to the upstream VCS get the commit id""" if not vcs_tag_format: return None try: tag = self.version_to_tag(vcs_tag_format, version) return [self.rev_parse("%s^{}" % tag)] except GitRepositoryError: raise GitRepositoryError("Can't find upstream vcs tag at '%s'" % tag)
class DebianGitRepository(GitRepository): """A git repository that holds the source of a Debian package""" version_mangle_re = (r'%\(version' '%(?P<M>[^%])' '%(?P<R>([^%]|\\%))+' '\)s') def __init__(self, path): super(DebianGitRepository, self).__init__(path) self.pristine_tar = DebianPristineTar(self) def tree_drop_dirs(self, tree, dirs): """ Drop the given top level dirs from the given git tree returning a new tree object. """ objs = self.list_tree(tree) new_tree_objs = [] for m, t, s, n in objs: if not (n in dirs and t == 'tree'): new_tree_objs.append((m, t, s, n)) new_tree = self.make_tree(new_tree_objs) return new_tree def tree_get_dir(self, tree, dir): """ Get the SHA1 of directory in a given tree """ toplevel = self.list_tree(tree) for m, t, s, n in toplevel: if n == dir and t == 'tree': return s return None def find_version(self, format, version): """ Check if a certain version is stored in this repo and return the SHA1 of the related commit. That is, an annotated tag is dereferenced to the commit object it points to. For legacy tags don't only check the tag itself but also the commit message, since the former wasn't injective until release 0.5.5. You only need to use this function if you also need to check for legacy tags. @param format: tag pattern @type format: C{str} @param version: debian version number @type version: C{str} @return: sha1 of the commit the tag references to @rtype: C{str} """ tag = self.version_to_tag(format, version) legacy_tag = self._build_legacy_tag(format, version) if self.has_tag(tag): # new tags are injective # dereference to a commit object return self.rev_parse("%s^0" % tag) elif self.has_tag(legacy_tag): out, ret = self._git_getoutput('cat-file', args=['-p', legacy_tag]) if ret: return None for line in out: if line.endswith(" %s\n" % version): # dereference to a commit object return self.rev_parse("%s^0" % legacy_tag) elif line.startswith('---'): # GPG signature start return None return None def debian_version_from_upstream(self, upstream_tag_format, upstream_branch, commit='HEAD', epoch=None, debian_release=True): """ Build the Debian version that a package based on upstream commit I{commit} would carry taking into account a possible epoch. @param upstream_tag_format: the tag format on the upstream branch @type upstream_tag_format: C{str} @param upstream_branch: the upstream branch @type upstream_branch: C{str} @param commit: the commit to search for the latest upstream version @param epoch: an epoch to use @param debian_release: If set to C{False} don't append a Debian release number to the version number @returns: a new debian version @raises GitRepositoryError: if no upstream tag was found """ pattern = upstream_tag_format % dict(version='*') tag = self.find_branch_tag(commit, upstream_branch, pattern=pattern) version = self.tag_to_version(tag, upstream_tag_format) if debian_release: version += "-1" if epoch: version = "%s:%s" % (epoch, version) return version @staticmethod def _build_legacy_tag(format, version): """ Legacy tags (prior to 0.5.5) dropped epochs and didn't honor the '~' >>> DebianGitRepository._build_legacy_tag('upstream/%(version)s', '1:2.0~3') 'upstream/2.0.3' """ if ':' in version: # strip of any epochs version = version.split(':', 1)[1] version = version.replace('~', '.') return format % dict(version=version) @classmethod def version_to_tag(cls, format, version): """Generate a tag from a given format and a version %(version)s provides a clean version that works as a git tag. %(hversion)s provides the same thing, but with '.' replaced with '-'. hversion is useful for upstreams with tagging policies that prohibit . characters. %(version%A%B)s provides %(version)s with string 'A' replaced by 'B'. This way, simple version mangling is possible via substitution. Inside the substition string, '%' needs to be escaped. See the examples below. >>> DebianGitRepository.version_to_tag("debian/%(version)s", "0:0~0") 'debian/0%0_0' >>> DebianGitRepository.version_to_tag("libfoo-%(hversion)s", "1.8.1") 'libfoo-1-8-1' >>> DebianGitRepository.version_to_tag("v%(version%.%_)s", "1.2.3") 'v1_2_3' >>> DebianGitRepository.version_to_tag("%(version%-%\%)s", "0-1.2.3") '0%1.2.3' """ f, v = cls._mangle_version(format, version) return format_str(f, dict(version=cls._sanitize_version(v), hversion=cls._sanitize_version(v).replace('.', '-'))) @classmethod def _mangle_version(cls, format, version): """ Basic version mangling to replce single characters >>> DebianGitRepository._mangle_version("%(version%-%\%)s", "0-1.2.3") ('%(version)s', '0%1.2.3') """ r = re.search(cls.version_mangle_re, format) if r: f = re.sub(cls.version_mangle_re, "%(version)s", format) v = version.replace(r.group('M'), r.group('R').replace('\%', '%')) return f, v else: return format, version @classmethod def _unmangle_format(cls, format): """ Reverse of _mangle_version for format """ r = re.search(cls.version_mangle_re, format) if r: return re.sub(cls.version_mangle_re, "%(version)s", format) else: return format @classmethod def _unmangle_version(cls, format, tag): """ Reverse of _mangle_version for version """ r = re.search(cls.version_mangle_re, format) if r: v = tag.replace(r.group('R').replace('\%', '%'), r.group('M')) return v else: return tag @staticmethod def _sanitize_version(version): """sanitize a version so git accepts it as a tag as descirbed in DEP14 >>> DebianGitRepository._sanitize_version("0.0.0") '0.0.0' >>> DebianGitRepository._sanitize_version("0.0~0") '0.0_0' >>> DebianGitRepository._sanitize_version("0:0.0") '0%0.0' >>> DebianGitRepository._sanitize_version("0%0~0") '0%0_0' >>> DebianGitRepository._sanitize_version("0....0") '0.#.#.#.0' >>> DebianGitRepository._sanitize_version("0.lock") '0.#lock' """ v = re.sub('\.(?=\.|$|lock$)', '.#', version) return v.replace('~', '_').replace(':', '%') @staticmethod def _unsanitize_version(tag): """Reverse _sanitize_version as descirbed in DEP14 >>> DebianGitRepository._unsanitize_version("1%0_bpo3") '1:0~bpo3' >>> DebianGitRepository._unsanitize_version("1%0_bpo3.#.") '1:0~bpo3..' """ return tag.replace('_', '~').replace('%', ':').replace('#', '') @classmethod def tag_to_version(cls, tag, format): """Extract the version from a tag >>> DebianGitRepository.tag_to_version("upstream/1%2_3-4", "upstream/%(version)s") '1:2~3-4' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "foo/%(version)s") '2.3.4' >>> DebianGitRepository.tag_to_version("v1-2-3", "v%(version%.%-)s") '1.2.3' >>> DebianGitRepository.tag_to_version("v1.#.2", "v%(version%.%-)s") '1..2' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "upstream/%(version)s") """ f = cls._unmangle_format(format) version_re = f.replace('%(version)s', '(?P<version>[\w_%+-.#]+)') r = re.match(version_re, tag) if r: v = cls._unsanitize_version(r.group('version')) return cls._unmangle_version(format, v) return None @property def pristine_tar_branch(self): """ The name of the pristine-tar branch, whether it already exists or not. """ return DebianPristineTar.branch def has_pristine_tar_branch(self): """ Whether the repo has a I{pristine-tar} branch. @return: C{True} if the repo has pristine-tar commits already, C{False} otherwise @rtype: C{Bool} """ return True if self.has_branch(self.pristine_tar_branch) else False def create_pristinetar_commits(self, upstream_tree, tarball, component_tarballs): """ Create pristine-tar commits for a package with main tarball tarball and (optionl) component tarballs based on upstream_tree @param tarball: path to main tarball @param component_tarballs: C{list} of C{tuple}s of component name and path to additional tarball @param upstream_tree: the treeish in the git repo to create the commits against """ components = [c for (c, t) in component_tarballs] main_tree = self.tree_drop_dirs(upstream_tree, components) for component, name in component_tarballs: subtree = self.tree_get_dir(upstream_tree, component) if not subtree: raise GitRepositoryError("No tree for '%s' found in '%s' to create pristine tar commit from" % (component, upstream_tree)) gbp.log.debug("Creating pristine tar commit '%s' from '%s'" % (component, subtree)) self.pristine_tar.commit(name, subtree) self.pristine_tar.commit(tarball, main_tree)
class DebianGitRepository(GitRepository): """A git repository that holds the source of a Debian package""" version_mangle_re = (r'%\(version' '%(?P<M>[^%])' '%(?P<R>([^%]|\\%))+' '\)s') def __init__(self, *args, **kwargs): super(DebianGitRepository, self).__init__(*args, **kwargs) self.pristine_tar = DebianPristineTar(self) def tree_drop_dirs(self, tree, dirs): """ Drop the given top level dirs from the given git tree returning a new tree object. """ objs = self.list_tree(tree) new_tree_objs = [] for m, t, s, n in objs: if not (n in dirs and t == 'tree'): new_tree_objs.append((m, t, s, n)) new_tree = self.make_tree(new_tree_objs) return new_tree def tree_get_dir(self, tree, dir): """ Get the SHA1 of directory in a given tree """ toplevel = self.list_tree(tree) for m, t, s, n in toplevel: if n == dir and t == 'tree': return s return None def find_version(self, format, version): """ Check if a certain version is stored in this repo and return the SHA1 of the related commit. That is, an annotated tag is dereferenced to the commit object it points to. For legacy tags don't only check the tag itself but also the commit message, since the former wasn't injective until release 0.5.5. You only need to use this function if you also need to check for legacy tags. @param format: tag pattern @type format: C{str} @param version: debian version number @type version: C{str} @return: sha1 of the commit the tag references to @rtype: C{str} """ tag = self.version_to_tag(format, version) legacy_tag = self._build_legacy_tag(format, version) if self.has_tag(tag): # new tags are injective # dereference to a commit object return self.rev_parse("%s^0" % tag) elif self.has_tag(legacy_tag): out, ret = self._git_getoutput('cat-file', args=['-p', legacy_tag]) if ret: return None for line in out: if line.endswith(" %s\n" % version): # dereference to a commit object return self.rev_parse("%s^0" % legacy_tag) elif line.startswith('---'): # GPG signature start return None return None def debian_version_from_upstream(self, upstream_tag_format, upstream_branch, commit='HEAD', epoch=None, debian_release=True): """ Build the Debian version that a package based on upstream commit I{commit} would carry taking into account a possible epoch. @param upstream_tag_format: the tag format on the upstream branch @type upstream_tag_format: C{str} @param upstream_branch: the upstream branch @type upstream_branch: C{str} @param commit: the commit to search for the latest upstream version @param epoch: an epoch to use @param debian_release: If set to C{False} don't append a Debian release number to the version number @returns: a new debian version @raises GitRepositoryError: if no upstream tag was found """ pattern = upstream_tag_format % dict(version='*') tag = self.find_branch_tag(commit, upstream_branch, pattern=pattern) version = self.tag_to_version(tag, upstream_tag_format) if debian_release: version += "-1" if epoch: version = "%s:%s" % (epoch, version) return version @staticmethod def _build_legacy_tag(format, version): """ Legacy tags (prior to 0.5.5) dropped epochs and didn't honor the '~' >>> DebianGitRepository._build_legacy_tag('upstream/%(version)s', '1:2.0~3') 'upstream/2.0.3' """ if ':' in version: # strip of any epochs version = version.split(':', 1)[1] version = version.replace('~', '.') return format % dict(version=version) @classmethod def version_to_tag(cls, format, version): """Generate a tag from a given format and a version %(version)s provides a clean version that works as a git tag. %(hversion)s provides the same thing, but with '.' replaced with '-'. hversion is useful for upstreams with tagging policies that prohibit . characters. %(version%A%B)s provides %(version)s with string 'A' replaced by 'B'. This way, simple version mangling is possible via substitution. Inside the substition string, '%' needs to be escaped. See the examples below. >>> DebianGitRepository.version_to_tag("debian/%(version)s", "0:0~0") 'debian/0%0_0' >>> DebianGitRepository.version_to_tag("libfoo-%(hversion)s", "1.8.1") 'libfoo-1-8-1' >>> DebianGitRepository.version_to_tag("v%(version%.%_)s", "1.2.3") 'v1_2_3' >>> DebianGitRepository.version_to_tag("%(version%-%\%)s", "0-1.2.3") '0%1.2.3' """ f, v = cls._mangle_version(format, version) return format_str( f, dict(version=cls._sanitize_version(v), hversion=cls._sanitize_version(v).replace('.', '-'))) @classmethod def _mangle_version(cls, format, version): """ Basic version mangling to replce single characters >>> DebianGitRepository._mangle_version("%(version%-%\%)s", "0-1.2.3") ('%(version)s', '0%1.2.3') """ r = re.search(cls.version_mangle_re, format) if r: f = re.sub(cls.version_mangle_re, "%(version)s", format) v = version.replace(r.group('M'), r.group('R').replace('\%', '%')) return f, v else: return format, version @classmethod def _unmangle_format(cls, format): """ Reverse of _mangle_version for format """ r = re.search(cls.version_mangle_re, format) if r: return re.sub(cls.version_mangle_re, "%(version)s", format) else: return format @classmethod def _unmangle_version(cls, format, tag): """ Reverse of _mangle_version for version """ r = re.search(cls.version_mangle_re, format) if r: v = tag.replace(r.group('R').replace('\%', '%'), r.group('M')) return v else: return tag @staticmethod def _sanitize_version(version): """sanitize a version so git accepts it as a tag as descirbed in DEP14 >>> DebianGitRepository._sanitize_version("0.0.0") '0.0.0' >>> DebianGitRepository._sanitize_version("0.0~0") '0.0_0' >>> DebianGitRepository._sanitize_version("0:0.0") '0%0.0' >>> DebianGitRepository._sanitize_version("0%0~0") '0%0_0' >>> DebianGitRepository._sanitize_version("0....0") '0.#.#.#.0' >>> DebianGitRepository._sanitize_version("0.lock") '0.#lock' """ v = re.sub('\.(?=\.|$|lock$)', '.#', version) return v.replace('~', '_').replace(':', '%') @staticmethod def _unsanitize_version(tag): """Reverse _sanitize_version as descirbed in DEP14 >>> DebianGitRepository._unsanitize_version("1%0_bpo3") '1:0~bpo3' >>> DebianGitRepository._unsanitize_version("1%0_bpo3.#.") '1:0~bpo3..' """ return tag.replace('_', '~').replace('%', ':').replace('#', '') @classmethod def tag_to_version(cls, tag, format): """Extract the version from a tag >>> DebianGitRepository.tag_to_version("upstream/1%2_3-4", "upstream/%(version)s") '1:2~3-4' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "foo/%(version)s") '2.3.4' >>> DebianGitRepository.tag_to_version("v1-2-3", "v%(version%.%-)s") '1.2.3' >>> DebianGitRepository.tag_to_version("v1.#.2", "v%(version%.%-)s") '1..2' >>> DebianGitRepository.tag_to_version("foo/2.3.4", "upstream/%(version)s") """ f = cls._unmangle_format(format) version_re = f.replace('%(version)s', '(?P<version>[\w_%+-.#]+)') r = re.match(version_re, tag) if r: v = cls._unsanitize_version(r.group('version')) return cls._unmangle_version(format, v) return None @property def pristine_tar_branch(self): """ The name of the pristine-tar branch, whether it already exists or not. """ return DebianPristineTar.branch def has_pristine_tar_branch(self): """ Whether the repo has a I{pristine-tar} branch. @return: C{True} if the repo has pristine-tar commits already, C{False} otherwise @rtype: C{Bool} """ return True if self.has_branch(self.pristine_tar_branch) else False def create_pristinetar_commits(self, upstream_tree, tarball, component_tarballs): """ Create pristine-tar commits for a package with main tarball tarball and (optionl) component tarballs based on upstream_tree @param tarball: path to main tarball @param component_tarballs: C{list} of C{tuple}s of component name and path to additional tarball @param upstream_tree: the treeish in the git repo to create the commits against """ components = [c for (c, t) in component_tarballs] main_tree = self.tree_drop_dirs(upstream_tree, components) for component, name in component_tarballs: subtree = self.tree_get_dir(upstream_tree, component) if not subtree: raise GitRepositoryError( "No tree for '%s' found in '%s' to create pristine tar commit from" % (component, upstream_tree)) gbp.log.debug("Creating pristine tar commit '%s' from '%s'" % (component, subtree)) self.pristine_tar.commit(name, subtree) self.pristine_tar.commit(tarball, main_tree)