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 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"))
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