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)
def __init__(self, path):
super(DebianGitRepository, self).__init__(path)
self.pristine_tar = DebianPristineTar(self)
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)
def __init__(self, *args, **kwargs):
super(DebianGitRepository, self).__init__(*args, **kwargs)
self.pristine_tar = DebianPristineTar(self)
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)
