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
prefix = "git-"
source = None
branch = None
hook_env = {}
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.")
head = repo.head
tree = write_tree(repo, options)
source = source_vfs(repo, options, tree)
check_tag(options, repo, source)
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)
build_env, hook_env = setup_pbuilder(options, repo, source.is_native())
# 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:
Hook('Postexport', options.postexport,
extra_env=md(hook_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:
Hook('Prebuild', options.prebuild,
extra_env=md(hook_env,
{'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir})
)(dir=build_dir)
# Finally build the package:
RunAtCommand(options.builder, dpkg_args, shell=True,
extra_env=md(build_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)
Hook('Postbuild', options.postbuild,
extra_env=md(hook_env,
{'GBP_CHANGES_FILE': changes,
'GBP_BUILD_DIR': build_dir})
)()
if options.tag or options.tag_only:
tag = repo.version_to_tag(options.debian_tag, source.changelog.version)
gbp.log.info("Tagging %s as %s" % (source.changelog.version, tag))
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
tag_msg = format_str(options.debian_tag_msg,
dict(pkg=source.sourcepkg,
version=source.changelog.version))
repo.create_tag(name=tag,
msg=tag_msg,
sign=options.sign_tags,
commit=head,
keyid=options.keyid)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Hook('Posttag', options.posttag,
extra_env=md(hook_env,
{'GBP_TAG': tag,
'GBP_BRANCH': branch or '(no branch)',
'GBP_SHA1': sha})
)()
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if str(err):
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:
summary, msg = gbp.notifications.build_msg(source.changelog,
not retval)
if not gbp.notifications.notify(summary, msg, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
def main(argv):
retval = 0
prefix = "git-"
cp = 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)
cp = fetch_changelog(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 cp.is_native():
if options.postexport:
gbp.log.info("Postexport hook set, delaying tarball creation")
else:
prepare_upstream_tarball(repo, cp, 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" % cp['Source'])
export_source(repo, tree, cp, 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 = (cp.debian_version if cp.is_native() else cp.upstream_version)
export_dir = os.path.join(output_dir, "%s-%s" % (cp['Source'], 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 cp.is_native() and options.postexport:
prepare_upstream_tarball(repo, cp, 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:
arch = os.getenv('ARCH', None) or du.get_arch()
changes = os.path.abspath("%s/../%s_%s_%s.changes" %
(build_dir, cp['Source'], cp.noepoch, arch))
gbp.log.debug("Looking for changes file %s" % changes)
if not os.path.exists(changes):
changes = os.path.abspath("%s/../%s_%s_source.changes" %
(build_dir, cp['Source'], cp.noepoch))
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" % cp.version)
tag = repo.version_to_tag(options.debian_tag, cp.version)
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
repo.create_tag(name=tag, msg="Debian release %s" % cp.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
finally:
drop_index()
if not options.tag_only:
if options.export_dir and options.purge and not retval:
RemoveTree(export_dir)()
if cp and not gbp.notifications.notify(cp, not retval, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
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
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.")
head = repo.head
tree = write_tree(repo, options)
source = source_vfs(repo, options, tree)
check_tag(options, repo, source)
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.
is_native = source.is_native()
gbp.log.debug('Is the package Debian-native? %s' % (is_native,))
if not is_native:
if options.postexport:
gbp.log.info("Postexport hook set, delaying tarball creation")
else:
gbp.log.info('Preparing upstream tarball (not delayed)...')
prepare_upstream_tarball(repo, source.changelog, options, tarball_dir,
output_dir)
# Export to another build dir if requested:
if options.export_dir:
gbp.log.debug('export_dir is set...')
sourcepkg = source.sourcepkg
assert sourcepkg is not None
gbp.log.debug('sourcepkg = %s' % (sourcepkg,))
tmp_dir = os.path.join(output_dir, "%s-tmp" % sourcepkg)
export_source(repo, tree, source, options, tmp_dir, output_dir)
# XXX: @KK:
gbp.log.debug('Changing source to use tmp_dir=%s' % (tmp_dir,))
source = DebianSource(tmp_dir)
# Run postexport hook
gbp.log.debug('running post-export hook...')
if options.postexport:
Hook('Postexport', options.postexport, shell=True,
extra_env={'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': tmp_dir})(dir=tmp_dir)
# @KK: This is unnecessary because we are creating a new DebianSource object above now, anyhow.
assert source._changelog is None
# # XXX: Using source.sourcepkg causes debian/changelog to be parsed (and then
# # cached); but we want our post-export hook to be able to change it!
# source._changelog = None
if source.changelog.upstream_version is None and not source.is_native():
raise GbpError('This package is not Debian-native (according to debian/source/format), but the '
'last version number in debian/changelog does not seem to contain a dash (-) to '
'separate the Debian version from the upstream version. (The raw version string '
'is {!r}.)'.format(source.changelog.version))
major = (source.changelog.debian_version if source.is_native()
else source.changelog.upstream_version)
if major is None:
raise GbpError('Cannot determine upstream version from changelog.')
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:
gbp.log.debug('Preparing upstream tarball (delayed)...')
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:
Hook('Prebuild', options.prebuild, shell=True,
extra_env={'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir,
'GBP_PBUILDER_DIST': get_pbuilder_dist(options,
repo,
source.is_native()),
})(dir=build_dir)
setup_pbuilder(options, repo, source.is_native())
# 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)
Hook('Postbuild', options.postbuild, shell=True,
extra_env={'GBP_CHANGES_FILE': changes,
'GBP_BUILD_DIR': build_dir})()
if options.tag or options.tag_only:
tag = repo.version_to_tag(options.debian_tag, source.changelog.version)
gbp.log.info("Tagging %s as %s" % (source.changelog.version, tag))
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
tag_msg = format_str(options.debian_tag_msg,
dict(pkg=source.sourcepkg,
version=source.changelog.version))
repo.create_tag(name=tag,
msg=tag_msg,
sign=options.sign_tags,
commit=head,
keyid=options.keyid)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Hook('Posttag', 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 str(err):
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:
summary, msg = gbp.notifications.build_msg(source.changelog,
not retval)
if not gbp.notifications.notify(summary, msg, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
def main(argv):
retval = 0
prefix = "git-"
source = None
branch = None
hook_env = {}
options, gbp_args, dpkg_args = parse_args(argv, prefix)
if not options:
return ExitCodes.parse_error
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
clean_working_tree(options, repo)
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."
)
head = repo.head
tree = write_tree(repo, options)
source = source_vfs(repo, options, tree)
check_tag(options, repo, source)
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, options,
tarball_dir, output_dir)
build_env, hook_env = setup_pbuilder(options, repo,
source.is_native())
# 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:
Hook('Postexport',
options.postexport,
extra_env=Hook.md(hook_env, {
'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': tmp_dir
}))(dir=tmp_dir)
major = (source.debian_version
if source.is_native() else source.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, options,
tarball_dir, output_dir)
build_dir = export_dir
else:
build_dir = repo.path
if options.prebuild:
Hook('Prebuild',
options.prebuild,
extra_env=Hook.md(hook_env, {
'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir
}))(dir=build_dir)
# Finally build the package:
RunAtCommand(
options.builder, [pipes.quote(arg) for arg in dpkg_args],
shell=True,
extra_env=Hook.md(build_env,
{'GBP_BUILD_DIR': build_dir}))(dir=build_dir)
if options.postbuild:
changes = os.path.abspath(
"%s/../%s_%s_%s.changes" %
(build_dir, source.changelog.name,
source.changelog.noepoch, changes_file_suffix(dpkg_args)))
gbp.log.debug("Looking for changes file %s" % changes)
Hook('Postbuild',
options.postbuild,
extra_env=Hook.md(hook_env, {
'GBP_CHANGES_FILE': changes,
'GBP_BUILD_DIR': build_dir
}))()
if options.tag or options.tag_only:
if is_pq_branch(branch):
commit = repo.get_merge_base(branch, pq_branch_base(branch))
else:
commit = head
tag = repo.version_to_tag(options.debian_tag, source.version)
gbp.log.info("Tagging %s as %s" % (source.version, tag))
if options.retag and repo.has_tag(tag):
repo.delete_tag(tag)
tag_msg = format_str(
options.debian_tag_msg,
dict(pkg=source.sourcepkg, version=source.version))
repo.create_tag(name=tag,
msg=tag_msg,
sign=options.sign_tags,
commit=commit,
keyid=options.keyid)
if options.posttag:
sha = repo.rev_parse("%s^{}" % tag)
Hook('Posttag',
options.posttag,
extra_env=Hook.md(
hook_env, {
'GBP_TAG': tag,
'GBP_BRANCH': branch or '(no branch)',
'GBP_SHA1': sha
}))()
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
except DebianSourceError as err:
gbp.log.err(err)
source = None
retval = 1
finally:
drop_index(repo)
if not options.tag_only:
if options.export_dir and options.purge and not retval:
RemoveTree(export_dir)()
if source:
summary, msg = gbp.notifications.build_msg(source.changelog,
not retval)
if not gbp.notifications.notify(summary, msg, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
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
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
finally:
drop_index(repo)
if dump_dir and os.path.exists(dump_dir):
shutil.rmtree(dump_dir)
if not options.tag_only:
if bbfile and options.notify:
summary = "GBP buildpackage-bb %s" % \
["failed", "successful"][not retval]
message = ("Build of %s %s %s" % (bbfile.getVar('PN', True),
RpmPkgPolicy.compose_full_version(pkg_version(bbfile)),
["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
prefix = "git-"
source = None
hook_env = {}
options, gbp_args, dpkg_args = parse_args(argv, prefix)
if not options:
return ExitCodes.parse_error
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
clean_working_tree(options, repo)
check_branch(repo, options)
tree = maybe_write_tree(repo, options)
source = source_vfs(repo, options, tree)
check_tag(options, repo, source)
if not options.tag_only:
output_dir = prepare_output_dir(options.export_dir)
tarball_dir = options.tarball_dir or output_dir
tmp_dir = os.path.join(output_dir, "%s-tmp" % source.sourcepkg)
build_env, hook_env = setup_pbuilder(options, repo,
source.is_native())
major = (source.debian_version
if source.is_native() else source.upstream_version)
export_dir = os.path.join(output_dir,
"%s-%s" % (source.sourcepkg, major))
build_dir = export_dir if options.export_dir else repo.path
changes_file = changes_file_name(source, build_dir, dpkg_args)
# 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_tarballs(repo, source, options,
tarball_dir, output_dir)
# Export to another build dir if requested:
if options.export_dir:
export_source(repo, tree, source, options, tmp_dir,
tarball_dir)
# Run postexport hook
if options.postexport:
Hook('Postexport',
options.postexport,
extra_env=Hook.md(hook_env, {
'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': tmp_dir
}))(dir=tmp_dir)
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_tarballs(repo, source, options,
tarball_dir, output_dir)
if options.prebuild:
Hook('Prebuild',
options.prebuild,
extra_env=Hook.md(hook_env, {
'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir
}))(dir=build_dir)
# Finally build the package:
RunAtCommand(
options.builder, [pipes.quote(arg) for arg in dpkg_args],
shell=True,
extra_env=Hook.md(build_env,
{'GBP_BUILD_DIR': build_dir}))(dir=build_dir)
if options.postbuild:
gbp.log.debug("Looking for changes file %s" % changes_file)
Hook('Postbuild',
options.postbuild,
extra_env=Hook.md(
hook_env, {
'GBP_CHANGES_FILE': changes_file,
'GBP_BUILD_DIR': build_dir
}))()
if options.tag or options.tag_only:
perform_tagging(repo, source, options, hook_env)
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
except DebianSourceError as err:
gbp.log.err(err)
source = None
retval = 1
finally:
drop_index(repo)
if not options.tag_only:
if options.export_dir and options.purge and not retval:
RemoveTree(export_dir)()
if source:
summary, msg = gbp.notifications.build_msg(source.changelog,
not retval)
if not gbp.notifications.notify(summary, msg, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval
def main(argv):
retval = 0
prefix = "git-"
source = None
hook_env = {}
options, gbp_args, dpkg_args = parse_args(argv, prefix)
if not options:
return ExitCodes.parse_error
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
clean_working_tree(options, repo)
check_branch(repo, options)
tree = maybe_write_tree(repo, options)
source = source_vfs(repo, options, tree)
check_tag(options, repo, source)
if not options.tag_only:
output_dir = prepare_output_dir(options.export_dir)
tarball_dir = output_dir
if options.tarball_dir and source.upstream_version is not None:
tarball_dir = PkgPolicy.version_subst(options.tarball_dir, source.upstream_version)
tmp_dir = os.path.join(output_dir, "%s-tmp" % source.sourcepkg)
build_env, hook_env = setup_pbuilder(options, repo, source.is_native())
major = (source.debian_version if source.is_native()
else source.upstream_version)
export_dir = os.path.join(output_dir, "%s-%s" % (source.sourcepkg, major))
build_dir = export_dir if options.export_dir else repo.path
changes_file = changes_file_name(source, build_dir, options.builder, dpkg_args)
# Run preexport hook
if options.export_dir and options.preexport:
Hook('Preexport', options.preexport,
extra_env=Hook.md(hook_env,
{'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_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_tarballs(repo, source, options, tarball_dir,
output_dir)
# Export to another build dir if requested:
if options.export_dir:
export_source(repo, tree, source, options, tmp_dir, tarball_dir)
# Run postexport hook
if options.postexport:
Hook('Postexport', options.postexport,
extra_env=Hook.md(hook_env,
{'GBP_GIT_DIR': repo.git_dir,
'GBP_TMP_DIR': tmp_dir})
)(dir=tmp_dir)
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_tarballs(repo, source, options, tarball_dir,
output_dir)
if options.prebuild:
Hook('Prebuild', options.prebuild,
extra_env=Hook.md(hook_env,
{'GBP_GIT_DIR': repo.git_dir,
'GBP_BUILD_DIR': build_dir})
)(dir=build_dir)
# Finally build the package:
gbp.log.info("Performing the build")
RunAtCommand(options.builder,
[pipes.quote(arg) for arg in dpkg_args],
shell=True,
extra_env=Hook.md(build_env,
{'GBP_BUILD_DIR': build_dir})
)(dir=build_dir)
if options.postbuild:
gbp.log.debug("Looking for changes file %s" % changes_file)
Hook('Postbuild', options.postbuild,
extra_env=Hook.md(hook_env,
{'GBP_CHANGES_FILE': changes_file,
'GBP_BUILD_DIR': build_dir})
)()
if options.tag or options.tag_only:
perform_tagging(repo, source, options, hook_env)
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
except DebianSourceError as err:
gbp.log.err(err)
source = None
retval = 1
finally:
drop_index(repo)
if not options.tag_only:
if options.export_dir and options.purge and not retval:
RemoveTree(export_dir)()
if source:
summary, msg = gbp.notifications.build_msg(source.changelog,
not retval)
if not gbp.notifications.notify(summary, msg, options.notify):
gbp.log.err("Failed to send notification")
retval = 1
return retval