# Copyright (C) 2006,2008 by Jelmer Vernooij # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """Upgrading revisions made with older versions of the mapping.""" from bzrlib import ui from bzrlib.errors import BzrError, InvalidRevisionId, DependencyNotPresent from bzrlib.revision import Revision from bzrlib.trace import info import itertools class RebaseNotPresent(DependencyNotPresent): _fmt = "Unable to import bzr-rebase (required for upgrade support): %(error)s" def __init__(self, error): DependencyNotPresent.__init__(self, 'bzr-rebase', error) def check_rebase_version(min_version): """Check what version of bzr-rebase is installed. Raises an exception when the version installed is older than min_version. :raises RebaseNotPresent: Raised if bzr-rebase is not installed or too old. """ try: from bzrlib.plugins.rebase import version_info as rebase_version_info if rebase_version_info[:2] < min_version: raise RebaseNotPresent("Version %r present, at least %r required" % (rebase_version_info, min_version)) except ImportError, e: raise RebaseNotPresent(e) class UpgradeChangesContent(BzrError): """Inconsistency was found upgrading the mapping of a revision.""" _fmt = """Upgrade will change contents in revision %(revid)s. Use --allow-changes to override.""" def __init__(self, revid): self.revid = revid def create_upgraded_revid(revid, mapping_suffix, upgrade_suffix="-upgrade"): """Create a new revision id for an upgraded version of a revision. Prevents suffix to be appended needlessly. :param revid: Original revision id. :return: New revision id """ if revid.endswith(upgrade_suffix): return revid[0:revid.rfind("-svn")] + mapping_suffix + upgrade_suffix else: return revid + mapping_suffix + upgrade_suffix def determine_fileid_renames(old_tree, new_tree): for old_file_id in old_tree: new_file_id = new_tree.path2id(old_tree.id2path(old_file_id)) if old_file_id == new_file_id: continue if new_file_id is not None: yield new_tree.id2path(new_file_id), old_file_id, new_file_id def upgrade_workingtree(wt, foreign_repository, new_mapping, mapping_registry, allow_changes=False, verbose=False): """Upgrade a working tree. :param foreign_repository: Foreign repository object """ wt.lock_write() try: old_revid = wt.last_revision() revid_renames = upgrade_branch(wt.branch, foreign_repository, new_mapping=new_mapping, mapping_registry=mapping_registry, allow_changes=allow_changes, verbose=verbose) last_revid = wt.branch.last_revision() if old_revid == last_revid: return revid_renames fileid_renames = dict([(path, (old_fileid, new_fileid)) for (path, old_fileid, new_fileid) in determine_fileid_renames(wt.branch.repository.revision_tree(old_revid), wt.branch.repository.revision_tree(last_revid))]) old_fileids = [] new_fileids = [] new_root_id = None # Adjust file ids in working tree for path in sorted(fileid_renames.keys(), reverse=True): if path != "": old_fileids.append(fileid_renames[path][0]) new_fileids.append((path, fileid_renames[path][1])) else: new_root_id = fileid_renames[path][1] new_fileids.reverse() wt.unversion(old_fileids) if new_root_id is not None: wt.set_root_id(new_root_id) wt.add([x[0] for x in new_fileids], [x[1] for x in new_fileids]) wt.set_last_revision(last_revid) finally: wt.unlock() return revid_renames def upgrade_tags(tags, repository, foreign_repository, new_mapping, mapping_registry, allow_changes=False, verbose=False, branch_renames=None): """Upgrade a tags dictionary.""" pb = ui.ui_factory.nested_progress_bar() try: tags_dict = tags.get_tag_dict() for i, (name, revid) in enumerate(tags_dict.items()): pb.update("upgrading tags", i, len(tags_dict)) if branch_renames is not None and revid in branch_renames: renames = branch_renames else: renames = upgrade_repository(repository, foreign_repository, revision_id=revid, new_mapping=new_mapping, mapping_registry=mapping_registry, allow_changes=allow_changes, verbose=verbose) if revid in renames: tags.set_tag(name, renames[revid]) finally: pb.finished() def upgrade_branch(branch, foreign_repository, new_mapping, mapping_registry, allow_changes=False, verbose=False): """Upgrade a branch to the current mapping version. :param branch: Branch to upgrade. :param foreign_repository: Repository to fetch new revisions from :param allow_changes: Allow changes in mappings. :param verbose: Whether to print verbose list of rewrites """ revid = branch.last_revision() renames = upgrade_repository(branch.repository, foreign_repository, revision_id=revid, new_mapping=new_mapping, mapping_registry=mapping_registry, allow_changes=allow_changes, verbose=verbose) upgrade_tags(branch.tags, branch.repository, foreign_repository, new_mapping=new_mapping, mapping_registry=mapping_registry, allow_changes=allow_changes, verbose=verbose) if len(renames) > 0: branch.generate_revision_history(renames[revid]) return renames def check_revision_changed(oldrev, newrev): """Check if two revisions are different. This is exactly the same as Revision.equals() except that it does not check the revision_id.""" if (newrev.inventory_sha1 != oldrev.inventory_sha1 or newrev.timestamp != oldrev.timestamp or newrev.message != oldrev.message or newrev.timezone != oldrev.timezone or newrev.committer != oldrev.committer or newrev.properties != oldrev.properties): raise UpgradeChangesContent(oldrev.revision_id) def generate_upgrade_map(new_mapping, revs, mapping_registry): """Generate an upgrade map for use by bzr-rebase. :param new_mapping: Mapping to upgrade revisions to. :param revs: Iterator over revisions to upgrade. :return: Map from old revids as keys, new revids as values stored in a dictionary. """ rename_map = {} # Create a list of revisions that can be renamed during the upgrade for revid in revs: assert isinstance(revid, str) try: (foreign_revid, _) = mapping_registry.parse_revision_id(revid) except InvalidRevisionId: # Not a foreign revision, nothing to do continue newrevid = new_mapping.revision_id_foreign_to_bzr(foreign_revid) if revid == newrevid: continue rename_map[revid] = newrevid return rename_map MIN_REBASE_VERSION = (0, 4) def create_upgrade_plan(repository, foreign_repository, new_mapping, mapping_registry, revision_id=None, allow_changes=False): """Generate a rebase plan for upgrading revisions. :param repository: Repository to do upgrade in :param foreign_repository: Subversion repository to fetch new revisions from. :param new_mapping: New mapping to use. :param revision_id: Revision to upgrade (None for all revisions in repository.) :param allow_changes: Whether an upgrade is allowed to change the contents of revisions. :return: Tuple with a rebase plan and map of renamed revisions. """ from bzrlib.plugins.rebase.rebase import generate_transpose_plan check_rebase_version(MIN_REBASE_VERSION) graph = repository.get_graph() if revision_id is None: potential = repository.all_revision_ids() else: potential = itertools.imap(lambda (rev, parents): rev, graph.iter_ancestry([revision_id])) upgrade_map = generate_upgrade_map(new_mapping, potential, mapping_registry) # Make sure all the required current version revisions are present for revid in upgrade_map.values(): if not repository.has_revision(revid): repository.fetch(foreign_repository, revid) if not allow_changes: for oldrevid, newrevid in upgrade_map.items(): oldrev = repository.get_revision(oldrevid) newrev = repository.get_revision(newrevid) check_revision_changed(oldrev, newrev) if revision_id is None: heads = repository.all_revision_ids() else: heads = [revision_id] plan = generate_transpose_plan(graph.iter_ancestry(heads), upgrade_map, graph, lambda revid: create_upgraded_revid(revid, new_mapping.upgrade_suffix)) def remove_parents((oldrevid, (newrevid, parents))): return (oldrevid, newrevid) upgrade_map.update(dict(map(remove_parents, plan.items()))) return (plan, upgrade_map) def upgrade_repository(repository, foreign_repository, new_mapping, mapping_registry, 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 """ check_rebase_version(MIN_REBASE_VERSION) from bzrlib.plugins.rebase.rebase import ( replay_snapshot, rebase, rebase_todo) # Find revisions that need to be upgraded, create # dictionary with revision ids in key, new parents in value try: repository.lock_write() foreign_repository.lock_read() (plan, revid_renames) = create_upgrade_plan(repository, foreign_repository, new_mapping, mapping_registry, revision_id=revision_id, allow_changes=allow_changes) if verbose: for revid in rebase_todo(repository, plan): info("%s -> %s" % (revid, plan[revid][0])) def fix_revid(revid): try: (foreign_revid, mapping) = mapping_registry.parse_revision_id(revid) except InvalidRevisionId: return revid return new_mapping.revision_id_foreign_to_bzr(foreign_revid) def replay(repository, oldrevid, newrevid, new_parents): return replay_snapshot(repository, oldrevid, newrevid, new_parents, revid_renames, fix_revid) rebase(repository, plan, replay) return revid_renames finally: repository.unlock() foreign_repository.unlock()