/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: Martin Pool
  • Date: 2007-08-20 05:53:39 UTC
  • mfrom: (2727 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2730.
  • Revision ID: mbp@sourcefrog.net-20070820055339-uzei7f7i7jo6tugg
merge trunk

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