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