← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2007-08-22 01:41:24 UTC
  • mfrom: (2740 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2741.
  • Revision ID: robertc@robertcollins.net-20070822014124-wiinlne4nin2f2tm
Merge bzr.dev to resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
36
36
from bzrlib.errors import (InstallFailed,
37
37
                           )
38
38
from bzrlib.progress import ProgressPhase
39
 
from bzrlib.revision import NULL_REVISION
 
39
from bzrlib.revision import is_null, NULL_REVISION
40
40
from bzrlib.symbol_versioning import (deprecated_function,
41
41
        deprecated_method,
42
 
        zero_eight,
43
42
        )
44
43
from bzrlib.trace import mutter
45
44
import bzrlib.ui
64
63
#   and add in all file versions
65
64
 
66
65
 
67
 
@deprecated_function(zero_eight)
68
 
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
69
 
    """Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
70
 
    f = Fetcher(to_branch, from_branch, revision, pb)
71
 
    return f.count_copied, f.failed_revisions
72
 
 
73
 
fetch = greedy_fetch
74
 
 
75
 
 
76
66
class RepoFetcher(object):
77
67
    """Pull revisions and texts from one repository to another.
78
68
 
89
79
        # result variables.
90
80
        self.failed_revisions = []
91
81
        self.count_copied = 0
92
 
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
93
 
            # check that last_revision is in 'from' and then return a no-operation.
94
 
            if last_revision not in (None, NULL_REVISION):
 
82
        if to_repository.has_same_location(from_repository):
 
83
            # check that last_revision is in 'from' and then return a
 
84
            # no-operation.
 
85
            if last_revision is not None and not is_null(last_revision):
95
86
                to_repository.get_revision(last_revision)
96
87
            return
97
88
        self.to_repository = to_repository
139
130
        try:
140
131
            pp.next_phase()
141
132
            revs = self._revids_to_fetch()
142
 
            # something to do ?
143
 
            if revs:
144
 
                pp.next_phase()
145
 
                self._fetch_weave_texts(revs)
146
 
                pp.next_phase()
147
 
                self._fetch_inventory_weave(revs)
148
 
                pp.next_phase()
149
 
                self._fetch_revision_texts(revs)
150
 
                self.count_copied += len(revs)
 
133
            self._fetch_everything_for_revisions(revs, pp)
151
134
        finally:
152
135
            self.pb.clear()
153
136
 
 
137
    def _fetch_everything_for_revisions(self, revs, pp):
 
138
        """Fetch all data for the given set of revisions."""
 
139
        if revs is None:
 
140
            return
 
141
        # The first phase is "file".  We pass the progress bar for it directly
 
142
        # into item_keys_introduced_by, which has more information about how
 
143
        # that phase is progressing than we do.  Progress updates for the other
 
144
        # phases are taken care of in this function.
 
145
        # XXX: there should be a clear owner of the progress reporting.  Perhaps
 
146
        # item_keys_introduced_by should have a richer API than it does at the
 
147
        # moment, so that it can feed the progress information back to this
 
148
        # function?
 
149
        phase = 'file'
 
150
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
151
        try:
 
152
            data_to_fetch = self.from_repository.item_keys_introduced_by(revs, pb)
 
153
            for knit_kind, file_id, revisions in data_to_fetch:
 
154
                if knit_kind != phase:
 
155
                    phase = knit_kind
 
156
                    # Make a new progress bar for this phase
 
157
                    pb.finished()
 
158
                    pp.next_phase()
 
159
                    pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
160
                if knit_kind == "file":
 
161
                    self._fetch_weave_text(file_id, revisions)
 
162
                elif knit_kind == "inventory":
 
163
                    # XXX:
 
164
                    # Once we've processed all the files, then we generate the root
 
165
                    # texts (if necessary), then we process the inventory.  It's a
 
166
                    # bit distasteful to have knit_kind == "inventory" mean this,
 
167
                    # perhaps it should happen on the first non-"file" knit, in case
 
168
                    # it's not always inventory?
 
169
                    self._generate_root_texts(revs)
 
170
                    self._fetch_inventory_weave(revs, pb)
 
171
                elif knit_kind == "signatures":
 
172
                    # Nothing to do here; this will be taken care of when
 
173
                    # _fetch_revision_texts happens.
 
174
                    pass
 
175
                elif knit_kind == "revisions":
 
176
                    self._fetch_revision_texts(revs, pb)
 
177
                else:
 
178
                    raise AssertionError("Unknown knit kind %r" % knit_kind)
 
179
        finally:
 
180
            if pb is not None:
 
181
                pb.finished()
 
182
        self.count_copied += len(revs)
 
183
        
154
184
    def _revids_to_fetch(self):
 
185
        """Determines the exact revisions needed from self.from_repository to
 
186
        install self._last_revision in self.to_repository.
 
187
 
 
188
        If no revisions need to be fetched, then this just returns None.
 
189
        """
155
190
        mutter('fetch up to rev {%s}', self._last_revision)
156
191
        if self._last_revision is NULL_REVISION:
157
192
            # explicit limit of no revisions needed
166
201
        except errors.NoSuchRevision:
167
202
            raise InstallFailed([self._last_revision])
168
203
 
169
 
    def _fetch_weave_texts(self, revs):
170
 
        texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
171
 
        try:
172
 
            # fileids_altered_by_revision_ids requires reading the inventory
173
 
            # weave, we will need to read the inventory weave again when
174
 
            # all this is done, so enable caching for that specific weave
175
 
            inv_w = self.from_repository.get_inventory_weave()
176
 
            inv_w.enable_cache()
177
 
            file_ids = self.from_repository.fileids_altered_by_revision_ids(revs)
178
 
            count = 0
179
 
            num_file_ids = len(file_ids)
180
 
            for file_id, required_versions in file_ids.items():
181
 
                texts_pb.update("fetch texts", count, num_file_ids)
182
 
                count +=1
183
 
                to_weave = self.to_weaves.get_weave_or_empty(file_id,
184
 
                    self.to_repository.get_transaction())
185
 
                from_weave = self.from_weaves.get_weave(file_id,
186
 
                    self.from_repository.get_transaction())
187
 
                # we fetch all the texts, because texts do
188
 
                # not reference anything, and its cheap enough
189
 
                to_weave.join(from_weave, version_ids=required_versions)
190
 
                # we don't need *all* of this data anymore, but we dont know
191
 
                # what we do. This cache clearing will result in a new read 
192
 
                # of the knit data when we do the checkout, but probably we
193
 
                # want to emit the needed data on the fly rather than at the
194
 
                # end anyhow.
195
 
                # the from weave should know not to cache data being joined,
196
 
                # but its ok to ask it to clear.
197
 
                from_weave.clear_cache()
198
 
                to_weave.clear_cache()
199
 
        finally:
200
 
            texts_pb.finished()
201
 
 
202
 
    def _fetch_inventory_weave(self, revs):
203
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
204
 
        try:
205
 
            pb.update("fetch inventory", 0, 2)
206
 
            to_weave = self.to_control.get_weave('inventory',
207
 
                    self.to_repository.get_transaction())
208
 
    
209
 
            child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
210
 
            try:
211
 
                # just merge, this is optimisable and its means we don't
212
 
                # copy unreferenced data such as not-needed inventories.
213
 
                pb.update("fetch inventory", 1, 3)
214
 
                from_weave = self.from_repository.get_inventory_weave()
215
 
                pb.update("fetch inventory", 2, 3)
216
 
                # we fetch only the referenced inventories because we do not
217
 
                # know for unselected inventories whether all their required
218
 
                # texts are present in the other repository - it could be
219
 
                # corrupt.
220
 
                to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
221
 
                              version_ids=revs)
222
 
                from_weave.clear_cache()
223
 
            finally:
224
 
                child_pb.finished()
225
 
        finally:
226
 
            pb.finished()
227
 
 
 
204
    def _fetch_weave_text(self, file_id, required_versions):
 
205
        to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
206
            self.to_repository.get_transaction())
 
207
        from_weave = self.from_weaves.get_weave(file_id,
 
208
            self.from_repository.get_transaction())
 
209
        # we fetch all the texts, because texts do
 
210
        # not reference anything, and its cheap enough
 
211
        to_weave.join(from_weave, version_ids=required_versions)
 
212
        # we don't need *all* of this data anymore, but we dont know
 
213
        # what we do. This cache clearing will result in a new read 
 
214
        # of the knit data when we do the checkout, but probably we
 
215
        # want to emit the needed data on the fly rather than at the
 
216
        # end anyhow.
 
217
        # the from weave should know not to cache data being joined,
 
218
        # but its ok to ask it to clear.
 
219
        from_weave.clear_cache()
 
220
        to_weave.clear_cache()
 
221
 
 
222
    def _fetch_inventory_weave(self, revs, pb):
 
223
        pb.update("fetch inventory", 0, 2)
 
224
        to_weave = self.to_control.get_weave('inventory',
 
225
                self.to_repository.get_transaction())
 
226
 
 
227
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
228
        try:
 
229
            # just merge, this is optimisable and its means we don't
 
230
            # copy unreferenced data such as not-needed inventories.
 
231
            pb.update("fetch inventory", 1, 3)
 
232
            from_weave = self.from_repository.get_inventory_weave()
 
233
            pb.update("fetch inventory", 2, 3)
 
234
            # we fetch only the referenced inventories because we do not
 
235
            # know for unselected inventories whether all their required
 
236
            # texts are present in the other repository - it could be
 
237
            # corrupt.
 
238
            to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
 
239
                          version_ids=revs)
 
240
            from_weave.clear_cache()
 
241
        finally:
 
242
            child_pb.finished()
 
243
 
 
244
    def _generate_root_texts(self, revs):
 
245
        """This will be called by __fetch between fetching weave texts and
 
246
        fetching the inventory weave.
 
247
 
 
248
        Subclasses should override this if they need to generate root texts
 
249
        after fetching weave texts.
 
250
        """
 
251
        pass
 
252
        
228
253
 
229
254
class GenericRepoFetcher(RepoFetcher):
230
255
    """This is a generic repo to repo fetcher.
233
258
    It triggers a reconciliation after fetching to ensure integrity.
234
259
    """
235
260
 
236
 
    def _fetch_revision_texts(self, revs):
 
261
    def _fetch_revision_texts(self, revs, pb):
237
262
        """Fetch revision object texts"""
238
 
        rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
239
 
        try:
240
 
            to_txn = self.to_transaction = self.to_repository.get_transaction()
241
 
            count = 0
242
 
            total = len(revs)
243
 
            to_store = self.to_repository._revision_store
244
 
            for rev in revs:
245
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
246
 
                try:
247
 
                    pb.update('copying revisions', count, total)
248
 
                    try:
249
 
                        sig_text = self.from_repository.get_signature_text(rev)
250
 
                        to_store.add_revision_signature_text(rev, sig_text, to_txn)
251
 
                    except errors.NoSuchRevision:
252
 
                        # not signed.
253
 
                        pass
254
 
                    to_store.add_revision(self.from_repository.get_revision(rev),
255
 
                                          to_txn)
256
 
                    count += 1
257
 
                finally:
258
 
                    pb.finished()
259
 
            # fixup inventory if needed: 
260
 
            # this is expensive because we have no inverse index to current ghosts.
261
 
            # but on local disk its a few seconds and sftp push is already insane.
262
 
            # so we just-do-it.
263
 
            # FIXME: repository should inform if this is needed.
264
 
            self.to_repository.reconcile()
265
 
        finally:
266
 
            rev_pb.finished()
 
263
        to_txn = self.to_transaction = self.to_repository.get_transaction()
 
264
        count = 0
 
265
        total = len(revs)
 
266
        to_store = self.to_repository._revision_store
 
267
        for rev in revs:
 
268
            pb.update('copying revisions', count, total)
 
269
            try:
 
270
                sig_text = self.from_repository.get_signature_text(rev)
 
271
                to_store.add_revision_signature_text(rev, sig_text, to_txn)
 
272
            except errors.NoSuchRevision:
 
273
                # not signed.
 
274
                pass
 
275
            to_store.add_revision(self.from_repository.get_revision(rev),
 
276
                                  to_txn)
 
277
            count += 1
 
278
        # fixup inventory if needed: 
 
279
        # this is expensive because we have no inverse index to current ghosts.
 
280
        # but on local disk its a few seconds and sftp push is already insane.
 
281
        # so we just-do-it.
 
282
        # FIXME: repository should inform if this is needed.
 
283
        self.to_repository.reconcile()
267
284
    
268
285
 
269
286
class KnitRepoFetcher(RepoFetcher):
274
291
    copy revision texts.
275
292
    """
276
293
 
277
 
    def _fetch_revision_texts(self, revs):
 
294
    def _fetch_revision_texts(self, revs, pb):
278
295
        # may need to be a InterRevisionStore call here.
279
296
        from_transaction = self.from_repository.get_transaction()
280
297
        to_transaction = self.to_repository.get_transaction()
364
381
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
365
382
                                    last_revision, pb)
366
383
 
367
 
    def _fetch_weave_texts(self, revs):
368
 
        GenericRepoFetcher._fetch_weave_texts(self, revs)
369
 
        # Now generate a weave for the tree root
 
384
    def _generate_root_texts(self, revs):
370
385
        self.helper.generate_root_texts(revs)
371
386
 
372
 
    def _fetch_inventory_weave(self, revs):
 
387
    def _fetch_inventory_weave(self, revs, pb):
373
388
        self.helper.regenerate_inventory(revs)
374
389
 
375
390
 
382
397
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
383
398
                                 last_revision, pb)
384
399
 
385
 
    def _fetch_weave_texts(self, revs):
386
 
        KnitRepoFetcher._fetch_weave_texts(self, revs)
387
 
        # Now generate a weave for the tree root
 
400
    def _generate_root_texts(self, revs):
388
401
        self.helper.generate_root_texts(revs)
389
402
 
390
 
    def _fetch_inventory_weave(self, revs):
 
403
    def _fetch_inventory_weave(self, revs, pb):
391
404
        self.helper.regenerate_inventory(revs)
392
 
        
393
 
 
394
 
class Fetcher(object):
395
 
    """Backwards compatibility glue for branch.fetch()."""
396
 
 
397
 
    @deprecated_method(zero_eight)
398
 
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
399
 
        """Please see branch.fetch()."""
400
 
        to_branch.fetch(from_branch, last_revision, pb)