def spawn_dch(msg=[], author=None, email=None, newversion=False, version=None,
release=False, distribution=None, dch_options=[]):
"""
Spawn dch
@param author: committers name
@type author: C{str}
@param email: committers email
@type email: C{str}
@param newversion: start a new version
@type newversion: C{bool}
@param version: the verion to use
@type version: C{str}
@param release: finalize changelog for releaze
@type release: C{bool}
@param distribution: distribution to use
@type distribution: C{str}
@param dch_options: options passed verbatim to dch
@type dch_options: C{list}
"""
env = {}
args = ['--no-auto-nmu']
if newversion:
if version:
try:
args.append(version['increment'])
except KeyError:
args.append('--newversion=%s' % version['version'])
else:
args.append('-i')
elif release:
args.extend(["--release", "--no-force-save-on-release"])
msg = None
if author and email:
env = {'DEBFULLNAME': author, 'DEBEMAIL': email}
if distribution:
args.append("--distribution=%s" % distribution)
args.extend(dch_options)
args.append('--')
if msg:
args.append('[[[insert-git-dch-commit-message-here]]]')
else:
args.append('')
dch = Command('dch', args, extra_env=env)
dch.call([])
if msg:
old_cl = open("debian/changelog", "r")
new_cl = open("debian/changelog.bak", "w")
for line in old_cl:
if line == " * [[[insert-git-dch-commit-message-here]]]\n":
print >> new_cl, " * " + msg[0]
for line in msg[1:]:
print >> new_cl, " " + line
else:
print >> new_cl, line,
os.rename("debian/changelog.bak", "debian/changelog")
def test_log_quote_format(self, create_mock):
self.false = Command('/does/{not}/matter')
self.false.capture_stderr = True
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: '/does/{not}/matter' failed: it exited with 1")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, 'we have a problem')
self.assertEqual(self.false.stdout, '')
def apt_showsrc(pkg):
try:
aptsrc = Command("apt-cache", ["showsrc", pkg], capture_stdout=True)
aptsrc(quiet=True)
return aptsrc.stdout
except CommandExecFailed:
return ''
def setUpClass(cls):
"""Initializations only made once per test run"""
super(RpmRepoTestBase, cls).setUpClass()
# Initialize test data repositories
cmd = Command('./manage.py',
cwd=RPM_TEST_DATA_DIR,
capture_stderr=True)
cmd(['import-repo', '-o', cls._tmproot])
cls.orig_repos = {}
for path in glob(cls._tmproot + '/*.repo'):
prj = os.path.basename(path).rsplit('.', 1)[0]
cls.orig_repos[prj] = ComponentTestGitRepository(path)
class TestCommandWrapperFailures(unittest.TestCase, GbpLogTester):
def setUp(self):
self.false = Command('/does/not/matter')
self.log_tester = GbpLogTester()
self.log_tester._capture_log(True)
def tearDown(self):
self.log_tester._capture_log(False)
@patch_popen(stdout='', stderr='', returncode=1)
def test_log_default_error_msg(self, create_mock):
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(
0, "gbp:error: '/does/not/matter' failed: it exited with 1")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, '')
self.assertEqual(self.false.stdout, '')
@patch_popen(stdout='', stderr='we have a problem', returncode=1)
def test_log_use_stderr_for_err_message(self, create_mock):
self.false.capture_stderr = True
self.false.run_error = "Erpel {stderr}"
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: Erpel we have a problem")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, 'we have a problem')
self.assertEqual(self.false.stdout, '')
@patch_popen(stdout='we have a problem', stderr='', returncode=1)
def test_log_use_stdout_for_err_message(self, create_mock):
self.false.capture_stdout = True
self.false.run_error = "Erpel {stdout}"
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: Erpel we have a problem")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, '')
self.assertEqual(self.false.stdout, 'we have a problem')
@patch_popen(returncode=0)
def test_no_log_on_success(self, create_mock):
self.false.__call__()
self.log_tester._check_log_empty()
self.assertEqual(self.false.retcode, 0)
def clean_working_tree(options, repo):
"""
Clean the working tree.
:param options: Program run-time options, as an `optparse.OptionContainer`.
:param repo: The Git repository, as a `DebianGitRepository`.
:raise GbpError: When the working tree has uncommitted changes.
:return: None.
"""
Command(options.cleaner, shell=True)()
if not options.ignore_new:
(ret, out) = repo.is_clean()
if not ret:
gbp.log.err("You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError("Use --git-ignore-new to ignore.")
class TestCommandWrapperFailures(unittest.TestCase, GbpLogTester):
def setUp(self):
self.false = Command('/does/not/matter')
self.log_tester = GbpLogTester()
self.log_tester._capture_log(True)
def tearDown(self):
self.log_tester._capture_log(False)
@patch_popen(stdout='', stderr='', returncode=1)
def test_log_default_error_msg(self, create_mock):
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: '/does/not/matter' failed: it exited with 1")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, '')
self.assertEqual(self.false.stdout, '')
@patch_popen(stdout='', stderr='we have a problem', returncode=1)
def test_log_use_stderr_for_err_message(self, create_mock):
self.false.capture_stderr = True
self.false.run_error = "Erpel {stderr}"
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: Erpel we have a problem")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, 'we have a problem')
self.assertEqual(self.false.stdout, '')
@patch_popen(stdout='we have a problem', stderr='', returncode=1)
def test_log_use_stdout_for_err_message(self, create_mock):
self.false.capture_stdout = True
self.false.run_error = "Erpel {stdout}"
with self.assertRaises(CommandExecFailed):
self.false.__call__()
self.log_tester._check_log(0, "gbp:error: Erpel we have a problem")
self.assertEqual(self.false.retcode, 1)
self.assertEqual(self.false.stderr, '')
self.assertEqual(self.false.stdout, 'we have a problem')
@patch_popen(returncode=0)
def test_no_log_on_success(self, create_mock):
self.false.__call__()
self.log_tester._check_log_empty()
self.assertEqual(self.false.retcode, 0)
def setUp(self):
self.false = Command('/does/not/matter')
self.log_tester = GbpLogTester()
self.log_tester._capture_log(True)
def spawn_dch(msg=[], author=None, email=None, newversion=False, version=None,
release=False, distribution=None, dch_options=[]):
"""
Spawn dch
@param author: committers name
@type author: C{str}
@param email: committers email
@type email: C{str}
@param newversion: start a new version
@type newversion: C{bool}
@param version: the verion to use
@type version: C{str}
@param release: finalize changelog for releaze
@type release: C{bool}
@param distribution: distribution to use
@type distribution: C{str}
@param dch_options: options passed verbatim to dch
@type dch_options: C{list}
"""
env = {}
args = ['--no-auto-nmu']
if newversion:
if version:
try:
args.append(version['increment'])
except KeyError:
args.append('--newversion=%s' % version['version'])
else:
args.append('-i')
elif release:
args.extend(["--release", "--no-force-save-on-release"])
msg = None
if author:
env['DEBFULLNAME'] = author
if email:
env['DEBEMAIL'] = email
if distribution:
args.append("--distribution=%s" % distribution)
args.extend(dch_options)
args.append('--')
if msg:
args.append('[[[insert-git-dch-commit-message-here]]]')
else:
args.append('')
dch = Command('debchange', args, extra_env=env)
dch([], quiet=True)
if msg:
old_cl = open("debian/changelog", "r")
new_cl = open("debian/changelog.bak", "w")
for line in old_cl:
if line == " * [[[insert-git-dch-commit-message-here]]]\n":
print(" * " + msg[0], file=new_cl)
for line in msg[1:]:
print(" " + line, file=new_cl)
else:
print(line, end='', file=new_cl)
os.rename("debian/changelog.bak", "debian/changelog")
def main(argv):
"""Entry point for gbp-buildpackage-rpm"""
retval = 0
prefix = "git-"
spec = None
options, gbp_args, builder_args = parse_args(argv, prefix)
if not options:
return 1
try:
repo = RpmGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
# Determine tree-ish to be exported
try:
tree = get_tree(repo, options.export)
except GbpError as err:
gbp.log.err('Failed to determine export treeish: %s' % err)
return 1
# Re-parse config options with using the per-tree config file(s) from the
# exported tree-ish
options, gbp_args, builder_args = parse_args(argv, prefix, tree)
branch = get_current_branch(repo)
try:
init_tmpdir(options.tmp_dir, prefix='buildpackage-rpm_')
tree = get_tree(repo, options.export)
spec = parse_spec(options, repo, treeish=tree)
Command(options.cleaner, shell=True)()
if not options.ignore_new:
ret, out = repo.is_clean()
if not ret:
gbp.log.err(
"You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError("Use --git-ignore-new to ignore.")
if not options.ignore_new and not options.ignore_branch:
if branch != options.packaging_branch:
gbp.log.err("You are not on branch '%s' but on '%s'" %
(options.packaging_branch, branch))
raise GbpError(
"Use --git-ignore-branch to ignore or "
"--git-packaging-branch to set the branch name.")
# Dump from git to a temporary directory:
packaging_tree = '%s:%s' % (tree, options.packaging_dir)
dump_dir = tempfile.mkdtemp(prefix='packaging_')
gbp.log.debug("Dumping packaging files to '%s'" % dump_dir)
if not dump_tree(repo, dump_dir, packaging_tree, False, False):
raise GbpError
# Re-parse spec from dump dir to get version etc.
spec = rpm.SpecFile(os.path.join(dump_dir, spec.specfile))
if not options.tag_only:
# Setup builder opts
setup_builder(options, builder_args)
if options.use_mock:
setup_mock(options)
# Prepare final export dirs
export_dir = makedir(options.export_dir)
source_dir = makedir(
os.path.join(export_dir, options.export_sourcedir))
spec_dir = makedir(os.path.join(export_dir,
options.export_specdir))
# Move packaging files to final export dir
gbp.log.debug("Exporting packaging files from '%s' to '%s'" %
(dump_dir, export_dir))
for fname in os.listdir(dump_dir):
src = os.path.join(dump_dir, fname)
if fname == spec.specfile:
dst = os.path.join(spec_dir, fname)
else:
dst = os.path.join(source_dir, fname)
try:
shutil.copy2(src, dst)
except IOError as err:
raise GbpError("Error exporting packaging files: %s" % err)
spec.specdir = os.path.abspath(spec_dir)
# Get/build the orig tarball
if is_native(repo, options):
if spec.orig_src and not options.no_create_orig:
# Just build source archive from the exported tree
gbp.log.info(
"Creating (native) source archive %s from '%s'" %
(spec.orig_src['filename'], tree))
if spec.orig_src['compression']:
gbp.log.debug(
"Building source archive with "
"compression '%s -%s'" %
(spec.orig_src['compression'], options.comp_level))
orig_prefix = spec.orig_src['prefix']
if not git_archive(repo, spec, source_dir, tree,
orig_prefix, options.comp_level,
options.with_submodules):
raise GbpError("Cannot create source tarball at '%s'" %
source_dir)
# Non-native packages: create orig tarball from upstream
elif spec.orig_src:
prepare_upstream_tarball(repo, spec, options, source_dir)
# Run postexport hook
if options.postexport:
RunAtCommand(options.postexport,
shell=True,
extra_env={
'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': export_dir
})(dir=export_dir)
# Do actual build
if not options.no_build and not options.tag_only:
if options.prebuild:
RunAtCommand(options.prebuild,
shell=True,
extra_env={
'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': export_dir
})(dir=export_dir)
# Finally build the package:
if options.builder.startswith("rpmbuild"):
builder_args.append(
os.path.join(spec.specdir, spec.specfile))
else:
builder_args.append(spec.specfile)
RunAtCommand(options.builder,
builder_args,
shell=True,
extra_env={'GBP_BUILD_DIR':
export_dir})(dir=export_dir)
if options.postbuild:
changes = os.path.abspath("%s/%s.changes" %
(source_dir, spec.name))
gbp.log.debug("Looking for changes file %s" % changes)
Command(options.postbuild,
shell=True,
extra_env={
'GBP_CHANGES_FILE': changes,
'GBP_BUILD_DIR': export_dir
})()
# Tag (note: tags the exported version)
if options.tag or options.tag_only:
gbp.log.info("Tagging %s" % rpm.compose_version_str(spec.version))
tag = create_packaging_tag(repo, tree, spec.name, spec.version,
options)
vcs_info = get_vcs_info(repo, tag)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Command(options.posttag,
shell=True,
extra_env={
'GBP_TAG': tag,
'GBP_BRANCH': branch,
'GBP_SHA1': sha
})()
else:
vcs_info = get_vcs_info(repo, tree)
except CommandExecFailed:
retval = 1
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpAutoGenerateError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 2
except GbpError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
finally:
drop_index()
del_tmpdir()
if not options.tag_only:
if spec and options.notify:
summary = "Gbp-rpm %s" % ["failed", "successful"][not retval]
message = ("Build of %s %s %s" %
(spec.name, rpm.compose_version_str(
spec.version), ["failed", "succeeded"][not retval]))
if not gbp.notifications.notify(summary, message, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
def main(argv):
retval = 0
current = None
(options, args) = parse_args(argv)
if not options:
return 1
gbp.log.setup(options.color, options.verbose, options.color_scheme)
try:
repo = GitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
branches = set()
try:
current = repo.get_branch()
except GitRepositoryError:
# Not being on any branch is o.k. with --git-ignore-branch
if options.ignore_branch:
current = repo.head
gbp.log.info("Found detached head at '%s'" % current)
else:
raise
for branch in [options.packaging_branch, options.upstream_branch]:
if repo.has_branch(branch):
branches.add(branch)
if repo.has_pristine_tar_branch() and options.pristine_tar:
branches.add(repo.pristine_tar_branch)
if options.all:
current_remote = repo.get_merge_branch(current)
if current_remote:
fetch_remote = current_remote.split('/')[0]
else:
fetch_remote = 'origin'
for branch in repo.get_local_branches():
merge_branch = repo.get_merge_branch(branch)
if merge_branch:
rem, rem_br = merge_branch.split('/', 1)
if rem == fetch_remote and branch == rem_br:
branches.add(branch)
(ret, out) = repo.is_clean()
if not ret:
gbp.log.err("You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError
repo.fetch(depth=options.depth)
repo.fetch(depth=options.depth, tags=True)
for branch in branches:
if not update_branch(branch, repo, options):
retval = 2
if options.redo_pq:
repo.set_branch(options.packaging_branch)
Command("gbp-pq")(["drop"])
Command("gbp-pq")(["import"])
repo.set_branch(current)
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
def main(argv):
"""Entry point for git-buildpackage-bb"""
retval = 0
prefix = "git-"
bbfile = None
dump_dir = None
if not bb:
return 1
options, gbp_args, builder_args = parse_args(argv, prefix)
if not options:
return 1
try:
repo = RpmGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
# Determine tree-ish to be exported
try:
tree = get_tree(repo, options.export)
except GbpError as err:
gbp.log.err('Failed to determine export treeish: %s' % err)
return 1
# Re-parse config options with using the per-tree config file(s) from the
# exported tree-ish
options, gbp_args, builder_args = parse_args(argv, prefix, tree)
branch = get_current_branch(repo)
try:
tinfoil = init_tinfoil(config_only=True)
#bb_cfg_data = bb.data.createCopy(tinfoil.config_data)
except GbpError:
tinfoil = None
# Use naive parsing because repository might only have .bb file
gbp.log.info("Using naive standalone parsing of recipes in package repo.")
bb_cfg_data = None
try:
tree = guess_export_params(repo, options)
Command(options.cleaner, shell=True)()
if not options.ignore_new:
(ret, out) = repo.is_clean(options.ignore_untracked)
if not ret:
gbp.log.err("You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError("Use --git-ignore-new or --git-ignore-untracked "
"to ignore.")
if not options.ignore_new and not options.ignore_branch:
if branch != options.packaging_branch:
gbp.log.err("You are not on branch '%s' but on '%s'" %
(options.packaging_branch, branch))
raise GbpError("Use --git-ignore-branch to ignore or "
"--git-packaging-branch to set the branch name.")
if not options.tag_only:
# Dump/parse meta to export dir
if options.export_dir:
export_dir = os.path.abspath(options.export_dir)
else:
export_dir = guess_export_dir(options, tinfoil, repo, tree)
gbp.log.info("Dumping meta from tree '%s' to '%s'" %
(options.export, export_dir))
bbfile = dump_meta(bb_cfg_data, options, repo, tree,
export_dir)
# Setup builder opts
setup_builder(options, builder_args)
if is_native(repo, options) and bbfile.getVar('SRCREV') == 'HEAD':
# Update SRCREV for native packages that are exported from
# pristine repository
BBFile.set_var_val(bbfile.bb_path, 'SRCREV',
repo.rev_parse(tree))
# TODO: Re-design the handling of native packages. Updating
# SRCREV must probably be more explicit
if options.patch_export:
# Generate patches, if requested
if options.patch_export_rev:
patch_tree = get_tree(repo, options.patch_export_rev)
else:
patch_tree = tree
export_patches(repo, bbfile, patch_tree, options)
# Run postexport hook
if options.postexport:
RunAtCommand(options.postexport, shell=True,
extra_env={'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': export_dir}
)(dir=export_dir)
# Do actual build
if not options.no_build:
if options.prebuild:
RunAtCommand(options.prebuild, shell=True,
extra_env={'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': export_dir}
)(dir=export_dir)
# Unlock cooker so that we are able to run external bitbake
if options.builder == 'bitbake' and tinfoil:
bb.utils.unlockfile(tinfoil.cooker.lock)
# Finally build the package:
bb_path = bbfile.getVar('FILE', True)
builder_args.extend(['-b', bb_path])
RunAtCommand(options.builder, builder_args, shell=True,
extra_env={'GBP_BUILD_DIR': export_dir})()
if options.postbuild:
Command(options.postbuild, shell=True,
extra_env={'GBP_BUILD_DIR': export_dir})()
else:
# Tag-only: we just need to parse the meta
bbfile = parse_bb(bb_cfg_data, options, repo, tree)
# Tag (note: tags the exported version)
if options.tag or options.tag_only:
version = pkg_version(bbfile)
gbp.log.info("Tagging %s" %
RpmPkgPolicy.compose_full_version(version))
commit_info = repo.get_commit_info(tree)
tag = packaging_tag_name(repo, version, commit_info, options)
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
create_packaging_tag(repo, tag, commit=tree, version=version,
options=options)
vcs_info = get_vcs_info(repo, tag)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Command(options.posttag, shell=True,
extra_env={'GBP_TAG': tag,
'GBP_BRANCH': branch,
'GBP_SHA1': sha})()
else:
vcs_info = get_vcs_info(repo, tree)
# TODO: Put VCS information to recipe
if options.bb_vcs_info:
raise GbpError("Injecting VCS info into recipe not yet supported")
except CommandExecFailed:
retval = 1
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpAutoGenerateError as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 2
except GbpError, err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
options, gbp_args, builder_args = parse_args(argv, prefix, tree)
try:
# Create base temporary directory for this run
options.tmp_dir = tempfile.mkdtemp(dir=options.tmp_dir,
prefix='buildpackage-rpm_')
except GbpError, err:
gbp.log.err(err)
return 1
branch = get_current_branch(repo)
try:
tree, relative_spec_path = guess_export_params(repo, options)
Command(options.cleaner, shell=True)()
if not options.ignore_new:
(ret, out) = repo.is_clean(options.ignore_untracked)
if not ret:
gbp.log.err(
"You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError, "Use --git-ignore-new or --git-ignore-untracked to ignore."
if not options.ignore_new and not options.ignore_branch:
if branch != options.packaging_branch:
gbp.log.err("You are not on branch '%s' but on '%s'" %
(options.packaging_branch, branch))
raise GbpError, "Use --git-ignore-branch to ignore or --git-packaging-branch to set the branch name."
# Dump from git to a temporary directory:
def spawn_dch(
msg=[],
author=None,
email=None,
newversion=False,
version=None,
release=False,
distribution=None,
dch_options=[],
):
"""
Spawn dch
@param author: committers name
@type author: C{str}
@param email: committers email
@type email: C{str}
@param newversion: start a new version
@type newversion: C{bool}
@param version: the verion to use
@type version: C{str}
@param release: finalize changelog for releaze
@type release: C{bool}
@param distribution: distribution to use
@type distribution: C{str}
@param dch_options: options passed verbatim to dch
@type dch_options: C{list}
"""
env = {}
args = ["--no-auto-nmu"]
if newversion:
if version:
try:
args.append(version["increment"])
except KeyError:
args.append("--newversion=%s" % version["version"])
else:
args.append("-i")
elif release:
args.extend(["--release", "--no-force-save-on-release"])
msg = None
if author:
env["DEBFULLNAME"] = author
if email:
env["DEBEMAIL"] = email
if distribution:
args.append("--distribution=%s" % distribution)
args.extend(dch_options)
args.append("--")
if msg:
args.append("[[[insert-git-dch-commit-message-here]]]")
else:
args.append("")
dch = Command("debchange", args, extra_env=env)
dch.call([])
if msg:
old_cl = open("debian/changelog", "r")
new_cl = open("debian/changelog.bak", "w")
for line in old_cl:
if line == " * [[[insert-git-dch-commit-message-here]]]\n":
print(" * " + msg[0], file=new_cl)
for line in msg[1:]:
print(" " + line, file=new_cl)
else:
print(line, end="", file=new_cl)
os.rename("debian/changelog.bak", "debian/changelog")
def main(argv):
retval = 0
prefix = "git-"
source = None
branch = None
options, gbp_args, dpkg_args = parse_args(argv, prefix)
if not options:
return 1
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
else:
repo_dir = os.path.abspath(os.path.curdir)
try:
Command(options.cleaner, shell=True)()
if not options.ignore_new:
(ret, out) = repo.is_clean()
if not ret:
gbp.log.err(
"You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError("Use --git-ignore-new to ignore.")
try:
branch = repo.get_branch()
except GitRepositoryError:
# Not being on any branch is o.k. with --git-ignore-branch
if not options.ignore_branch:
raise
if not options.ignore_new and not options.ignore_branch:
if branch != options.debian_branch:
gbp.log.err("You are not on branch '%s' but on '%s'" %
(options.debian_branch, branch))
raise GbpError(
"Use --git-ignore-branch to ignore or --git-debian-branch to set the branch name."
)
tree = write_tree(repo, options)
source = source_vfs(repo, options, tree)
if not options.tag_only:
output_dir = prepare_output_dir(options.export_dir)
tarball_dir = options.tarball_dir or output_dir
# Get/build the upstream tarball if necessary. We delay this in
# case of a postexport hook so the hook gets a chance to modify the
# sources and create different tarballs (#640382)
# We don't delay it in general since we want to fail early if the
# tarball is missing.
if not source.is_native():
if options.postexport:
gbp.log.info(
"Postexport hook set, delaying tarball creation")
else:
prepare_upstream_tarball(repo, source.changelog, options,
tarball_dir, output_dir)
# Export to another build dir if requested:
if options.export_dir:
tmp_dir = os.path.join(output_dir, "%s-tmp" % source.sourcepkg)
export_source(repo, tree, source, options, tmp_dir, output_dir)
# Run postexport hook
if options.postexport:
RunAtCommand(options.postexport,
shell=True,
extra_env={
'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': tmp_dir
})(dir=tmp_dir)
major = (source.changelog.debian_version if source.is_native()
else source.changelog.upstream_version)
export_dir = os.path.join(output_dir,
"%s-%s" % (source.sourcepkg, major))
gbp.log.info("Moving '%s' to '%s'" % (tmp_dir, export_dir))
move_old_export(export_dir)
os.rename(tmp_dir, export_dir)
# Delayed tarball creation in case a postexport hook is used:
if not source.is_native() and options.postexport:
prepare_upstream_tarball(repo, source.changelog, options,
tarball_dir, output_dir)
if options.export_dir:
build_dir = export_dir
else:
build_dir = repo_dir
if options.prebuild:
RunAtCommand(options.prebuild,
shell=True,
extra_env={
'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir
})(dir=build_dir)
setup_pbuilder(options)
# Finally build the package:
RunAtCommand(options.builder,
dpkg_args,
shell=True,
extra_env={'GBP_BUILD_DIR': build_dir})(dir=build_dir)
if options.postbuild:
changes = os.path.abspath(
"%s/../%s_%s_%s.changes" %
(build_dir, source.sourcepkg, source.changelog.noepoch,
changes_file_suffix(dpkg_args)))
gbp.log.debug("Looking for changes file %s" % changes)
Command(options.postbuild,
shell=True,
extra_env={
'GBP_CHANGES_FILE': changes,
'GBP_BUILD_DIR': build_dir
})()
if options.tag or options.tag_only:
gbp.log.info("Tagging %s" % source.changelog.version)
tag = repo.version_to_tag(options.debian_tag,
source.changelog.version)
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
repo.create_tag(name=tag,
msg="%s Debian release %s" %
(source.sourcepkg, source.changelog.version),
sign=options.sign_tags,
keyid=options.keyid)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Command(options.posttag,
shell=True,
extra_env={
'GBP_TAG': tag,
'GBP_BRANCH': branch or '(no branch)',
'GBP_SHA1': sha
})()
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
except DebianSourceError as err:
gbp.log.err(err)
source = None
retval = 1
finally:
drop_index()
if not options.tag_only:
if options.export_dir and options.purge and not retval:
RemoveTree(export_dir)()
if source and not gbp.notifications.notify(source.changelog,
not retval, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
def main(argv):
retval = 0
current = None
rem_repo = None
(options, args) = parse_args(argv)
if not options:
return ExitCodes.parse_error
gbp.log.setup(options.color, options.verbose, options.color_scheme)
if len(args) == 2:
rem_repo = args[1]
gbp.log.info("Fetching from '%s'" % rem_repo)
else:
gbp.log.info("Fetching from default remote for each branch")
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
branches = []
try:
current = repo.get_branch()
except GitRepositoryError:
# Not being on any branch is o.k. with --git-ignore-branch
if options.ignore_branch:
current = repo.head
gbp.log.info("Found detached head at '%s'" % current)
else:
raise
for branch in [options.debian_branch, options.upstream_branch]:
if repo.has_branch(branch):
branches += [branch]
if repo.has_pristine_tar_branch() and options.pristine_tar:
branches += [repo.pristine_tar_branch]
(ret, out) = repo.is_clean()
if not ret:
gbp.log.err("You have uncommitted changes in your source tree:")
gbp.log.err(out)
raise GbpError
repo.fetch(rem_repo, depth=options.depth)
repo.fetch(rem_repo, depth=options.depth, tags=True)
for branch in branches:
if not fast_forward_branch(rem_repo, branch, repo, options):
retval = 2
if options.redo_pq:
repo.set_branch(options.debian_branch)
Command("gbp-pq")(["drop"])
Command("gbp-pq")(["import"])
repo.set_branch(current)
except KeyboardInterrupt:
retval = 1
gbp.log.err("Interrupted. Aborting.")
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if str(err):
gbp.log.err(err)
retval = 1
return retval
def spawn_dch(msg=[], author=None, email=None, newversion=False, version=None,
release=False, distribution=None, dch_options=None):
"""
Spawn dch
@param author: committers name
@type author: C{str}
@param email: committers email
@type email: C{str}
@param newversion: start a new version
@type newversion: C{bool}
@param version: the verion to use
@type version: C{str}
@param release: finalize changelog for releaze
@type release: C{bool}
@param distribution: distribution to use
@type distribution: C{str}
@param dch_options: options passed verbatim to dch
@type dch_options: C{list}
"""
env = {}
args = ['--no-auto-nmu']
if newversion:
if version:
try:
args.append(version['increment'])
except KeyError:
args.append('--newversion=%s' % version['version'])
else:
args.append('-i')
elif release:
args.extend(["--release", "--no-force-save-on-release"])
msg = None
if author:
env['DEBFULLNAME'] = author.encode('utf-8')
if email:
env['DEBEMAIL'] = email.encode('utf-8')
if distribution:
args.append("--distribution=%s" % distribution)
args.extend(dch_options or [])
if '--create' in args:
env['EDITOR'] = env['VISUAL'] = '/bin/true'
args.append('--')
if msg:
args.append('[[[insert-git-dch-commit-message-here]]]')
else:
args.append('')
dch = Command('debchange', args, extra_env=env, capture_stderr=True)
dch.run_error = Command._f("Dch failed: {stderr_or_reason}")
dch([], quiet=True)
if msg:
old_cl = open("debian/changelog", "r", encoding='utf-8')
new_cl = open("debian/changelog.bak", "w", encoding='utf-8')
for line in old_cl:
if line == " * [[[insert-git-dch-commit-message-here]]]\n":
print(" * " + msg[0], file=new_cl)
for line in msg[1:]:
print(" " + line, file=new_cl)
else:
print(line, end='', file=new_cl)
os.rename("debian/changelog.bak", "debian/changelog")
