1
# Copyright (C) 2006-2009 by Jelmer Vernooij
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 3 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
"""Upgrading revisions made with older versions of the mapping."""
22
from bzrlib.errors import (
31
class RebaseNotPresent(DependencyNotPresent):
32
_fmt = "Unable to import bzr-rebase (required for upgrade support): %(error)s"
34
def __init__(self, error):
35
DependencyNotPresent.__init__(self, 'bzr-rebase', error)
38
def check_rebase_version(min_version):
39
"""Check what version of bzr-rebase is installed.
41
Raises an exception when the version installed is older than
44
:raises RebaseNotPresent: Raised if bzr-rebase is not installed or too old.
47
from bzrlib.plugins.rebase import version_info as rebase_version_info
48
if rebase_version_info[:len(min_version)] < min_version:
49
raise RebaseNotPresent("Version %r present, at least %r required"
50
% (rebase_version_info, min_version))
51
except ImportError, e:
52
raise RebaseNotPresent(e)
56
class UpgradeChangesContent(BzrError):
57
"""Inconsistency was found upgrading the mapping of a revision."""
58
_fmt = """Upgrade will change contents in revision %(revid)s. Use --allow-changes to override."""
60
def __init__(self, revid):
65
def create_upgraded_revid(revid, mapping_suffix, upgrade_suffix="-upgrade"):
66
"""Create a new revision id for an upgraded version of a revision.
68
Prevents suffix to be appended needlessly.
70
:param revid: Original revision id.
71
:return: New revision id
73
if revid.endswith(upgrade_suffix):
74
return revid[0:revid.rfind("-svn")] + mapping_suffix + upgrade_suffix
76
return revid + mapping_suffix + upgrade_suffix
79
def determine_fileid_renames(old_inv, new_inv):
80
"""Determine the file ids based on a old and a new inventory that
83
:param old_inv: Old inventory
84
:param new_inv: New inventory
85
:return: Dictionary a (old_id, new_id) tuple for each path in the
89
if len(old_inv) != len(new_inv):
90
raise AssertionError("Inventories are not of the same size")
91
for old_file_id in old_inv:
92
new_file_id = new_inv.path2id(old_inv.id2path(old_file_id))
93
if new_file_id is None:
95
"Unable to find %s in new inventory" % old_file_id)
96
ret[new_inv.id2path(new_file_id)] = (old_file_id, new_file_id)
100
def update_workinginv_fileids(wt, old_inv, new_inv):
101
"""Update all file ids in wt according to old_tree/new_tree.
103
old_tree and new_tree should be two RevisionTree's that differ only
106
fileid_renames = determine_fileid_renames(old_inv, new_inv)
110
# Adjust file ids in working tree
111
# Sorted, so we process parents before children
112
for path in sorted(fileid_renames.keys()):
114
old_fileids.append(fileid_renames[path][0])
115
new_fileids.append((path, fileid_renames[path][1]))
117
new_root_id = fileid_renames[path][1]
118
new_fileids.reverse()
119
wt.unversion(old_fileids)
120
if new_root_id is not None:
121
wt.set_root_id(new_root_id)
122
wt.add([x[0] for x in new_fileids], [x[1] for x in new_fileids])
123
wt.set_last_revision(new_inv.revision_id)
126
def upgrade_workingtree(wt, foreign_repository, new_mapping,
127
allow_changes=False, verbose=False):
128
"""Upgrade a working tree.
130
:param foreign_repository: Foreign repository object
134
old_revid = wt.last_revision()
135
revid_renames = upgrade_branch(wt.branch, foreign_repository, new_mapping=new_mapping,
136
allow_changes=allow_changes, verbose=verbose)
137
last_revid = wt.branch.last_revision()
138
if old_revid == last_revid:
140
old_inv = wt.branch.repository.get_inventory(old_revid)
141
new_inv = wt.branch.repository.get_inventory(last_revid)
142
update_workinginv_fileids(wt, old_inv, new_inv)
149
def upgrade_tags(tags, repository, foreign_repository, new_mapping,
150
allow_changes=False, verbose=False, branch_renames=None,
151
branch_ancestry=None):
152
"""Upgrade a tags dictionary."""
154
if branch_renames is not None:
155
renames.update(branch_renames)
156
pb = ui.ui_factory.nested_progress_bar()
158
tags_dict = tags.get_tag_dict()
159
for i, (name, revid) in enumerate(tags_dict.items()):
160
pb.update("upgrading tags", i, len(tags_dict))
161
if not revid in renames:
162
renames.update(upgrade_repository(repository, foreign_repository,
163
revision_id=revid, new_mapping=new_mapping,
164
allow_changes=allow_changes, verbose=verbose))
165
if revid in renames and (branch_ancestry is None or not revid in branch_ancestry):
166
tags.set_tag(name, renames[revid])
171
def upgrade_branch(branch, foreign_repository, new_mapping,
172
allow_changes=False, verbose=False):
173
"""Upgrade a branch to the current mapping version.
175
:param branch: Branch to upgrade.
176
:param foreign_repository: Repository to fetch new revisions from
177
:param allow_changes: Allow changes in mappings.
178
:param verbose: Whether to print verbose list of rewrites
180
revid = branch.last_revision()
181
renames = upgrade_repository(branch.repository, foreign_repository,
182
revision_id=revid, new_mapping=new_mapping,
183
allow_changes=allow_changes, verbose=verbose)
185
branch.generate_revision_history(renames[revid])
186
ancestry = branch.repository.get_ancestry(branch.last_revision(), topo_sorted=False)
187
upgrade_tags(branch.tags, branch.repository, foreign_repository,
188
new_mapping=new_mapping,
189
allow_changes=allow_changes, verbose=verbose, branch_renames=renames,
190
branch_ancestry=ancestry)
194
def check_revision_changed(oldrev, newrev):
195
"""Check if two revisions are different. This is exactly the same
196
as Revision.equals() except that it does not check the revision_id."""
197
if (newrev.inventory_sha1 != oldrev.inventory_sha1 or
198
newrev.timestamp != oldrev.timestamp or
199
newrev.message != oldrev.message or
200
newrev.timezone != oldrev.timezone or
201
newrev.committer != oldrev.committer or
202
newrev.properties != oldrev.properties):
203
raise UpgradeChangesContent(oldrev.revision_id)
206
def generate_upgrade_map(revs, vcs, determine_upgraded_revid):
207
"""Generate an upgrade map for use by bzr-rebase.
209
:param new_mapping: Mapping to upgrade revisions to.
210
:param vcs: The foreign vcs
211
:param revs: Iterator over revisions to upgrade.
212
:return: Map from old revids as keys, new revids as values stored in a
216
# Create a list of revisions that can be renamed during the upgrade
218
assert isinstance(revid, str)
220
(foreign_revid, old_mapping) = vcs.mapping_registry.parse_revision_id(revid)
221
except InvalidRevisionId:
222
# Not a foreign revision, nothing to do
224
newrevid = determine_upgraded_revid(foreign_revid)
225
if newrevid in (revid, None):
227
rename_map[revid] = newrevid
230
MIN_REBASE_VERSION = (0, 4, 3)
232
def create_upgrade_plan(repository, foreign_repository, new_mapping,
233
revision_id=None, allow_changes=False):
234
"""Generate a rebase plan for upgrading revisions.
236
:param repository: Repository to do upgrade in
237
:param foreign_repository: Subversion repository to fetch new revisions from.
238
:param new_mapping: New mapping to use.
239
:param revision_id: Revision to upgrade (None for all revisions in
241
:param allow_changes: Whether an upgrade is allowed to change the contents
243
:return: Tuple with a rebase plan and map of renamed revisions.
245
from bzrlib.plugins.rebase.rebase import generate_transpose_plan
246
check_rebase_version(MIN_REBASE_VERSION)
248
graph = repository.get_graph()
249
if revision_id is None:
250
potential = repository.all_revision_ids()
252
potential = itertools.imap(lambda (rev, parents): rev,
253
graph.iter_ancestry([revision_id]))
255
def determine_upgraded_revid(foreign_revid):
256
# FIXME: Try all mappings until new_mapping rather than just new_mapping
257
new_revid = foreign_repository.upgrade_foreign_revision_id(foreign_revid, new_mapping)
258
if new_revid is None:
260
# Make sure the revision is there
261
if not repository.has_revision(new_revid):
263
repository.fetch(foreign_repository, new_revid)
264
except NoSuchRevision:
266
if not repository.has_revision(new_revid):
270
upgrade_map = generate_upgrade_map(potential, foreign_repository.vcs,
271
determine_upgraded_revid)
273
if not allow_changes:
274
for oldrevid, newrevid in upgrade_map.iteritems():
275
oldrev = repository.get_revision(oldrevid)
276
newrev = repository.get_revision(newrevid)
277
check_revision_changed(oldrev, newrev)
279
if revision_id is None:
280
heads = repository.all_revision_ids()
282
heads = [revision_id]
284
def determine_new_revid(old_revid):
285
# If this revision id already exists round-tripped upstream,
287
if foreign_repository.has_revision(old_revid):
289
# if not, return old_revid'
290
return create_upgraded_revid(old_revid, new_mapping.upgrade_suffix)
292
plan = generate_transpose_plan(graph.iter_ancestry(heads), upgrade_map,
293
graph, determine_new_revid)
294
def remove_parents((oldrevid, (newrevid, parents))):
295
return (oldrevid, newrevid)
296
upgrade_map.update(dict(map(remove_parents, plan.iteritems())))
298
return (plan, upgrade_map)
301
def upgrade_repository(repository, foreign_repository, new_mapping,
302
revision_id=None, allow_changes=False,
304
"""Upgrade the revisions in repository until the specified stop revision.
306
:param repository: Repository in which to upgrade.
307
:param foreign_repository: Repository to fetch new revisions from.
308
:param new_mapping: New mapping.
309
:param revision_id: Revision id up until which to upgrade, or None for
311
:param allow_changes: Allow changes to mappings.
312
:param verbose: Whether to print list of rewrites
313
:return: Dictionary of mapped revisions
315
check_rebase_version(MIN_REBASE_VERSION)
316
from bzrlib.plugins.rebase.rebase import (
317
replay_snapshot, rebase, rebase_todo)
319
# Find revisions that need to be upgraded, create
320
# dictionary with revision ids in key, new parents in value
322
repository.lock_write()
323
foreign_repository.lock_read()
324
(plan, revid_renames) = create_upgrade_plan(repository, foreign_repository,
326
revision_id=revision_id,
327
allow_changes=allow_changes)
329
for revid in rebase_todo(repository, plan):
330
trace.info("%s -> %s" % (revid, plan[revid][0]))
331
rebase(repository, plan, replay_snapshot)
335
foreign_repository.unlock()
added
removed
upgrade.py
