# Copyright (C) 2006-2009 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 ( DependencyNotPresent, BzrError, InvalidRevisionId, NoSuchRevision, ) 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[:len(min_version)] < 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_inv, new_inv): """Determine the file ids based on a old and a new inventory that are equal in content. :param old_inv: Old inventory :param new_inv: New inventory :return: Dictionary a (old_id, new_id) tuple for each path in the inventories. """ ret = {} if len(old_inv) != len(new_inv): raise AssertionError("Inventories are not of the same size") for old_file_id in old_inv: new_file_id = new_inv.path2id(old_inv.id2path(old_file_id)) if new_file_id is None: raise AssertionError( "Unable to find %s in new inventory" % old_file_id) ret[new_inv.id2path(new_file_id)] = (old_file_id, new_file_id) return ret def update_workinginv_fileids(wt, old_inv, new_inv): """Update all file ids in wt according to old_tree/new_tree. old_tree and new_tree should be two RevisionTree's that differ only in file ids. """ fileid_renames = determine_fileid_renames(old_inv, new_inv) old_fileids = [] new_fileids = [] new_root_id = None # Adjust file ids in working tree # Sorted, so we process parents before children for path in sorted(fileid_renames.keys()): 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(new_inv.revision_id) def upgrade_workingtree(wt, foreign_repository, new_mapping, 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, allow_changes=allow_changes, verbose=verbose) last_revid = wt.branch.last_revision() if old_revid == last_revid: return revid_renames old_inv = wt.branch.repository.get_inventory(old_revid) new_inv = wt.branch.repository.get_inventory(last_revid) update_workinginv_fileids(wt, old_inv, new_inv) finally: wt.unlock() return revid_renames def upgrade_tags(tags, repository, foreign_repository, new_mapping, allow_changes=False, verbose=False, branch_renames=None, branch_ancestry=None): """Upgrade a tags dictionary.""" renames = {} if branch_renames is not None: renames.update(branch_renames) 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 not revid in renames: renames.update(upgrade_repository(repository, foreign_repository, revision_id=revid, new_mapping=new_mapping, allow_changes=allow_changes, verbose=verbose)) if revid in renames and (branch_ancestry is None or not revid in branch_ancestry): tags.set_tag(name, renames[revid]) finally: pb.finished() def upgrade_branch(branch, foreign_repository, new_mapping, 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, allow_changes=allow_changes, verbose=verbose) if revid in renames: branch.generate_revision_history(renames[revid]) ancestry = branch.repository.get_ancestry(branch.last_revision(), topo_sorted=False) upgrade_tags(branch.tags, branch.repository, foreign_repository, new_mapping=new_mapping, allow_changes=allow_changes, verbose=verbose, branch_renames=renames, branch_ancestry=ancestry) 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(revs, vcs, determine_upgraded_revid): """Generate an upgrade map for use by bzr-rebase. :param new_mapping: Mapping to upgrade revisions to. :param vcs: The foreign vcs :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, old_mapping) = vcs.mapping_registry.parse_revision_id(revid) except InvalidRevisionId: # Not a foreign revision, nothing to do continue newrevid = determine_upgraded_revid(foreign_revid) if newrevid in (revid, None): continue rename_map[revid] = newrevid return rename_map MIN_REBASE_VERSION = (0, 4, 3) def create_upgrade_plan(repository, foreign_repository, new_mapping, 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])) def determine_upgraded_revid(foreign_revid): # FIXME: Try all mappings until new_mapping rather than just new_mapping new_revid = foreign_repository.upgrade_foreign_revision_id(foreign_revid, new_mapping) if new_revid is None: return None # Make sure the revision is there if not repository.has_revision(new_revid): try: repository.fetch(foreign_repository, new_revid) except NoSuchRevision: return None if not repository.has_revision(new_revid): return None return new_revid upgrade_map = generate_upgrade_map(potential, foreign_repository.vcs, determine_upgraded_revid) if not allow_changes: for oldrevid, newrevid in upgrade_map.iteritems(): 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] def determine_new_revid(old_revid): # If this revision id already exists round-tripped upstream, # leave it alone. if foreign_repository.has_revision(old_revid): return old_revid # if not, return old_revid' return create_upgraded_revid(old_revid, new_mapping.upgrade_suffix) plan = generate_transpose_plan(graph.iter_ancestry(heads), upgrade_map, graph, determine_new_revid) def remove_parents((oldrevid, (newrevid, parents))): return (oldrevid, newrevid) upgrade_map.update(dict(map(remove_parents, plan.iteritems()))) return (plan, upgrade_map) def upgrade_repository(repository, foreign_repository, new_mapping, 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, revision_id=revision_id, allow_changes=allow_changes) if verbose: for revid in rebase_todo(repository, plan): info("%s -> %s" % (revid, plan[revid][0])) rebase(repository, plan, replay_snapshot) return revid_renames finally: repository.unlock() foreign_repository.unlock()