/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to upgrade.py

  • Committer: Jelmer Vernooij
  • Date: 2009-02-08 19:20:14 UTC
  • mto: (0.436.139 foreign)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20090208192014-0g17picqdx7edl92
Import foreign-mapping-upgrade command, fixes for bzr-svn.

Show diffs side-by-side

added added

removed removed

Lines of Context:
upgrade.py
121
121
    wt.set_last_revision(new_inv.revision_id)
122
122
 
123
123
 
124
 
def upgrade_workingtree(wt, foreign_repository, new_mapping, mapping_registry, 
 
124
def upgrade_workingtree(wt, foreign_repository, new_mapping, 
125
125
                        allow_changes=False, verbose=False):
126
126
    """Upgrade a working tree.
127
127
 
131
131
    try:
132
132
        old_revid = wt.last_revision()
133
133
        revid_renames = upgrade_branch(wt.branch, foreign_repository, new_mapping=new_mapping,
134
 
                                 mapping_registry=mapping_registry,
135
134
                                 allow_changes=allow_changes, verbose=verbose)
136
135
        last_revid = wt.branch.last_revision()
137
136
        if old_revid == last_revid:
145
144
    return revid_renames
146
145
 
147
146
 
148
 
def upgrade_tags(tags, repository, foreign_repository, new_mapping, mapping_registry, 
 
147
def upgrade_tags(tags, repository, foreign_repository, new_mapping, 
149
148
                 allow_changes=False, verbose=False, branch_renames=None):
150
149
    """Upgrade a tags dictionary."""
151
150
    renames = {}
159
158
            if not revid in renames:
160
159
                renames.update(upgrade_repository(repository, foreign_repository, 
161
160
                      revision_id=revid, new_mapping=new_mapping,
162
 
                      mapping_registry=mapping_registry,
163
161
                      allow_changes=allow_changes, verbose=verbose))
164
162
            if revid in renames:
165
163
                tags.set_tag(name, renames[revid])
168
166
 
169
167
 
170
168
def upgrade_branch(branch, foreign_repository, new_mapping, 
171
 
                   mapping_registry, allow_changes=False, verbose=False):
 
169
                   allow_changes=False, verbose=False):
172
170
    """Upgrade a branch to the current mapping version.
173
171
    
174
172
    :param branch: Branch to upgrade.
179
177
    revid = branch.last_revision()
180
178
    renames = upgrade_repository(branch.repository, foreign_repository, 
181
179
              revision_id=revid, new_mapping=new_mapping,
182
 
              mapping_registry=mapping_registry,
183
180
              allow_changes=allow_changes, verbose=verbose)
184
181
    upgrade_tags(branch.tags, branch.repository, foreign_repository, 
185
 
           new_mapping=new_mapping, mapping_registry=mapping_registry, 
 
182
           new_mapping=new_mapping, 
186
183
           allow_changes=allow_changes, verbose=verbose, branch_renames=renames)
187
 
    if len(renames) > 0:
 
184
    if revid in renames:
188
185
        branch.generate_revision_history(renames[revid])
189
186
    return renames
190
187
 
201
198
        raise UpgradeChangesContent(oldrev.revision_id)
202
199
 
203
200
 
204
 
def generate_upgrade_map(revs, mapping_registry, determine_upgraded_revid):
 
201
def generate_upgrade_map(revs, vcs, determine_upgraded_revid):
205
202
    """Generate an upgrade map for use by bzr-rebase.
206
203
 
207
204
    :param new_mapping: Mapping to upgrade revisions to.
 
205
    :param vcs: The foreign vcs
208
206
    :param revs: Iterator over revisions to upgrade.
209
207
    :return: Map from old revids as keys, new revids as values stored in a 
210
208
             dictionary.
214
212
    for revid in revs:
215
213
        assert isinstance(revid, str)
216
214
        try:
217
 
            (foreign_revid, old_mapping) = mapping_registry.parse_revision_id(revid)
 
215
            (foreign_revid, old_mapping) = vcs.mapping_registry.parse_revision_id(revid)
218
216
        except InvalidRevisionId:
219
217
            # Not a foreign revision, nothing to do
220
218
            continue
227
225
MIN_REBASE_VERSION = (0, 4, 3)
228
226
 
229
227
def create_upgrade_plan(repository, foreign_repository, new_mapping,
230
 
                        mapping_registry, revision_id=None, allow_changes=False):
 
228
                        revision_id=None, allow_changes=False):
231
229
    """Generate a rebase plan for upgrading revisions.
232
230
 
233
231
    :param repository: Repository to do upgrade in
251
249
 
252
250
    def determine_upgraded_revid(foreign_revid):
253
251
        # FIXME: Try all mappings until new_mapping rather than just new_mapping
254
 
        new_revid = new_mapping.revision_id_foreign_to_bzr(foreign_revid)
 
252
        new_revid = foreign_repository.upgrade_foreign_revision_id(foreign_revid, new_mapping)
 
253
        if new_revid is None:
 
254
            return None
255
255
        # Make sure the revision is there
256
256
        if not repository.has_revision(new_revid):
257
257
            try:
258
258
                repository.fetch(foreign_repository, new_revid)
259
259
            except NoSuchRevision:
260
260
                return None
 
261
            if not repository.has_revision(new_revid):
 
262
                return None
261
263
        return new_revid
262
264
 
263
 
    upgrade_map = generate_upgrade_map(potential, mapping_registry, determine_upgraded_revid)
 
265
    upgrade_map = generate_upgrade_map(potential, foreign_repository.vcs, 
 
266
                                       determine_upgraded_revid)
264
267
   
265
268
    if not allow_changes:
266
269
        for oldrevid, newrevid in upgrade_map.iteritems():
273
276
    else:
274
277
        heads = [revision_id]
275
278
 
 
279
    def determine_new_revid(old_revid):
 
280
        # If this revision id already exists round-tripped upstream, 
 
281
        # leave it alone.
 
282
        if foreign_repository.has_revision(old_revid):
 
283
            return old_revid
 
284
        # if not, return old_revid'
 
285
        return create_upgraded_revid(old_revid, new_mapping.upgrade_suffix)
 
286
 
276
287
    plan = generate_transpose_plan(graph.iter_ancestry(heads), upgrade_map, 
277
 
      graph, lambda revid: create_upgraded_revid(revid, new_mapping.upgrade_suffix))
 
288
      graph, determine_new_revid)
278
289
    def remove_parents((oldrevid, (newrevid, parents))):
279
290
        return (oldrevid, newrevid)
280
291
    upgrade_map.update(dict(map(remove_parents, plan.iteritems())))
283
294
 
284
295
 
285
296
def upgrade_repository(repository, foreign_repository, new_mapping, 
286
 
                       mapping_registry, revision_id=None, allow_changes=False, 
 
297
                       revision_id=None, allow_changes=False, 
287
298
                       verbose=False):
288
299
    """Upgrade the revisions in repository until the specified stop revision.
289
300
 
306
317
        repository.lock_write()
307
318
        foreign_repository.lock_read()
308
319
        (plan, revid_renames) = create_upgrade_plan(repository, foreign_repository, 
309
 
                                                    new_mapping, mapping_registry,
 
320
                                                    new_mapping, 
310
321
                                                    revision_id=revision_id,
311
322
                                                    allow_changes=allow_changes)
312
323
        if verbose: