def test_directory(self):
"""Upstream source is a directory"""
source = UpstreamSource(self.upstream_dir)
self.assertEqual(source.is_orig(), False)
self.assertEqual(source.path, self.upstream_dir)
self.assertEqual(source.unpacked, self.upstream_dir)
self.assertEqual(source.guess_version(), ('test', '1.0'))
def test_unpack(self):
source = UpstreamSource(self.zipfile)
self.assertEqual(source.is_orig(), False)
self.assertEqual(source.is_dir(), False)
self.assertEqual(source.unpacked, None)
source.unpack(self.tmpdir)
self.assertNotEqual(source.unpacked, None)
def test_pack_mangle_prefix(self):
"""Check if mangling prefix works"""
source = UpstreamSource(os.path.abspath("gbp/"))
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = source.pack(target, newprefix="foobar")
self._check_tar(repacked, ["foobar/errors.py", "foobar/__init__.py"])
repacked2 = source.pack(target, newprefix="")
self._check_tar(repacked2, ["./errors.py", "./__init__.py"])
def test_pack_tar(self):
"""Check if packing tar archives works"""
source = UpstreamSource(os.path.abspath("gbp/"))
target = os.path.join(self.tmpdir,
"gbp_0.1.tar.bz2")
repacked = source.pack(target)
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_dir(), False)
self._check_tar(repacked, ["gbp/errors.py", "gbp/__init__.py"])
class TestTar(unittest.TestCase):
"""Test if packing tar archives works"""
def _check_tar(self, us, positive=[], negative=[]):
t = tarfile.open(name=us.path, mode="r:bz2")
for f in positive:
i = t.getmember(f)
self.assertEqual(type(i), tarfile.TarInfo)
for f in negative:
try:
t.getmember(f)
self.fail("Found %s in archive" % f)
except KeyError:
pass
t.close()
def setUp(self):
self.tmpdir = context.new_tmpdir(__name__)
self.source = UpstreamSource(os.path.join(context.projectdir, "gbp"))
def tearDown(self):
context.teardown()
def test_pack_tar(self):
"""Check if packing tar archives works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target)
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_tarball(), True)
self.assertEqual(repacked.is_dir(), False)
self.assertEqual(repacked.guess_version(), ('gbp', '0.1'))
self.assertEqual(repacked.archive_fmt, 'tar')
self.assertEqual(repacked.compression, 'bzip2')
self.assertEqual(repacked.prefix, 'gbp')
self._check_tar(repacked, ["gbp/errors.py", "gbp/__init__.py"])
def test_pack_filtered(self):
"""Check if filtering out files works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target, ["__init__.py"])
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_tarball(), True)
self.assertEqual(repacked.is_dir(), False)
self._check_tar(repacked, ["gbp/errors.py"], ["gbp/__init__.py"])
def test_pack_mangle_prefix(self):
"""Check if mangling prefix works"""
source = UpstreamSource(os.path.abspath("gbp/"))
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = source.pack(target, newprefix="foobar")
self._check_tar(repacked, ["foobar/errors.py", "foobar/__init__.py"])
repacked2 = source.pack(target, newprefix="")
self._check_tar(repacked2, ["./errors.py", "./__init__.py"])
def extract_orig(orig_tarball, dest_dir):
"""extract orig tarball to export dir before exporting from git"""
gbp.log.info("Extracting %s to '%s'" % (os.path.basename(orig_tarball), dest_dir))
move_old_export(dest_dir)
upstream = UpstreamSource(orig_tarball)
upstream.unpack(dest_dir)
# Check if tarball extracts into a single folder or not:
if upstream.unpacked != dest_dir:
# If it extracts a single folder, move its contents to dest_dir:
gbp.log.debug("Moving %s to %s" % (upstream.unpacked, dest_dir))
tmpdir = dest_dir + '.new'
os.rename(upstream.unpacked, tmpdir)
os.rmdir(dest_dir)
os.rename(tmpdir, dest_dir)
def test_dir(self):
"""Basic test for unpacked sources, no filtering etc"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='dir_basic_')
source = UpstreamSource(self._origs['dir'])
orig, prist = prepare_sources(source, 'test', '1.0', None, None, False,
None, tmpdir)
self.assertEqual(ls_dir(self._origs['dir']), ls_dir(orig))
self.assertEqual(prist, '')
def extract_orig(orig_tarball, dest_dir):
"""extract orig tarball to export dir before exporting from git"""
gbp.log.info("Extracting %s to '%s'" %
(os.path.basename(orig_tarball), dest_dir))
move_old_export(dest_dir)
upstream = UpstreamSource(orig_tarball)
upstream.unpack(dest_dir)
# Check if tarball extracts into a single folder or not:
if upstream.unpacked != dest_dir:
# If it extracts a single folder, move its contents to dest_dir:
gbp.log.debug("Moving %s to %s" % (upstream.unpacked, dest_dir))
tmpdir = dest_dir + '.new'
os.rename(upstream.unpacked, tmpdir)
os.rmdir(dest_dir)
os.rename(tmpdir, dest_dir)
def test_tar_pristine_prefix(self):
"""Test tarball import with prefix mangling"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='tar_prefix_')
source = UpstreamSource(self._origs['tar'])
_orig, prist = prepare_sources(source, 'test', '1.0', 'test.tgz', None,
False, 'np', tmpdir)
src_ls = ls_tar(self._origs['tar'])
prist_ref = set([fname.replace('test-1.0', 'np') for fname in src_ls])
self.assertEqual(prist_ref, ls_tar(prist))
def test_unpack(self):
source = UpstreamSource(self.zipfile)
self.assertEqual(source.is_orig(), False)
self.assertEqual(source.is_dir(), False)
self.assertEqual(source.unpacked, None)
self.assertEqual(source.guess_version(), ('gbp', '0.1'))
source.unpack(str(self.tmpdir))
self.assertNotEqual(source.unpacked, None)
def test_unpack(self):
source = UpstreamSource(self.zipfile)
self.assertEqual(source.is_orig(), False)
self.assertEqual(source.is_tarball(), False)
self.assertEqual(source.is_dir(), False)
self.assertEqual(source.unpacked, None)
self.assertEqual(source.guess_version(), ('gbp', '0.1'))
self.assertEqual(source.archive_fmt, 'zip')
self.assertEqual(source.compression, None)
self.assertEqual(source.prefix, 'gbp')
source.unpack(str(self.tmpdir))
self.assertNotEqual(source.unpacked, None)
def test_dir_filter(self):
"""Test filtering of unpacked sources"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='dir_filter_')
source = UpstreamSource(self._origs['dir'])
orig, prist = prepare_sources(source, 'test', '1.0', None, ['pkg'],
False, None, tmpdir)
orig_filt_ref = set([
fname for fname in ls_dir(self._origs['dir'])
if not fname.startswith('pkg')
])
self.assertEqual(orig_filt_ref, ls_dir(orig))
self.assertEqual(prist, '')
def test_unpack(self):
source = UpstreamSource(self.zipfile)
self.assertEqual(source.is_orig(), False)
self.assertEqual(source.is_dir(), False)
self.assertEqual(source.unpacked, None)
source.unpack(str(self.tmpdir))
self.assertNotEqual(source.unpacked, None)
class TestTar(unittest.TestCase):
"""Test if packing tar archives works"""
def _check_tar(self, us, positive=[], negative=[]):
t = tarfile.open(name=us.path, mode="r:bz2")
for f in positive:
i = t.getmember(f)
self.assertEqual(type(i), tarfile.TarInfo)
for f in negative:
try:
t.getmember(f)
self.fail("Found %s in archive" % f)
except KeyError:
pass
t.close()
def setUp(self):
self.tmpdir = context.new_tmpdir(__name__)
self.source = UpstreamSource(os.path.join(context.projectdir, "gbp"))
def tearDown(self):
context.teardown()
def test_pack_tar(self):
"""Check if packing tar archives works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target)
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_dir(), False)
self.assertEqual(repacked.guess_version(), ('gbp', '0.1'))
self._check_tar(repacked, ["gbp/errors.py", "gbp/__init__.py"])
def test_pack_filtered(self):
"""Check if filtering out files works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target, ["__init__.py"])
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_dir(), False)
self._check_tar(repacked, ["gbp/errors.py"],
["gbp/__init__.py"])
def test_tar(self):
"""Basic test for tarball sources, with pristine-tar"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='tar_basic_')
source = UpstreamSource(self._origs['tar'])
orig, prist = prepare_sources(source, 'test', '1.0', 'test.tgz', None,
False, 'test-1.0', tmpdir)
src_ls = ls_tar(self._origs['tar'])
orig_ref = set([
fname.replace('test-1.0/', '') for fname in src_ls
if fname != 'test-1.0'
])
self.assertEqual(orig_ref, ls_dir(orig))
self.assertEqual(src_ls, ls_tar(prist))
def test_dir_pristine_filter(self):
"""Test filtering pristine-tar and mangling prefix"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='dir_filter3_')
source = UpstreamSource(self._origs['dir'])
orig, prist = prepare_sources(source, 'test', '1.0', 'test.tar.gz',
['pkg'], True, 'newpref', tmpdir)
src_ls = ls_dir(self._origs['dir'])
orig_filt_ref = set(
[fname for fname in src_ls if not fname.startswith('pkg')])
prist_ref = set(['newpref/%s' % fname
for fname in orig_filt_ref] + ['newpref'])
self.assertEqual(orig_filt_ref, ls_dir(orig))
self.assertEqual(prist_ref, ls_tar(prist))
def test_dir_pristine_nofilter(self):
"""Test filtering of unpacked sources, not filtering pristine-tar"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='dir_filter2_')
source = UpstreamSource(self._origs['dir'])
orig, prist = prepare_sources(source, 'test', '1.0', 'test.tar.gz',
['pkg'], False, None, tmpdir)
src_ls = ls_dir(self._origs['dir'])
orig_filt_ref = set(
[fname for fname in src_ls if not fname.startswith('pkg')])
prist_ref = set(['test-1.0/%s' % fname
for fname in src_ls] + ['test-1.0'])
self.assertEqual(orig_filt_ref, ls_dir(orig))
self.assertEqual(prist_ref, ls_tar(prist))
class TestTar(unittest.TestCase):
"""Test if packing tar archives works"""
def _check_tar(self, us, positive=[], negative=[]):
t = tarfile.open(name=us.path, mode="r:bz2")
for f in positive:
i = t.getmember(f)
self.assertEqual(type(i), tarfile.TarInfo)
for f in negative:
try:
t.getmember(f)
self.fail("Found %s in archive" % f)
except KeyError:
pass
t.close()
def setUp(self):
self.tmpdir = context.new_tmpdir(__name__)
self.source = UpstreamSource(os.path.join(context.projectdir, "gbp"))
def tearDown(self):
context.teardown()
def test_pack_tar(self):
"""Check if packing tar archives works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target)
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_dir(), False)
self._check_tar(repacked, ["gbp/errors.py", "gbp/__init__.py"])
def test_pack_filtered(self):
"""Check if filtering out files works"""
target = self.tmpdir.join("gbp_0.1.tar.bz2")
repacked = self.source.pack(target, ["__init__.py"])
self.assertEqual(repacked.is_orig(), True)
self.assertEqual(repacked.is_dir(), False)
self._check_tar(repacked, ["gbp/errors.py"], ["gbp/__init__.py"])
def test_tar_filter_pristine_prefix(self):
"""Filter tarball, pristine-tar prefix mangling but not filter"""
tmpdir = tempfile.mkdtemp(dir=self._tmpdir, prefix='tar_filter_')
source = UpstreamSource(self._origs['tar'])
orig, prist = prepare_sources(source, 'test', '1.0', 'test.tgz',
['pkg'], False, 'newp', tmpdir)
src_ls = ls_tar(self._origs['tar'])
orig_ref = set([
fname.replace('test-1.0/', '') for fname in src_ls
if fname != 'test-1.0' and not fname.startswith('test-1.0/pkg')
])
prist_ref = set(
[fname.replace('test-1.0', 'newp') for fname in src_ls])
self.assertEqual(orig_ref, ls_dir(orig))
self.assertEqual(prist_ref, ls_tar(prist))
def extract_orig(orig_tarball, dest_dir):
"""extract orig tarball to export dir before exporting from git"""
gbp.log.info("Extracting %s to '%s'" % (os.path.basename(orig_tarball), dest_dir))
move_old_export(dest_dir)
upstream = UpstreamSource(orig_tarball)
upstream.unpack(dest_dir)
# Check if tarball extracts into a single folder or not:
if upstream.unpacked != dest_dir:
# If it extracts a single folder, move its contents to dest_dir:
gbp.log.debug("Moving %s to %s" % (upstream.unpacked, dest_dir))
tmpdir = dest_dir + '.new'
os.rename(upstream.unpacked, tmpdir)
os.rmdir(dest_dir)
os.rename(tmpdir, dest_dir)
src_dir = os.path.dirname(orig_tarball)
for component, filename in du.orig_components(orig_tarball, os.listdir(src_dir)).iteritems():
additional_component = UpstreamSource(filename)
additional_component.unpack(dest_dir, strip_toplevel=False)
def main(argv):
dirs = dict(top=os.path.abspath(os.curdir))
needs_repo = False
ret = 0
skipped = False
parents = None
options, args = parse_args(argv)
try:
if len(args) != 1:
gbp.log.err("Need to give exactly one package to import. Try --help.")
raise GbpError
else:
pkg = args[0]
if options.download:
dsc = download_source(pkg,
dirs=dirs,
unauth=options.allow_unauthenticated)
else:
dsc = pkg
src = DscFile.parse(dsc)
if src.pkgformat not in [ '1.0', '3.0' ]:
raise GbpError("Importing %s source format not yet supported." % src.pkgformat)
if options.verbose:
print_dsc(src)
try:
repo = DebianGitRepository('.')
is_empty = repo.is_empty()
(clean, out) = repo.is_clean()
if not clean and not is_empty:
gbp.log.err("Repository has uncommitted changes, commit these first: ")
raise GbpError(out)
except GitRepositoryError:
# no repo found, create one
needs_repo = True
is_empty = True
if needs_repo:
gbp.log.info("No git repository found, creating one.")
repo = DebianGitRepository.create(src.pkg)
os.chdir(repo.path)
if repo.bare:
set_bare_repo_options(options)
if repo.find_version(options.debian_tag, src.version):
gbp.log.warn("Version %s already imported." % src.version)
if options.allow_same_version:
gbp.log.info("Moving tag of version '%s' since import forced" % src.version)
move_tag_stamp(repo, options.debian_tag, src.version)
else:
raise SkipImport
dirs['tmp'] = os.path.abspath(tempfile.mkdtemp(dir='..'))
upstream = UpstreamSource(src.tgz)
upstream.unpack(dirs['tmp'], options.filters)
format = [(options.upstream_tag, "Upstream"), (options.debian_tag, "Debian")][src.native]
tag = repo.version_to_tag(format[0], src.upstream_version)
msg = "%s version %s" % (format[1], src.upstream_version)
parents = []
if not repo.find_version(format[0], src.upstream_version):
gbp.log.info("Tag %s not found, importing %s tarball" % (tag, format[1]))
if is_empty:
branch = None
else:
branch = [options.upstream_branch,
options.debian_branch][src.native]
if not repo.has_branch(branch):
if options.create_missing_branches:
gbp.log.info("Creating missing branch '%s'" % branch)
repo.create_branch(branch)
else:
gbp.log.err(no_upstream_branch_msg % branch +
"\nAlso check the --create-missing-branches option.")
raise GbpError
if src.native:
author = get_author_from_changelog(upstream.unpacked)
committer = get_committer_from_author(author, options)
else:
author = committer = {}
commit = repo.commit_dir(upstream.unpacked,
"Imported %s" % msg,
branch,
author=author,
committer=committer)
parents.append(( tag, commit ))
if not (src.native and options.skip_debian_tag):
repo.create_tag(name=tag,
msg=msg,
commit=commit,
sign=options.sign_tags,
keyid=options.keyid)
if not src.native:
if is_empty:
repo.create_branch(options.upstream_branch, commit)
if options.pristine_tar:
repo.pristine_tar.commit(src.tgz, options.upstream_branch)
if is_empty and not repo.has_branch(options.debian_branch):
repo.create_branch(options.debian_branch, commit)
if not src.native and src.extra_tgz:
for tgz in src.extra_tgz:
tmp = os.path.abspath(tempfile.mkdtemp(dir='..'))
try:
extra = UpstreamSource(tgz)
extra.unpack(tmp, options.filters, False)
_, _, component = extra.guess_version()
tagcomponent = '-' + component
tag = repo.version_to_tag(format[0], src.upstream_version, tagcomponent)
if not repo.find_version(format[0], src.upstream_version, tagcomponent):
gbp.log.info("Tag %s not found, importing %s tarball" % (tag, format[1]))
upstream_branch = options.upstream_branch + '-' + component
if is_empty:
branch = None
else:
branch = upstream_branch
if not repo.has_branch(branch):
if options.create_missing_branches:
gbp.log.info("Creating missing branch '%s'" % branch)
repo.create_branch(branch)
else:
gbp.log.err(no_upstream_branch_msg % branch +
"\nAlso check the --create-missing-branches option.")
raise GbpError
commit = repo.commit_dir(extra.unpacked,
"Imported %s" % msg,
branch,
author)
parents.append(( tag, commit ))
repo.create_tag(name=tag,
msg=msg,
commit=commit,
sign=options.sign_tags,
keyid=options.keyid)
if is_empty:
repo.create_branch(upstream_branch, commit)
if options.pristine_tar:
repo.pristine_tar.commit(tgz, upstream_branch)
# Move unpacked source components into base tree
for item in os.listdir(extra.unpacked):
shutil.move(os.path.join(extra.unpacked, item),
os.path.join(upstream.unpacked, item))
finally:
gbpc.RemoveTree(tmp)()
if not src.native:
if src.diff or src.deb_tgz:
apply_debian_patch(repo, upstream.unpacked, src, options, parents)
else:
gbp.log.warn("Didn't find a diff to apply.")
if repo.get_branch() == options.debian_branch or is_empty:
# Update HEAD if we modified the checked out branch
repo.force_head(options.debian_branch, hard=True)
except KeyboardInterrupt:
ret = 1
gbp.log.err("Interrupted. Aborting.")
except gbpc.CommandExecFailed:
ret = 1
except GitRepositoryError as msg:
gbp.log.err("Git command failed: %s" % msg)
ret = 1
except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
ret = 1
except SkipImport:
skipped = True
finally:
os.chdir(dirs['top'])
for d in [ 'tmp', 'download' ]:
if dirs.has_key(d):
gbpc.RemoveTree(dirs[d])()
if not ret and not skipped:
gbp.log.info("Version '%s' imported under '%s'" % (src.version, src.pkg))
return ret
def setUp(self):
self.tmpdir = context.new_tmpdir(__name__)
self.source = UpstreamSource(os.path.join(context.projectdir, "gbp"))
def setUp(self):
self.tmpdir = context.new_tmpdir(__name__)
self.source = UpstreamSource(os.path.join(context.projectdir, "gbp"))
class DscFile(object):
"""Keeps all needed data read from a dscfile"""
compressions = r"(%s)" % '|'.join(UpstreamSource.known_compressions())
pkg_re = re.compile(r'Source:\s+(?P<pkg>.+)\s*')
version_re = re.compile(r'Version:\s((?P<epoch>\d+)\:)?'
'(?P<version>[%s]+)\s*$' %
DebianPkgPolicy.debianversion_chars)
tar_re = re.compile(r'^\s\w+\s\d+\s+(?P<tar>[^_]+_[^_]+'
'(\.orig)?\.tar\.%s)' % compressions)
diff_re = re.compile(r'^\s\w+\s\d+\s+(?P<diff>[^_]+_[^_]+'
'\.diff.(gz|bz2))')
deb_tgz_re = re.compile(r'^\s\w+\s\d+\s+(?P<deb_tgz>[^_]+_[^_]+'
'\.debian.tar.%s)' % compressions)
format_re = re.compile(r'Format:\s+(?P<format>[0-9.]+)\s*')
def __init__(self, dscfile):
self.pkg = ""
self.tgz = ""
self.diff = ""
self.deb_tgz = ""
self.pkgformat = "1.0"
self.debian_version = ""
self.upstream_version = ""
self.native = False
self.dscfile = os.path.abspath(dscfile)
f = open(self.dscfile)
fromdir = os.path.dirname(os.path.abspath(dscfile))
for line in f:
m = self.version_re.match(line)
if m and not self.upstream_version:
if '-' in m.group('version'):
self.debian_version = m.group('version').split("-")[-1]
self.upstream_version = "-".join(
m.group('version').split("-")[0:-1])
self.native = False
else:
self.native = True # Debian native package
self.upstream_version = m.group('version')
if m.group('epoch'):
self.epoch = m.group('epoch')
else:
self.epoch = ""
continue
m = self.pkg_re.match(line)
if m:
self.pkg = m.group('pkg')
continue
m = self.deb_tgz_re.match(line)
if m:
self.deb_tgz = os.path.join(fromdir, m.group('deb_tgz'))
continue
m = self.tar_re.match(line)
if m:
self.tgz = os.path.join(fromdir, m.group('tar'))
continue
m = self.diff_re.match(line)
if m:
self.diff = os.path.join(fromdir, m.group('diff'))
continue
m = self.format_re.match(line)
if m:
self.pkgformat = m.group('format')
continue
f.close()
if not self.pkg:
raise GbpError("Cannot parse package name from '%s'" %
self.dscfile)
elif not self.tgz:
raise GbpError("Cannot parse archive name from '%s'" %
self.dscfile)
if not self.upstream_version:
raise GbpError("Cannot parse version number from '%s'" %
self.dscfile)
if not self.native and not self.debian_version:
raise GbpError("Cannot parse Debian version number from '%s'" %
self.dscfile)
def _get_version(self):
version = ["", self.epoch + ":"][len(self.epoch) > 0]
if self.native:
version += self.upstream_version
else:
version += "%s-%s" % (self.upstream_version, self.debian_version)
return version
version = property(_get_version)
def __str__(self):
return "<%s object %s>" % (self.__class__.__name__, self.dscfile)
@classmethod
def parse(cls, filename):
try:
dsc = cls(filename)
except IOError as err:
raise GbpError("Error reading dsc file: %s" % err)
return dsc
def main(argv):
dirs = dict(top=os.path.abspath(os.curdir))
needs_repo = False
ret = 0
skipped = False
parents = None
options, args = parse_args(argv)
if not options:
return 1
try:
if len(args) != 1:
gbp.log.err(
"Need to give exactly one package to import. Try --help.")
raise GbpError
else:
pkg = args[0]
if options.download:
dsc = download_source(pkg,
dirs=dirs,
unauth=options.allow_unauthenticated)
else:
dsc = pkg
src = DscFile.parse(dsc)
if src.pkgformat not in ['1.0', '3.0']:
raise GbpError(
"Importing %s source format not yet supported." %
src.pkgformat)
if options.verbose:
print_dsc(src)
try:
repo = DebianGitRepository('.')
is_empty = repo.is_empty()
(clean, out) = repo.is_clean()
if not clean and not is_empty:
gbp.log.err(
"Repository has uncommitted changes, commit these first: "
)
raise GbpError(out)
except GitRepositoryError:
# no repo found, create one
needs_repo = True
is_empty = True
if needs_repo:
gbp.log.info("No git repository found, creating one.")
repo = DebianGitRepository.create(src.pkg)
os.chdir(repo.path)
if repo.bare:
set_bare_repo_options(options)
dirs['tmp'] = os.path.abspath(tempfile.mkdtemp(dir='..'))
upstream = UpstreamSource(src.tgz)
upstream.unpack(dirs['tmp'], options.filters)
format = [(options.upstream_tag, "Upstream"),
(options.debian_tag, "Debian")][src.native]
tag = repo.version_to_tag(format[0], src.upstream_version)
msg = "%s version %s" % (format[1], src.upstream_version)
if repo.find_version(options.debian_tag, src.version):
gbp.log.warn("Version %s already imported." % src.version)
if options.allow_same_version:
gbp.log.info(
"Moving tag of version '%s' since import forced" %
src.version)
move_tag_stamp(repo, options.debian_tag, src.version)
else:
raise SkipImport
if not repo.find_version(format[0], src.upstream_version):
gbp.log.info("Tag %s not found, importing %s tarball" %
(tag, format[1]))
if is_empty:
branch = None
else:
branch = [options.upstream_branch,
options.debian_branch][src.native]
if not repo.has_branch(branch):
if options.create_missing_branches:
gbp.log.info("Creating missing branch '%s'" %
branch)
repo.create_branch(branch)
else:
gbp.log.err(
no_upstream_branch_msg % branch +
"\nAlso check the --create-missing-branches option."
)
raise GbpError
if src.native:
author = get_author_from_changelog(upstream.unpacked)
committer = get_committer_from_author(author, options)
else:
author = committer = {}
commit = repo.commit_dir(upstream.unpacked,
"Imported %s" % msg,
branch,
author=author,
committer=committer)
if not (src.native and options.skip_debian_tag):
repo.create_tag(name=tag,
msg=msg,
commit=commit,
sign=options.sign_tags,
keyid=options.keyid)
if not src.native:
if is_empty:
repo.create_branch(options.upstream_branch, commit)
if options.pristine_tar:
repo.pristine_tar.commit(src.tgz,
options.upstream_branch)
if (not repo.has_branch(options.debian_branch)
and (is_empty or options.create_missing_branches)):
repo.create_branch(options.debian_branch, commit)
if not src.native:
if src.diff or src.deb_tgz:
apply_debian_patch(repo, upstream.unpacked, src, options,
tag)
else:
gbp.log.warn("Didn't find a diff to apply.")
if repo.get_branch() == options.debian_branch or is_empty:
# Update HEAD if we modified the checked out branch
repo.force_head(options.debian_branch, hard=True)
except KeyboardInterrupt:
ret = 1
gbp.log.err("Interrupted. Aborting.")
except gbpc.CommandExecFailed:
ret = 1
except GitRepositoryError as msg:
gbp.log.err("Git command failed: %s" % msg)
ret = 1
except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
ret = 1
except SkipImport:
skipped = True
finally:
os.chdir(dirs['top'])
for d in ['tmp', 'download']:
if dirs.has_key(d):
gbpc.RemoveTree(dirs[d])()
if not ret and not skipped:
gbp.log.info("Version '%s' imported under '%s'" %
(src.version, src.pkg))
return ret
