/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 bzrlib/fetch.py

  • Committer: Aaron Bentley
  • Date: 2006-09-10 02:18:31 UTC
  • mto: This revision was merged to the branch mainline in revision 1997.
  • Revision ID: aaron.bentley@utoronto.ca-20060910021831-51f5888a7e62a02d
Update from review comments

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
282
282
 
283
283
 
284
284
class Inter1and2Helper(object):
285
 
 
286
 
    def iter_rev_trees(self, revs, source):
287
 
        while len(revs):
288
 
            for tree in source.revision_trees(revs[:500]):
 
285
    """Helper for operations that convert data from model 1 and 2
 
286
    
 
287
    This is for use by fetchers and converters.
 
288
    """
 
289
 
 
290
    def __init__(self, source, target):
 
291
        """Constructor.
 
292
 
 
293
        :param source: The repository data comes from
 
294
        :param target: The repository data goes to
 
295
        """
 
296
        self.source = source
 
297
        self.target = target
 
298
 
 
299
    def iter_rev_trees(self, revs):
 
300
        """Iterate through RevisionTrees efficiently.
 
301
 
 
302
        Additionally, the inventory's revision_id is set if unset.
 
303
 
 
304
        Trees are retrieved in batches of 100, and then yielded in the order
 
305
        they were requested.
 
306
 
 
307
        :param revs: A list of revision ids
 
308
        """
 
309
        while revs:
 
310
            for tree in self.source.revision_trees(revs[:100]):
289
311
                if tree.inventory.revision_id is None:
290
312
                    tree.inventory.revision_id = tree.get_revision_id()
291
313
                yield tree
292
 
            revs = revs[500:]
 
314
            revs = revs[100:]
293
315
 
294
 
    def generate_root_texts(self, fetcher, revs):
295
 
        inventory_weave = fetcher.from_repository.get_inventory_weave()
296
 
        for tree in self.iter_rev_trees(revs, fetcher.from_repository):
297
 
            parent_texts = {}
 
316
    def generate_root_texts(self, revs):
 
317
        """Generate VersionedFiles for all root ids.
 
318
        
 
319
        :param revs: the revisions to include
 
320
        """
 
321
        inventory_weave = self.source.get_inventory_weave()
 
322
        parent_texts = {}
 
323
        versionedfile = {}
 
324
        to_store = self.target.weave_store
 
325
        for tree in self.iter_rev_trees(revs):
298
326
            revision_id = tree.inventory.root.revision
 
327
            root_id = tree.inventory.root.file_id
299
328
            parents = inventory_weave.get_parents(revision_id)
300
 
            to_store = fetcher.to_repository.weave_store
301
 
            versionedfile = to_store.get_weave_or_empty(
302
 
                tree.inventory.root.file_id, 
303
 
                fetcher.to_repository.get_transaction())
304
 
            parent_texts = versionedfile.add_lines(revision_id, parents, [], 
305
 
                                                   parent_texts)
306
 
        versionedfile.clear_cache()
307
 
 
308
 
 
309
 
    def regenerate_inventory(self, fetcher, revs):
310
 
        inventory_weave = fetcher.from_repository.get_inventory_weave()
311
 
        for tree in self.iter_rev_trees(revs, fetcher.from_repository):
 
329
            if root_id not in versionedfile:
 
330
                versionedfile[root_id] = to_store.get_weave_or_empty(root_id, 
 
331
                    self.target.get_transaction())
 
332
            parent_texts[root_id] = versionedfile[root_id].add_lines(
 
333
                revision_id, parents, [], parent_texts)
 
334
 
 
335
    def regenerate_inventory(self, revs):
 
336
        """Generate a new inventory versionedfile in target, convertin data.
 
337
        
 
338
        The inventory is retrieved from the source, (deserializing it), and
 
339
        stored in the target (reserializing it in a different format).
 
340
        :param revs: The revisions to include
 
341
        """
 
342
        inventory_weave = self.source.get_inventory_weave()
 
343
        for tree in self.iter_rev_trees(revs):
312
344
            parents = inventory_weave.get_parents(tree.get_revision_id())
313
 
            if tree.inventory.revision_id is None:
314
 
                tree.inventory.revision_id = tree.get_revision_id()
315
 
            fetcher.to_repository.add_inventory(tree.get_revision_id(),
316
 
                                                tree.inventory, parents)
 
345
            self.target.add_inventory(tree.get_revision_id(), tree.inventory,
 
346
                                      parents)
317
347
 
318
348
 
319
349
class Model1toKnit2Fetcher(GenericRepoFetcher):
320
350
    """Fetch from a Model1 repository into a Knit2 repository
321
351
    """
 
352
    def __init__(self, to_repository, from_repository, last_revision=None, 
 
353
                 pb=None):
 
354
        self.helper = Inter1and2Helper(from_repository, to_repository)
 
355
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
 
356
                                    last_revision, pb)
322
357
 
323
358
    def _fetch_weave_texts(self, revs):
324
359
        GenericRepoFetcher._fetch_weave_texts(self, revs)
325
360
        # Now generate a weave for the tree root
326
 
        Inter1and2Helper().generate_root_texts(self, revs)
 
361
        self.helper.generate_root_texts(revs)
327
362
 
328
363
    def _fetch_inventory_weave(self, revs):
329
 
        Inter1and2Helper().regenerate_inventory(self, revs)
 
364
        self.helper.regenerate_inventory(revs)
330
365
 
331
366
 
332
367
class Knit1to2Fetcher(KnitRepoFetcher):
333
368
    """Fetch from a Knit1 repository into a Knit2 repository"""
334
369
 
 
370
    def __init__(self, to_repository, from_repository, last_revision=None, 
 
371
                 pb=None):
 
372
        self.helper = Inter1and2Helper(from_repository, to_repository)
 
373
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
 
374
                                 last_revision, pb)
 
375
 
335
376
    def _fetch_weave_texts(self, revs):
336
377
        KnitRepoFetcher._fetch_weave_texts(self, revs)
337
378
        # Now generate a weave for the tree root
338
 
        Inter1and2Helper().generate_root_texts(self, revs)
 
379
        self.helper.generate_root_texts(revs)
339
380
 
340
381
    def _fetch_inventory_weave(self, revs):
341
 
        Inter1and2Helper().regenerate_inventory(self, revs)
 
382
        self.helper.regenerate_inventory(revs)
342
383
        
343
384
 
344
385
class Fetcher(object):