/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: Canonical.com Patch Queue Manager
  • Date: 2007-08-16 05:50:11 UTC
  • mfrom: (2668.2.9 fetch-refactor)
  • Revision ID: pqm@pqm.ubuntu.com-20070816055011-tnjdmdi948uyvz6a
(Andrew Bennetts) Add Repository.item_keys_introduced_by, and some associated refactoring of bzrlib/fetch.py.

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
42
        )
79
79
        # result variables.
80
80
        self.failed_revisions = []
81
81
        self.count_copied = 0
82
 
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
83
 
            # check that last_revision is in 'from' and then return a no-operation.
84
 
            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):
85
86
                to_repository.get_revision(last_revision)
86
87
            return
87
88
        self.to_repository = to_repository
129
130
        try:
130
131
            pp.next_phase()
131
132
            revs = self._revids_to_fetch()
132
 
            # something to do ?
133
 
            if revs:
134
 
                pp.next_phase()
135
 
                self._fetch_weave_texts(revs)
136
 
                pp.next_phase()
137
 
                self._fetch_inventory_weave(revs)
138
 
                pp.next_phase()
139
 
                self._fetch_revision_texts(revs)
140
 
                self.count_copied += len(revs)
 
133
            self._fetch_everything_for_revisions(revs, pp)
141
134
        finally:
142
135
            self.pb.clear()
143
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
        
144
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
        """
145
190
        mutter('fetch up to rev {%s}', self._last_revision)
146
191
        if self._last_revision is NULL_REVISION:
147
192
            # explicit limit of no revisions needed
156
201
        except errors.NoSuchRevision:
157
202
            raise InstallFailed([self._last_revision])
158
203
 
159
 
    def _fetch_weave_texts(self, revs):
160
 
        texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
161
 
        try:
162
 
            # fileids_altered_by_revision_ids requires reading the inventory
163
 
            # weave, we will need to read the inventory weave again when
164
 
            # all this is done, so enable caching for that specific weave
165
 
            inv_w = self.from_repository.get_inventory_weave()
166
 
            inv_w.enable_cache()
167
 
            file_ids = self.from_repository.fileids_altered_by_revision_ids(revs)
168
 
            count = 0
169
 
            num_file_ids = len(file_ids)
170
 
            for file_id, required_versions in file_ids.items():
171
 
                texts_pb.update("fetch texts", count, num_file_ids)
172
 
                count +=1
173
 
                to_weave = self.to_weaves.get_weave_or_empty(file_id,
174
 
                    self.to_repository.get_transaction())
175
 
                from_weave = self.from_weaves.get_weave(file_id,
176
 
                    self.from_repository.get_transaction())
177
 
                # we fetch all the texts, because texts do
178
 
                # not reference anything, and its cheap enough
179
 
                to_weave.join(from_weave, version_ids=required_versions)
180
 
                # we don't need *all* of this data anymore, but we dont know
181
 
                # what we do. This cache clearing will result in a new read 
182
 
                # of the knit data when we do the checkout, but probably we
183
 
                # want to emit the needed data on the fly rather than at the
184
 
                # end anyhow.
185
 
                # the from weave should know not to cache data being joined,
186
 
                # but its ok to ask it to clear.
187
 
                from_weave.clear_cache()
188
 
                to_weave.clear_cache()
189
 
        finally:
190
 
            texts_pb.finished()
191
 
 
192
 
    def _fetch_inventory_weave(self, revs):
193
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
194
 
        try:
195
 
            pb.update("fetch inventory", 0, 2)
196
 
            to_weave = self.to_control.get_weave('inventory',
197
 
                    self.to_repository.get_transaction())
198
 
    
199
 
            child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
200
 
            try:
201
 
                # just merge, this is optimisable and its means we don't
202
 
                # copy unreferenced data such as not-needed inventories.
203
 
                pb.update("fetch inventory", 1, 3)
204
 
                from_weave = self.from_repository.get_inventory_weave()
205
 
                pb.update("fetch inventory", 2, 3)
206
 
                # we fetch only the referenced inventories because we do not
207
 
                # know for unselected inventories whether all their required
208
 
                # texts are present in the other repository - it could be
209
 
                # corrupt.
210
 
                to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
211
 
                              version_ids=revs)
212
 
                from_weave.clear_cache()
213
 
            finally:
214
 
                child_pb.finished()
215
 
        finally:
216
 
            pb.finished()
217
 
 
 
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
        
218
253
 
219
254
class GenericRepoFetcher(RepoFetcher):
220
255
    """This is a generic repo to repo fetcher.
223
258
    It triggers a reconciliation after fetching to ensure integrity.
224
259
    """
225
260
 
226
 
    def _fetch_revision_texts(self, revs):
 
261
    def _fetch_revision_texts(self, revs, pb):
227
262
        """Fetch revision object texts"""
228
 
        rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
229
 
        try:
230
 
            to_txn = self.to_transaction = self.to_repository.get_transaction()
231
 
            count = 0
232
 
            total = len(revs)
233
 
            to_store = self.to_repository._revision_store
234
 
            for rev in revs:
235
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
236
 
                try:
237
 
                    pb.update('copying revisions', count, total)
238
 
                    try:
239
 
                        sig_text = self.from_repository.get_signature_text(rev)
240
 
                        to_store.add_revision_signature_text(rev, sig_text, to_txn)
241
 
                    except errors.NoSuchRevision:
242
 
                        # not signed.
243
 
                        pass
244
 
                    to_store.add_revision(self.from_repository.get_revision(rev),
245
 
                                          to_txn)
246
 
                    count += 1
247
 
                finally:
248
 
                    pb.finished()
249
 
            # fixup inventory if needed: 
250
 
            # this is expensive because we have no inverse index to current ghosts.
251
 
            # but on local disk its a few seconds and sftp push is already insane.
252
 
            # so we just-do-it.
253
 
            # FIXME: repository should inform if this is needed.
254
 
            self.to_repository.reconcile()
255
 
        finally:
256
 
            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()
257
284
    
258
285
 
259
286
class KnitRepoFetcher(RepoFetcher):
264
291
    copy revision texts.
265
292
    """
266
293
 
267
 
    def _fetch_revision_texts(self, revs):
 
294
    def _fetch_revision_texts(self, revs, pb):
268
295
        # may need to be a InterRevisionStore call here.
269
296
        from_transaction = self.from_repository.get_transaction()
270
297
        to_transaction = self.to_repository.get_transaction()
354
381
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
355
382
                                    last_revision, pb)
356
383
 
357
 
    def _fetch_weave_texts(self, revs):
358
 
        GenericRepoFetcher._fetch_weave_texts(self, revs)
359
 
        # Now generate a weave for the tree root
 
384
    def _generate_root_texts(self, revs):
360
385
        self.helper.generate_root_texts(revs)
361
386
 
362
 
    def _fetch_inventory_weave(self, revs):
 
387
    def _fetch_inventory_weave(self, revs, pb):
363
388
        self.helper.regenerate_inventory(revs)
364
389
 
365
390
 
372
397
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
373
398
                                 last_revision, pb)
374
399
 
375
 
    def _fetch_weave_texts(self, revs):
376
 
        KnitRepoFetcher._fetch_weave_texts(self, revs)
377
 
        # Now generate a weave for the tree root
 
400
    def _generate_root_texts(self, revs):
378
401
        self.helper.generate_root_texts(revs)
379
402
 
380
 
    def _fetch_inventory_weave(self, revs):
 
403
    def _fetch_inventory_weave(self, revs, pb):
381
404
        self.helper.regenerate_inventory(revs)