← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-31 16:12:57 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060731161257-91a231523255332c
new official bzr.ico

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
35
35
import bzrlib.errors as errors
36
36
from bzrlib.errors import (InstallFailed,
37
37
                           )
 
38
from bzrlib.trace import mutter
38
39
from bzrlib.progress import ProgressPhase
39
40
from bzrlib.revision import NULL_REVISION
40
41
from bzrlib.symbol_versioning import (deprecated_function,
41
42
        deprecated_method,
42
43
        zero_eight,
43
44
        )
44
 
from bzrlib.trace import mutter
45
 
import bzrlib.ui
46
45
 
47
 
from bzrlib.lazy_import import lazy_import
48
46
 
49
47
# TODO: Avoid repeatedly opening weaves so many times.
50
48
 
92
90
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
93
91
            # check that last_revision is in 'from' and then return a no-operation.
94
92
            if last_revision not in (None, NULL_REVISION):
95
 
                to_repository.get_revision(last_revision)
 
93
                from_repository.get_revision(last_revision)
96
94
            return
97
95
        self.to_repository = to_repository
98
96
        self.from_repository = from_repository
149
147
        if self._last_revision is NULL_REVISION:
150
148
            # explicit limit of no revisions needed
151
149
            return None
152
 
        if (self._last_revision is not None and
 
150
        if (self._last_revision != None and
153
151
            self.to_repository.has_revision(self._last_revision)):
154
152
            return None
155
153
            
283
281
        to_rf.join(from_rf, version_ids=revs)
284
282
 
285
283
 
286
 
class Inter1and2Helper(object):
287
 
    """Helper for operations that convert data from model 1 and 2
288
 
    
289
 
    This is for use by fetchers and converters.
290
 
    """
291
 
 
292
 
    def __init__(self, source, target):
293
 
        """Constructor.
294
 
 
295
 
        :param source: The repository data comes from
296
 
        :param target: The repository data goes to
297
 
        """
298
 
        self.source = source
299
 
        self.target = target
300
 
 
301
 
    def iter_rev_trees(self, revs):
302
 
        """Iterate through RevisionTrees efficiently.
303
 
 
304
 
        Additionally, the inventory's revision_id is set if unset.
305
 
 
306
 
        Trees are retrieved in batches of 100, and then yielded in the order
307
 
        they were requested.
308
 
 
309
 
        :param revs: A list of revision ids
310
 
        """
311
 
        while revs:
312
 
            for tree in self.source.revision_trees(revs[:100]):
313
 
                if tree.inventory.revision_id is None:
314
 
                    tree.inventory.revision_id = tree.get_revision_id()
315
 
                yield tree
316
 
            revs = revs[100:]
317
 
 
318
 
    def generate_root_texts(self, revs):
319
 
        """Generate VersionedFiles for all root ids.
320
 
        
321
 
        :param revs: the revisions to include
322
 
        """
323
 
        inventory_weave = self.source.get_inventory_weave()
324
 
        parent_texts = {}
325
 
        versionedfile = {}
326
 
        to_store = self.target.weave_store
327
 
        for tree in self.iter_rev_trees(revs):
328
 
            revision_id = tree.inventory.root.revision
329
 
            root_id = tree.inventory.root.file_id
330
 
            parents = inventory_weave.get_parents(revision_id)
331
 
            if root_id not in versionedfile:
332
 
                versionedfile[root_id] = to_store.get_weave_or_empty(root_id, 
333
 
                    self.target.get_transaction())
334
 
            parent_texts[root_id] = versionedfile[root_id].add_lines(
335
 
                revision_id, parents, [], parent_texts)
336
 
 
337
 
    def regenerate_inventory(self, revs):
338
 
        """Generate a new inventory versionedfile in target, convertin data.
339
 
        
340
 
        The inventory is retrieved from the source, (deserializing it), and
341
 
        stored in the target (reserializing it in a different format).
342
 
        :param revs: The revisions to include
343
 
        """
344
 
        inventory_weave = self.source.get_inventory_weave()
345
 
        for tree in self.iter_rev_trees(revs):
346
 
            parents = inventory_weave.get_parents(tree.get_revision_id())
347
 
            self.target.add_inventory(tree.get_revision_id(), tree.inventory,
348
 
                                      parents)
349
 
 
350
 
 
351
 
class Model1toKnit2Fetcher(GenericRepoFetcher):
352
 
    """Fetch from a Model1 repository into a Knit2 repository
353
 
    """
354
 
    def __init__(self, to_repository, from_repository, last_revision=None, 
355
 
                 pb=None):
356
 
        self.helper = Inter1and2Helper(from_repository, to_repository)
357
 
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
358
 
                                    last_revision, pb)
359
 
 
360
 
    def _fetch_weave_texts(self, revs):
361
 
        GenericRepoFetcher._fetch_weave_texts(self, revs)
362
 
        # Now generate a weave for the tree root
363
 
        self.helper.generate_root_texts(revs)
364
 
 
365
 
    def _fetch_inventory_weave(self, revs):
366
 
        self.helper.regenerate_inventory(revs)
367
 
 
368
 
 
369
 
class Knit1to2Fetcher(KnitRepoFetcher):
370
 
    """Fetch from a Knit1 repository into a Knit2 repository"""
371
 
 
372
 
    def __init__(self, to_repository, from_repository, last_revision=None, 
373
 
                 pb=None):
374
 
        self.helper = Inter1and2Helper(from_repository, to_repository)
375
 
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
376
 
                                 last_revision, pb)
377
 
 
378
 
    def _fetch_weave_texts(self, revs):
379
 
        KnitRepoFetcher._fetch_weave_texts(self, revs)
380
 
        # Now generate a weave for the tree root
381
 
        self.helper.generate_root_texts(revs)
382
 
 
383
 
    def _fetch_inventory_weave(self, revs):
384
 
        self.helper.regenerate_inventory(revs)
385
 
        
386
 
 
387
284
class Fetcher(object):
388
285
    """Backwards compatibility glue for branch.fetch()."""
389
286