def main(argv):
retval = 0
(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:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
current = repo.get_branch()
if action == "export":
export_patches(repo, current, options)
elif action == "import":
import_pq(repo, current, options)
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, current, options)
elif action == "apply":
patch = Patch(patchfile)
maintainer = get_maintainer_from_control(repo)
apply_single_patch(repo, current, patch, maintainer, options.topic)
elif action == "switch":
switch_pq(repo, current, options)
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 main(argv):
retval = 0
(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:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = DebianGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
current = repo.get_branch()
if action == "export":
export_patches(repo, current, options)
elif action == "import":
import_pq(repo, current, options)
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, current, options)
elif action == "apply":
patch = Patch(patchfile)
maintainer = get_maintainer_from_control(repo)
apply_single_patch(repo, current, patch, maintainer, options.topic)
elif action == "switch":
switch_pq(repo, current, options)
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 drop_pq_rpm(repo, options):
"""Remove pq branch"""
current = repo.get_branch()
if is_pq_branch(current, options):
base = pq_branch_base(current, options)
spec = parse_spec(options, repo, base)
else:
spec = parse_spec(options, repo)
drop_pq(repo, current, options, spec.version)
def drop_pq_bb(cfg, repo, options):
"""Remove pq branch"""
current = repo.get_branch()
if is_pq_branch(current, options):
base = pq_branch_base(current, options)
bbfile = parse_bb(cfg, options, repo, base)
else:
bbfile = parse_bb(cfg, options, repo)
drop_pq(repo, current, options, pkg_version(bbfile))
def export_patches(repo, branch, options):
"""Export patches from the pq branch into a patch series"""
patch_dir = os.path.join(repo.path, PATCH_DIR)
series_file = os.path.join(repo.path, SERIES_FILE)
if is_pq_branch(branch):
base = pq_branch_base(branch)
gbp.log.info("On '%s', switching to '%s'" % (branch, base))
branch = base
repo.set_branch(branch)
pq_branch = pq_branch_name(branch)
try:
shutil.rmtree(patch_dir)
except OSError as e:
if e.errno != errno.ENOENT:
raise GbpError("Failed to remove patch dir: %s" % e.strerror)
else:
gbp.log.debug("%s does not exist." % patch_dir)
if pq_on_upstream_tag(options.pq_from):
base = find_upstream_commit(repo, branch, options.upstream_tag)
else:
base = branch
patches = generate_patches(repo, base, pq_branch, patch_dir, options)
if patches:
with open(series_file, 'w') as seriesfd:
for patch in patches:
seriesfd.write(os.path.relpath(patch, patch_dir) + '\n')
else:
gbp.log.info("No patches on '%s' - nothing to export." % pq_branch)
if options.commit:
added, removed = commit_patches(repo, branch, patches, options,
patch_dir)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" %
(what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" %
(what, ', '.join(removed)))
else:
gbp.log.info("Updated existing patches.")
if options.drop:
drop_pq(repo, branch)
def export_patches(repo, branch, options):
"""Export patches from the pq branch into a patch series"""
patch_dir = os.path.join(repo.path, PATCH_DIR)
series_file = os.path.join(repo.path, SERIES_FILE)
if is_pq_branch(branch):
base = pq_branch_base(branch)
gbp.log.info("On '%s', switching to '%s'" % (branch, base))
branch = base
repo.set_branch(branch)
pq_branch = pq_branch_name(branch)
try:
shutil.rmtree(patch_dir)
except OSError as e:
if e.errno != errno.ENOENT:
raise GbpError("Failed to remove patch dir: %s" % e.strerror)
else:
gbp.log.debug("%s does not exist." % patch_dir)
if pq_on_upstream_tag(options.pq_from):
base = find_upstream_commit(repo, branch, options.upstream_tag)
else:
base = branch
patches = generate_patches(repo, base, pq_branch, patch_dir, options)
if patches:
with open(series_file, 'w') as seriesfd:
for patch in patches:
seriesfd.write(os.path.relpath(patch, patch_dir) + '\n')
else:
gbp.log.info("No patches on '%s' - nothing to export." % pq_branch)
if options.commit:
added, removed = commit_patches(repo, branch, patches, options, patch_dir)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" % (what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" % (what, ', '.join(removed)))
else:
gbp.log.info("Updated existing patches.")
if options.drop:
drop_pq(repo, branch)
def export_patches(repo, options):
"""Export patches from the pq branch into a packaging branch"""
current = repo.get_branch()
if is_pq_branch(current):
base = pq_branch_base(current)
gbp.log.info("On branch '%s', switching to '%s'" % (current, base))
repo.set_branch(base)
pq_branch = current
else:
base = current
pq_branch = pq_branch_name(current)
spec = parse_spec(options, repo)
upstream_commit = find_upstream_commit(repo, spec, options.upstream_tag)
export_treeish = pq_branch
update_patch_series(repo, spec, upstream_commit, export_treeish, options)
GitCommand('status')(['--', spec.specdir])
if options.drop:
drop_pq(repo, base)
def export_patches(repo, branch, options):
"""Export patches from the pq branch into a patch series"""
if is_pq_branch(branch):
base = pq_branch_base(branch)
gbp.log.info("On '%s', switching to '%s'" % (branch, base))
branch = base
repo.set_branch(branch)
pq_branch = pq_branch_name(branch)
try:
shutil.rmtree(PATCH_DIR)
except OSError as e:
if e.errno != errno.ENOENT:
raise GbpError("Failed to remove patch dir: %s" % e.strerror)
else:
gbp.log.debug("%s does not exist." % PATCH_DIR)
patches = generate_patches(repo, branch, pq_branch, PATCH_DIR, options)
if patches:
with open(SERIES_FILE, 'w') as seriesfd:
for patch in patches:
seriesfd.write(os.path.relpath(patch, PATCH_DIR) + '\n')
if options.commit:
added, removed = commit_patches(repo, branch, patches, options)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" %
(what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" %
(what, ', '.join(removed)))
else:
GitCommand('status')(['--', PATCH_DIR])
else:
gbp.log.info("No patches on '%s' - nothing to do." % pq_branch)
if options.drop:
drop_pq(repo, branch)
def export_patches(repo, branch, options):
"""Export patches from the pq branch into a patch series"""
if is_pq_branch(branch):
base = pq_branch_base(branch)
gbp.log.info("On '%s', switching to '%s'" % (branch, base))
branch = base
repo.set_branch(branch)
pq_branch = pq_branch_name(branch)
try:
shutil.rmtree(PATCH_DIR)
except OSError as e:
if e.errno != errno.ENOENT:
raise GbpError("Failed to remove patch dir: %s" % e.strerror)
else:
gbp.log.debug("%s does not exist." % PATCH_DIR)
patches = generate_patches(repo, branch, pq_branch, PATCH_DIR, options)
if patches:
with open(SERIES_FILE, 'w') as seriesfd:
for patch in patches:
seriesfd.write(os.path.relpath(patch, PATCH_DIR) + '\n')
if options.commit:
added, removed = commit_patches(repo, branch, patches, options)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" % (what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" % (what, ', '.join(removed)))
else:
GitCommand('status')(['--', PATCH_DIR])
else:
gbp.log.info("No patches on '%s' - nothing to do." % pq_branch)
if options.drop:
drop_pq(repo, branch)
def main(argv):
"""Main function for the gbp pq-rpm command"""
retval = 0
(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:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch", "convert"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = RpmGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
# Create base temporary directory for this run
init_tmpdir(options.tmp_dir, prefix='pq-rpm_')
current = repo.get_branch()
if action == "export":
export_patches(repo, options)
elif action == "import":
import_spec_patches(repo, options)
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, options)
elif action == "apply":
patch = Patch(patchfile)
apply_single_patch(repo, current, patch, fallback_author=None)
elif action == "switch":
switch_pq(repo, current)
except KeyboardInterrupt:
retval = 1
gbp.log.err("Interrupted. Aborting.")
except CommandExecFailed:
retval = 1
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpError as err:
if str(err):
gbp.log.err(err)
retval = 1
finally:
del_tmpdir()
return retval
def import_quilt_patches(repo, branch, series, tries, force):
"""
apply a series of quilt patches in the series file 'series' to branch
the patch-queue branch for 'branch'
@param repo: git repository to work on
@param branch: branch to base pqtch queue on
@param series; series file to read patches from
@param tries: try that many times to apply the patches going back one
commit in the branches history after each failure.
@param force: import the patch series even if the branch already exists
"""
tmpdir = None
if is_pq_branch(branch):
if force:
branch = pq_branch_base(branch)
pq_branch = pq_branch_name(branch)
repo.checkout(branch)
else:
gbp.log.err("Already on a patch-queue branch '%s' - doing nothing." % branch)
raise GbpError
else:
pq_branch = pq_branch_name(branch)
if repo.has_branch(pq_branch):
if force:
drop_pq(repo, branch)
else:
raise GbpError("Patch queue branch '%s'. already exists. Try 'rebase' instead."
% pq_branch)
maintainer = get_maintainer_from_control(repo)
commits = repo.get_commits(num=tries, first_parent=True)
# If we go back in history we have to safe our pq so we always try to apply
# the latest one
if len(commits) > 1:
tmpdir, series = safe_patches(series)
queue = PatchSeries.read_series_file(series)
i = len(commits)
for commit in commits:
if len(commits) > 1:
gbp.log.info("%d %s left" % (i, 'tries' if i > 1 else 'try'))
try:
gbp.log.info("Trying to apply patches at '%s'" % commit)
repo.create_branch(pq_branch, commit)
except GitRepositoryError:
raise GbpError("Cannot create patch-queue branch '%s'." % pq_branch)
repo.set_branch(pq_branch)
for patch in queue:
gbp.log.debug("Applying %s" % patch.path)
try:
apply_and_commit_patch(repo, patch, maintainer, patch.topic)
except (GbpError, GitRepositoryError):
gbp.log.err("Failed to apply '%s'" % patch.path)
repo.set_branch(branch)
repo.delete_branch(pq_branch)
break
else:
# All patches applied successfully
break
i-=1
else:
raise GbpError("Couldn't apply patches")
if tmpdir:
gbp.log.debug("Remove temporary patch safe '%s'" % tmpdir)
shutil.rmtree(tmpdir)
def main(argv):
retval = 0
(options, args) = parse_args(argv)
if not options:
return 1
gbp.log.setup(options.color, options.verbose, options.color_scheme)
if len(args) < 2:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = GitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
current = repo.get_branch()
if action == "export":
export_patches(repo, current, options)
elif action == "import":
series = SERIES_FILE
tries = options.time_machine if (options.time_machine > 0) else 1
import_quilt_patches(repo, current, series, tries, options.force)
current = repo.get_branch()
gbp.log.info("Patches listed in '%s' imported on '%s'" %
(series, current))
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, current)
elif action == "apply":
patch = Patch(patchfile)
maintainer = get_maintainer_from_control(repo)
apply_single_patch(repo, current, patch, maintainer, options.topic)
elif action == "switch":
switch_pq(repo, current)
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
def import_quilt_patches(repo, branch, series, tries, force, pq_from,
upstream_tag):
"""
apply a series of quilt patches in the series file 'series' to branch
the patch-queue branch for 'branch'
@param repo: git repository to work on
@param branch: branch to base patch queue on
@param series: series file to read patches from
@param tries: try that many times to apply the patches going back one
commit in the branches history after each failure.
@param force: import the patch series even if the branch already exists
@param pq_from: what to use as the starting point for the pq branch.
DEBIAN indicates the current branch, TAG indicates that
the corresponding upstream tag should be used.
@param upstream_tag: upstream tag template to use
"""
tmpdir = None
series = os.path.join(repo.path, series)
if is_pq_branch(branch):
if force:
branch = pq_branch_base(branch)
pq_branch = pq_branch_name(branch)
repo.checkout(branch)
else:
raise GbpError("Already on a patch-queue branch '%s' - doing nothing." % branch)
else:
pq_branch = pq_branch_name(branch)
if repo.has_branch(pq_branch):
if force:
drop_pq(repo, branch)
else:
raise GbpError("Patch queue branch '%s'. already exists. Try 'rebase' or 'switch' instead."
% pq_branch)
maintainer = get_maintainer_from_control(repo)
if pq_on_upstream_tag(pq_from):
commits = [find_upstream_commit(repo, branch, upstream_tag)]
else: # pq_from == 'DEBIAN'
commits = repo.get_commits(num=tries, first_parent=True)
# If we go back in history we have to safe our pq so we always try to apply
# the latest one
# If we are using the upstream_tag, we always need a copy of the patches
if len(commits) > 1 or pq_on_upstream_tag(pq_from):
if os.path.exists(series):
tmpdir, series = safe_patches(series, repo)
queue = PatchSeries.read_series_file(series)
i = len(commits)
for commit in commits:
if len(commits) > 1:
gbp.log.info("%d %s left" % (i, 'tries' if i > 1 else 'try'))
try:
gbp.log.info("Trying to apply patches at '%s'" % commit)
repo.create_branch(pq_branch, commit)
except GitRepositoryError:
raise GbpError("Cannot create patch-queue branch '%s'." % pq_branch)
repo.set_branch(pq_branch)
for patch in queue:
gbp.log.debug("Applying %s" % patch.path)
try:
name = os.path.basename(patch.path)
apply_and_commit_patch(repo, patch, maintainer, patch.topic, name)
except (GbpError, GitRepositoryError) as e:
gbp.log.err("Failed to apply '%s': %s" % (patch.path, e))
repo.force_head('HEAD', hard=True)
repo.set_branch(branch)
repo.delete_branch(pq_branch)
break
else:
# All patches applied successfully
break
i -= 1
else:
raise GbpError("Couldn't apply patches")
if tmpdir:
gbp.log.debug("Remove temporary patch safe '%s'" % tmpdir)
shutil.rmtree(tmpdir)
return len(queue)
added, removed = commit_patches(repo, branch, patches, options)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" %
(what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" %
(what, ', '.join(removed)))
else:
GitCommand('status')(['--', PATCH_DIR])
else:
gbp.log.info("No patches on '%s' - nothing to do." % pq_branch)
if options.drop:
drop_pq(repo, branch, options)
def safe_patches(series, tmpdir_base):
"""
Safe the current patches in a temporary directory
below .git/
@param series: path to series file
@return: tmpdir and path to safed series file
@rtype: tuple
"""
src = os.path.dirname(series)
name = os.path.basename(series)
def import_quilt_patches(repo, branch, series, tries, force, pq_from,
upstream_tag):
"""
apply a series of quilt patches in the series file 'series' to branch
the patch-queue branch for 'branch'
@param repo: git repository to work on
@param branch: branch to base patch queue on
@param series: series file to read patches from
@param tries: try that many times to apply the patches going back one
commit in the branches history after each failure.
@param force: import the patch series even if the branch already exists
@param pq_from: what to use as the starting point for the pq branch.
DEBIAN indicates the current branch, TAG indicates that
the corresponding upstream tag should be used.
@param upstream_tag: upstream tag template to use
"""
tmpdir = None
series = os.path.join(repo.path, series)
if is_pq_branch(branch):
if force:
branch = pq_branch_base(branch)
pq_branch = pq_branch_name(branch)
repo.checkout(branch)
else:
raise GbpError(
"Already on a patch-queue branch '%s' - doing nothing." %
branch)
else:
pq_branch = pq_branch_name(branch)
if repo.has_branch(pq_branch):
if force:
drop_pq(repo, branch)
else:
raise GbpError(
"Patch queue branch '%s'. already exists. Try 'rebase' or 'switch' instead."
% pq_branch)
maintainer = get_maintainer_from_control(repo)
if pq_on_upstream_tag(pq_from):
commits = [find_upstream_commit(repo, branch, upstream_tag)]
else: # pq_from == 'DEBIAN'
commits = repo.get_commits(num=tries, first_parent=True)
# If we go back in history we have to safe our pq so we always try to apply
# the latest one
# If we are using the upstream_tag, we always need a copy of the patches
if len(commits) > 1 or pq_on_upstream_tag(pq_from):
if os.path.exists(series):
tmpdir, series = safe_patches(series, repo)
queue = PatchSeries.read_series_file(series)
i = len(commits)
for commit in commits:
if len(commits) > 1:
gbp.log.info("%d %s left" % (i, 'tries' if i > 1 else 'try'))
try:
gbp.log.info("Trying to apply patches at '%s'" % commit)
repo.create_branch(pq_branch, commit)
except GitRepositoryError:
raise GbpError("Cannot create patch-queue branch '%s'." %
pq_branch)
repo.set_branch(pq_branch)
for patch in queue:
gbp.log.debug("Applying %s" % patch.path)
try:
name = os.path.basename(patch.path)
apply_and_commit_patch(repo, patch, maintainer, patch.topic,
name)
except (GbpError, GitRepositoryError) as e:
gbp.log.err("Failed to apply '%s': %s" % (patch.path, e))
repo.force_head('HEAD', hard=True)
repo.set_branch(branch)
repo.delete_branch(pq_branch)
break
else:
# All patches applied successfully
break
i -= 1
else:
raise GbpError("Couldn't apply patches")
if tmpdir:
gbp.log.debug("Remove temporary patch safe '%s'" % tmpdir)
shutil.rmtree(tmpdir)
return len(queue)
def main(argv):
"""Main function for the gbp pq-rpm command"""
retval = 0
(options, args) = parse_args(argv)
if not options:
return 1
gbp.log.setup(options.color, options.verbose, options.color_scheme)
if len(args) < 2:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch", "convert"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = RpmGitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
# Create base temporary directory for this run
options.tmp_dir = tempfile.mkdtemp(dir=options.tmp_dir,
prefix='gbp-pq-rpm_')
current = repo.get_branch()
if action == "export":
export_patches(repo, options)
elif action == "import":
import_spec_patches(repo, options)
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, options)
elif action == "apply":
patch = Patch(patchfile)
apply_single_patch(repo, current, patch, fallback_author=None)
elif action == "switch":
switch_pq(repo, current)
except CommandExecFailed:
retval = 1
except GitRepositoryError as err:
gbp.log.err("Git command failed: %s" % err)
retval = 1
except GbpError, err:
if str(err):
gbp.log.err(err)
retval = 1
def main(argv):
retval = 0
parser = GbpOptionParserDebian(command=os.path.basename(argv[0]), prefix='',
usage="%prog [options] action - maintain patches on a patch queue branch\n"
"Actions:\n"
" export export the patch queue associated to the current branch\n"
" into a quilt patch series in debian/patches/ and update the\n"
" series file.\n"
" import create a patch queue branch from quilt patches in debian/patches.\n"
" rebase switch to patch queue branch associated to the current\n"
" branch and rebase against current branch.\n"
" drop drop (delete) the patch queue associated to the current branch.\n"
" apply apply a patch\n"
" switch switch to patch-queue branch and vice versa")
parser.add_boolean_config_file_option(option_name="patch-numbers", dest="patch_numbers")
parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False,
help="verbose command execution")
parser.add_option("--topic", dest="topic", help="in case of 'apply' topic (subdir) to put patch into")
parser.add_config_file_option(option_name="time-machine", dest="time_machine", type="int")
parser.add_option("--force", dest="force", action="store_true", default=False,
help="in case of import even import if the branch already exists")
parser.add_config_file_option(option_name="color", dest="color", type='tristate')
parser.add_config_file_option(option_name="color-scheme",
dest="color_scheme")
(options, args) = parser.parse_args(argv)
gbp.log.setup(options.color, options.verbose, options.color_scheme)
if len(args) < 2:
gbp.log.err("No action given.")
return 1
else:
action = args[1]
if args[1] in ["export", "import", "rebase", "drop", "switch"]:
pass
elif args[1] in ["apply"]:
if len(args) != 3:
gbp.log.err("No patch name given.")
return 1
else:
patchfile = args[2]
else:
gbp.log.err("Unknown action '%s'." % args[1])
return 1
try:
repo = GitRepository(os.path.curdir)
except GitRepositoryError:
gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
return 1
try:
current = repo.get_branch()
if action == "export":
export_patches(repo, current, options)
elif action == "import":
series = SERIES_FILE
tries = options.time_machine if (options.time_machine > 0) else 1
import_quilt_patches(repo, current, series, tries, options.force)
current = repo.get_branch()
gbp.log.info("Patches listed in '%s' imported on '%s'" %
(series, current))
elif action == "drop":
drop_pq(repo, current)
elif action == "rebase":
rebase_pq(repo, current)
elif action == "apply":
patch = Patch(patchfile)
maintainer = get_maintainer_from_control(repo)
apply_single_patch(repo, current, patch, maintainer, options.topic)
elif action == "switch":
switch_pq(repo, current)
except CommandExecFailed:
retval = 1
except (GbpError, GitRepositoryError) as err:
if len(err.__str__()):
gbp.log.err(err)
retval = 1
return retval
added, removed = commit_patches(repo, branch, patches, options)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" %
(what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" %
(what, ', '.join(removed)))
else:
GitCommand('status')(['--', PATCH_DIR])
else:
gbp.log.info("No patches on '%s' - nothing to do." % pq_branch)
if options.drop:
drop_pq(repo, branch)
def safe_patches(series):
"""
Safe the current patches in a temporary directory
below .git/
@param series: path to series file
@return: tmpdir and path to safed series file
@rtype: tuple
"""
src = os.path.dirname(series)
name = os.path.basename(series)
seriesfd.write(os.path.relpath(patch, PATCH_DIR) + '\n')
if options.commit:
added, removed = commit_patches(repo, branch, patches, options)
if added:
what = 'patches' if len(added) > 1 else 'patch'
gbp.log.info("Added %s %s to patch series" % (what, ', '.join(added)))
if removed:
what = 'patches' if len(removed) > 1 else 'patch'
gbp.log.info("Removed %s %s from patch series" % (what, ', '.join(removed)))
else:
GitCommand('status')(['--', PATCH_DIR])
else:
gbp.log.info("No patches on '%s' - nothing to do." % pq_branch)
if options.drop:
drop_pq(repo, branch)
def safe_patches(series):
"""
Safe the current patches in a temporary directory
below .git/
@param series: path to series file
@return: tmpdir and path to safed series file
@rtype: tuple
"""
src = os.path.dirname(series)
name = os.path.basename(series)
