← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Andrew Bennetts
  • Date: 2007-08-30 08:11:54 UTC
  • mfrom: (2766 +trunk)
  • mto: (2535.3.55 repo-refactor)
  • mto: This revision was merged to the branch mainline in revision 2772.
  • Revision ID: andrew.bennetts@canonical.com-20070830081154-16hebp2xwr15x2hc
Merge from bzr.dev.

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
130
121
        requested revisions, finally clearing the progress bar.
131
122
        """
132
123
        self.to_weaves = self.to_repository.weave_store
133
 
        self.to_control = self.to_repository.control_weaves
134
124
        self.from_weaves = self.from_repository.weave_store
135
 
        self.from_control = self.from_repository.control_weaves
136
125
        self.count_total = 0
137
126
        self.file_ids_names = {}
138
127
        pp = ProgressPhase('Fetch phase', 4, self.pb)
139
128
        try:
140
129
            pp.next_phase()
141
130
            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)
 
131
            self._fetch_everything_for_revisions(revs, pp)
151
132
        finally:
152
133
            self.pb.clear()
153
134
 
 
135
    def _fetch_everything_for_revisions(self, revs, pp):
 
136
        """Fetch all data for the given set of revisions."""
 
137
        if revs is None:
 
138
            return
 
139
        # The first phase is "file".  We pass the progress bar for it directly
 
140
        # into item_keys_introduced_by, which has more information about how
 
141
        # that phase is progressing than we do.  Progress updates for the other
 
142
        # phases are taken care of in this function.
 
143
        # XXX: there should be a clear owner of the progress reporting.  Perhaps
 
144
        # item_keys_introduced_by should have a richer API than it does at the
 
145
        # moment, so that it can feed the progress information back to this
 
146
        # function?
 
147
        phase = 'file'
 
148
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
149
        try:
 
150
            data_to_fetch = self.from_repository.item_keys_introduced_by(revs, pb)
 
151
            for knit_kind, file_id, revisions in data_to_fetch:
 
152
                if knit_kind != phase:
 
153
                    phase = knit_kind
 
154
                    # Make a new progress bar for this phase
 
155
                    pb.finished()
 
156
                    pp.next_phase()
 
157
                    pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
158
                if knit_kind == "file":
 
159
                    self._fetch_weave_text(file_id, revisions)
 
160
                elif knit_kind == "inventory":
 
161
                    # XXX:
 
162
                    # Once we've processed all the files, then we generate the root
 
163
                    # texts (if necessary), then we process the inventory.  It's a
 
164
                    # bit distasteful to have knit_kind == "inventory" mean this,
 
165
                    # perhaps it should happen on the first non-"file" knit, in case
 
166
                    # it's not always inventory?
 
167
                    self._generate_root_texts(revs)
 
168
                    self._fetch_inventory_weave(revs, pb)
 
169
                elif knit_kind == "signatures":
 
170
                    # Nothing to do here; this will be taken care of when
 
171
                    # _fetch_revision_texts happens.
 
172
                    pass
 
173
                elif knit_kind == "revisions":
 
174
                    self._fetch_revision_texts(revs, pb)
 
175
                else:
 
176
                    raise AssertionError("Unknown knit kind %r" % knit_kind)
 
177
        finally:
 
178
            if pb is not None:
 
179
                pb.finished()
 
180
        self.count_copied += len(revs)
 
181
        
154
182
    def _revids_to_fetch(self):
 
183
        """Determines the exact revisions needed from self.from_repository to
 
184
        install self._last_revision in self.to_repository.
 
185
 
 
186
        If no revisions need to be fetched, then this just returns None.
 
187
        """
155
188
        mutter('fetch up to rev {%s}', self._last_revision)
156
189
        if self._last_revision is NULL_REVISION:
157
190
            # explicit limit of no revisions needed
166
199
        except errors.NoSuchRevision:
167
200
            raise InstallFailed([self._last_revision])
168
201
 
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()
 
202
    def _fetch_weave_text(self, file_id, required_versions):
 
203
        to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
204
            self.to_repository.get_transaction())
 
205
        from_weave = self.from_weaves.get_weave(file_id,
 
206
            self.from_repository.get_transaction())
 
207
        # we fetch all the texts, because texts do
 
208
        # not reference anything, and its cheap enough
 
209
        to_weave.join(from_weave, version_ids=required_versions)
 
210
        # we don't need *all* of this data anymore, but we dont know
 
211
        # what we do. This cache clearing will result in a new read 
 
212
        # of the knit data when we do the checkout, but probably we
 
213
        # want to emit the needed data on the fly rather than at the
 
214
        # end anyhow.
 
215
        # the from weave should know not to cache data being joined,
 
216
        # but its ok to ask it to clear.
 
217
        from_weave.clear_cache()
 
218
        to_weave.clear_cache()
 
219
 
 
220
    def _fetch_inventory_weave(self, revs, pb):
 
221
        pb.update("fetch inventory", 0, 2)
 
222
        to_weave = self.to_repository.get_inventory_weave()
 
223
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
224
        try:
 
225
            # just merge, this is optimisable and its means we don't
 
226
            # copy unreferenced data such as not-needed inventories.
 
227
            pb.update("fetch inventory", 1, 3)
 
228
            from_weave = self.from_repository.get_inventory_weave()
 
229
            pb.update("fetch inventory", 2, 3)
 
230
            # we fetch only the referenced inventories because we do not
 
231
            # know for unselected inventories whether all their required
 
232
            # texts are present in the other repository - it could be
 
233
            # corrupt.
 
234
            to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
 
235
                          version_ids=revs)
 
236
            from_weave.clear_cache()
 
237
        finally:
 
238
            child_pb.finished()
 
239
 
 
240
    def _generate_root_texts(self, revs):
 
241
        """This will be called by __fetch between fetching weave texts and
 
242
        fetching the inventory weave.
 
243
 
 
244
        Subclasses should override this if they need to generate root texts
 
245
        after fetching weave texts.
 
246
        """
 
247
        pass
227
248
 
228
249
 
229
250
class GenericRepoFetcher(RepoFetcher):
233
254
    It triggers a reconciliation after fetching to ensure integrity.
234
255
    """
235
256
 
236
 
    def _fetch_revision_texts(self, revs):
 
257
    def _fetch_revision_texts(self, revs, pb):
237
258
        """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()
 
259
        to_txn = self.to_transaction = self.to_repository.get_transaction()
 
260
        count = 0
 
261
        total = len(revs)
 
262
        to_store = self.to_repository._revision_store
 
263
        for rev in revs:
 
264
            pb.update('copying revisions', count, total)
 
265
            try:
 
266
                sig_text = self.from_repository.get_signature_text(rev)
 
267
                to_store.add_revision_signature_text(rev, sig_text, to_txn)
 
268
            except errors.NoSuchRevision:
 
269
                # not signed.
 
270
                pass
 
271
            to_store.add_revision(self.from_repository.get_revision(rev),
 
272
                                  to_txn)
 
273
            count += 1
 
274
        # fixup inventory if needed: 
 
275
        # this is expensive because we have no inverse index to current ghosts.
 
276
        # but on local disk its a few seconds and sftp push is already insane.
 
277
        # so we just-do-it.
 
278
        # FIXME: repository should inform if this is needed.
 
279
        self.to_repository.reconcile()
267
280
    
268
281
 
269
282
class KnitRepoFetcher(RepoFetcher):
274
287
    copy revision texts.
275
288
    """
276
289
 
277
 
    def _fetch_revision_texts(self, revs):
 
290
    def _fetch_revision_texts(self, revs, pb):
278
291
        # may need to be a InterRevisionStore call here.
279
292
        from_transaction = self.from_repository.get_transaction()
280
293
        to_transaction = self.to_repository.get_transaction()
364
377
        GenericRepoFetcher.__init__(self, to_repository, from_repository,
365
378
                                    last_revision, pb)
366
379
 
367
 
    def _fetch_weave_texts(self, revs):
368
 
        GenericRepoFetcher._fetch_weave_texts(self, revs)
369
 
        # Now generate a weave for the tree root
 
380
    def _generate_root_texts(self, revs):
370
381
        self.helper.generate_root_texts(revs)
371
382
 
372
 
    def _fetch_inventory_weave(self, revs):
 
383
    def _fetch_inventory_weave(self, revs, pb):
373
384
        self.helper.regenerate_inventory(revs)
374
385
 
375
386
 
382
393
        KnitRepoFetcher.__init__(self, to_repository, from_repository,
383
394
                                 last_revision, pb)
384
395
 
385
 
    def _fetch_weave_texts(self, revs):
386
 
        KnitRepoFetcher._fetch_weave_texts(self, revs)
387
 
        # Now generate a weave for the tree root
 
396
    def _generate_root_texts(self, revs):
388
397
        self.helper.generate_root_texts(revs)
389
398
 
390
 
    def _fetch_inventory_weave(self, revs):
 
399
    def _fetch_inventory_weave(self, revs, pb):
391
400
        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)