def upgrade_repository(repository, generate_rebase_map,
determine_new_revid, revision_id=None,
allow_changes=False, verbose=False):
"""Upgrade the revisions in repository until the specified stop revision.
:param repository: Repository in which to upgrade.
:param foreign_repository: Repository to fetch new revisions from.
:param new_mapping: New mapping.
:param revision_id: Revision id up until which to upgrade, or None for
all revisions.
:param allow_changes: Allow changes to mappings.
:param verbose: Whether to print list of rewrites
:return: Dictionary of mapped revisions
"""
# Find revisions that need to be upgraded, create
# dictionary with revision ids in key, new parents in value
try:
repository.lock_write()
(plan, revid_renames) = create_upgrade_plan(repository,
generate_rebase_map, determine_new_revid,
revision_id=revision_id, allow_changes=allow_changes)
if verbose:
for revid in rebase_todo(repository, plan):
trace.note("%s -> %s" % (revid, plan[revid][0]))
rebase(repository, plan, CommitBuilderRevisionRewriter(repository))
return revid_renames
finally:
repository.unlock()
def finish_rebase(state, wt, replace_map, replayer):
from bzrlib.plugins.rewrite.rebase import rebase
try:
# Start executing plan from current Branch.last_revision()
rebase(wt.branch.repository, replace_map, replayer)
except ConflictsInTree:
raise BzrCommandError(
gettext(
"A conflict occurred replaying a commit."
" Resolve the conflict and run 'bzr rebase-continue' or "
"run 'bzr rebase-abort'."
)
)
# Remove plan file
state.remove_plan()
def run(self, merge_type=None, directory="."):
from bzrlib.plugins.rewrite.rebase import (
RebaseState1,
rebase,
WorkingTreeRevisionRewriter,
)
from bzrlib.workingtree import WorkingTree
wt = WorkingTree.open_containing(directory)[0]
wt.lock_write()
try:
state = RebaseState1(wt)
replayer = WorkingTreeRevisionRewriter(wt, state, merge_type=merge_type)
# Abort if there are any conflicts
if len(wt.conflicts()) != 0:
raise BzrCommandError("There are still conflicts present. "
"Resolve the conflicts and then run "
"'bzr resolve' and try again.")
# Read plan file
try:
replace_map = state.read_plan()[1]
except NoSuchFile:
raise BzrCommandError("No rebase to continue")
oldrevid = state.read_active_revid()
if oldrevid is not None:
oldrev = wt.branch.repository.get_revision(oldrevid)
replayer.commit_rebase(oldrev, replace_map[oldrevid][0])
try:
# Start executing plan from current Branch.last_revision()
rebase(wt.branch.repository, replace_map, replayer)
except ConflictsInTree:
raise BzrCommandError("A conflict occurred replaying a commit."
" Resolve the conflict and run 'bzr rebase-continue' or "
"run 'bzr rebase-abort'.")
# Remove plan file
state.remove_plan()
finally:
wt.unlock()
def run(self, upstream_location=None, onto=None, revision=None,
merge_type=None, verbose=False, dry_run=False,
always_rebase_merges=False, pending_merges=False,
directory="."):
from bzrlib.branch import Branch
from bzrlib.revisionspec import RevisionSpec
from bzrlib.workingtree import WorkingTree
from bzrlib.plugins.rewrite.rebase import (
generate_simple_plan,
rebase,
RebaseState1,
WorkingTreeRevisionRewriter,
regenerate_default_revid,
rebase_todo,
)
if revision is not None and pending_merges:
raise BzrCommandError(
"--revision and --pending-merges are mutually exclusive")
wt = WorkingTree.open_containing(directory)[0]
wt.lock_write()
try:
state = RebaseState1(wt)
if upstream_location is None:
if pending_merges:
upstream_location = directory
else:
upstream_location = wt.branch.get_parent()
if upstream_location is None:
raise BzrCommandError("No upstream branch specified.")
note("Rebasing on %s", upstream_location)
upstream = Branch.open_containing(upstream_location)[0]
upstream_repository = upstream.repository
upstream_revision = upstream.last_revision()
# Abort if there already is a plan file
if state.has_plan():
raise BzrCommandError("A rebase operation was interrupted. "
"Continue using 'bzr rebase-continue' or abort using 'bzr "
"rebase-abort'")
start_revid = None
stop_revid = None
if revision is not None:
if len(revision) == 1:
if revision[0] is not None:
stop_revid = revision[0].as_revision_id(wt.branch)
elif len(revision) == 2:
if revision[0] is not None:
start_revid = revision[0].as_revision_id(wt.branch)
if revision[1] is not None:
stop_revid = revision[1].as_revision_id(wt.branch)
else:
raise BzrCommandError(
"--revision takes only one or two arguments")
if pending_merges:
wt_parents = wt.get_parent_ids()
if len(wt_parents) in (0, 1):
raise BzrCommandError("No pending merges present.")
elif len(wt_parents) > 2:
raise BzrCommandError(
"Rebasing more than one pending merge not supported")
stop_revid = wt_parents[1]
assert stop_revid is not None, "stop revid invalid"
# Check for changes in the working tree.
if (not pending_merges and
wt.basis_tree().changes_from(wt).has_changed()):
raise UncommittedChanges(wt)
# Pull required revisions
wt.branch.repository.fetch(upstream_repository, upstream_revision)
if onto is None:
onto = upstream.last_revision()
else:
rev_spec = RevisionSpec.from_string(onto)
onto = rev_spec.as_revision_id(upstream)
wt.branch.repository.fetch(upstream_repository, onto)
if stop_revid is None:
stop_revid = wt.branch.last_revision()
repo_graph = wt.branch.repository.get_graph()
our_new, onto_unique = repo_graph.find_difference(stop_revid, onto)
if start_revid is None:
if not onto_unique:
self.outf.write("No revisions to rebase.\n")
return
if not our_new:
self.outf.write("Base branch is descendant of current "
"branch. Pulling instead.\n")
if not dry_run:
wt.pull(upstream, onto)
return
# else: include extra revisions needed to make start_revid mean
# something.
# Create plan
replace_map = generate_simple_plan(
our_new, start_revid, stop_revid,
onto, repo_graph,
lambda revid, ps: regenerate_default_revid(
wt.branch.repository, revid),
not always_rebase_merges
)
if verbose or dry_run:
todo = list(rebase_todo(wt.branch.repository, replace_map))
note('%d revisions will be rebased:' % len(todo))
for revid in todo:
note("%s" % revid)
if not dry_run:
# Write plan file
state.write_plan(replace_map)
# Start executing plan
try:
rebase(wt.branch.repository, replace_map,
WorkingTreeRevisionRewriter(wt, state,
merge_type=merge_type))
except ConflictsInTree:
raise BzrCommandError("A conflict occurred replaying a "
"commit. Resolve the conflict and run "
"'bzr rebase-continue' or run 'bzr rebase-abort'.")
# Remove plan file
state.remove_plan()
finally:
wt.unlock()
