/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: Robert Collins
  • Date: 2006-04-28 11:01:38 UTC
  • mfrom: (1687 +trunk)
  • mto: (1704.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1706.
  • Revision ID: robertc@robertcollins.net-20060428110138-0e69ecb765434f9d
Merge from mainline.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005 by 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from copy import copy
18
 
import os
19
 
from cStringIO import StringIO
20
 
 
21
 
import bzrlib
22
 
import bzrlib.errors as errors
23
 
from bzrlib.errors import (InstallFailed, NoSuchRevision, WeaveError,
24
 
                           MissingText)
25
 
from bzrlib.trace import mutter, note, warning
26
 
from bzrlib.branch import Branch
27
 
from bzrlib.progress import ProgressBar
28
 
from bzrlib.revision import NULL_REVISION
29
 
from bzrlib.xml5 import serializer_v5
30
 
from bzrlib.osutils import sha_string, split_lines
31
17
 
32
18
"""Copying of history from one branch to another.
33
19
 
40
26
add a revision to the store until everything it refers to is also
41
27
stored, so that if a revision is present we can totally recreate it.
42
28
However, we can't know what files are included in a revision until we
43
 
read its inventory.  Therefore, we first pull the XML and hold it in
44
 
memory until we've updated all of the files referenced.
 
29
read its inventory.  So we query the inventory store of the source for
 
30
the ids we need, and then pull those ids and finally actually join
 
31
the inventories.
45
32
"""
46
33
 
 
34
import bzrlib
 
35
import bzrlib.errors as errors
 
36
from bzrlib.errors import (InstallFailed, NoSuchRevision,
 
37
                           MissingText)
 
38
from bzrlib.trace import mutter
 
39
from bzrlib.progress import ProgressBar, ProgressPhase
 
40
from bzrlib.reconcile import RepoReconciler
 
41
from bzrlib.revision import NULL_REVISION
 
42
from bzrlib.symbol_versioning import *
 
43
 
 
44
 
47
45
# TODO: Avoid repeatedly opening weaves so many times.
48
46
 
49
47
# XXX: This doesn't handle ghost (not present in branch) revisions at
62
60
#   and add in all file versions
63
61
 
64
62
 
65
 
 
 
63
@deprecated_function(zero_eight)
66
64
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
65
    """Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
67
66
    f = Fetcher(to_branch, from_branch, revision, pb)
68
67
    return f.count_copied, f.failed_revisions
69
68
 
 
69
fetch = greedy_fetch
 
70
 
70
71
 
71
72
class RepoFetcher(object):
72
73
    """Pull revisions and texts from one repository to another.
76
77
 
77
78
    after running:
78
79
    count_copied -- number of revisions copied
79
 
    count_weaves -- number of file weaves copied
 
80
 
 
81
    This should not be used directory, its essential a object to encapsulate
 
82
    the logic in InterRepository.fetch().
80
83
    """
81
84
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
82
 
        if to_repository.bzrdir.transport.base == from_repository.bzrdir.transport.base:
83
 
            raise Exception("can't fetch from a repository to itself %s, %s" % 
84
 
                            (from_repository.bzrdir.transport.base,
85
 
                             to_repository.bzrdir.transport.base))
 
85
        # result variables.
 
86
        self.failed_revisions = []
 
87
        self.count_copied = 0
 
88
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
 
89
            # check that last_revision is in 'from' and then return a no-operation.
 
90
            if last_revision not in (None, NULL_REVISION):
 
91
                from_repository.get_revision(last_revision)
 
92
            return
86
93
        self.to_repository = to_repository
87
94
        self.from_repository = from_repository
88
95
        # must not mutate self._last_revision as its potentially a shared instance
89
96
        self._last_revision = last_revision
90
97
        if pb is None:
91
 
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
98
            self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
99
            self.nested_pb = self.pb
92
100
        else:
93
101
            self.pb = pb
 
102
            self.nested_pb = None
94
103
        self.from_repository.lock_read()
95
104
        try:
96
105
            self.to_repository.lock_write()
97
106
            try:
98
107
                self.__fetch()
99
108
            finally:
 
109
                if self.nested_pb is not None:
 
110
                    self.nested_pb.finished()
100
111
                self.to_repository.unlock()
101
112
        finally:
102
113
            self.from_repository.unlock()
111
122
        self.to_control = self.to_repository.control_weaves
112
123
        self.from_weaves = self.from_repository.weave_store
113
124
        self.from_control = self.from_repository.control_weaves
114
 
        self.failed_revisions = []
115
 
        self.count_copied = 0
116
125
        self.count_total = 0
117
 
        self.count_weaves = 0
118
 
        self.copied_file_ids = set()
119
126
        self.file_ids_names = {}
 
127
        pp = ProgressPhase('fetch phase', 4, self.pb)
120
128
        try:
121
129
            revs = self._revids_to_fetch()
122
 
            # nothing to do
123
 
            if revs: 
 
130
            # something to do ?
 
131
            if revs:
 
132
                pp.next_phase()
124
133
                self._fetch_weave_texts(revs)
 
134
                pp.next_phase()
125
135
                self._fetch_inventory_weave(revs)
 
136
                pp.next_phase()
126
137
                self._fetch_revision_texts(revs)
127
138
                self.count_copied += len(revs)
128
139
        finally:
143
154
        except errors.NoSuchRevision:
144
155
            raise InstallFailed([self._last_revision])
145
156
 
146
 
    def _fetch_revision_texts(self, revs):
147
 
        self.to_repository.revision_store.copy_multi(
148
 
            self.from_repository.revision_store,
149
 
            revs,
150
 
            pb=self.pb)
151
 
 
152
157
    def _fetch_weave_texts(self, revs):
153
 
        file_ids = self.from_repository.fileid_involved_by_set(revs)
154
 
        count = 0
155
 
        num_file_ids = len(file_ids)
156
 
        for file_id in file_ids:
157
 
            self.pb.update("merge weaves", count, num_file_ids)
158
 
            count +=1
159
 
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
160
 
                self.to_repository.get_transaction())
161
 
            from_weave = self.from_weaves.get_weave(file_id,
162
 
                self.from_repository.get_transaction())
163
 
 
164
 
            if to_weave.numversions() > 0:
165
 
                # destination has contents, must merge
 
158
        texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
159
        try:
 
160
            file_ids = self.from_repository.fileid_involved_by_set(revs)
 
161
            count = 0
 
162
            num_file_ids = len(file_ids)
 
163
            for file_id in file_ids:
 
164
                texts_pb.update("fetch texts", count, num_file_ids)
 
165
                count +=1
 
166
                to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
167
                    self.to_repository.get_transaction())
 
168
                from_weave = self.from_weaves.get_weave(file_id,
 
169
                    self.from_repository.get_transaction())
 
170
                # we fetch all the texts, because texts do
 
171
                # not reference anything, and its cheap enough
 
172
                to_weave.join(from_weave)
 
173
        finally:
 
174
            texts_pb.finished()
 
175
 
 
176
    def _fetch_inventory_weave(self, revs):
 
177
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
178
        try:
 
179
            pb.update("fetch inventory", 0, 2)
 
180
            to_weave = self.to_control.get_weave('inventory',
 
181
                    self.to_repository.get_transaction())
 
182
    
 
183
            child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
184
            try:
 
185
                # just merge, this is optimisable and its means we dont
 
186
                # copy unreferenced data such as not-needed inventories.
 
187
                pb.update("fetch inventory", 1, 3)
 
188
                from_weave = self.from_repository.get_inventory_weave()
 
189
                pb.update("fetch inventory", 2, 3)
 
190
                # we fetch only the referenced inventories because we do not
 
191
                # know for unselected inventories whether all their required
 
192
                # texts are present in the other repository - it could be
 
193
                # corrupt.
 
194
                to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
 
195
                              version_ids=revs)
 
196
            finally:
 
197
                child_pb.finished()
 
198
        finally:
 
199
            pb.finished()
 
200
 
 
201
 
 
202
class GenericRepoFetcher(RepoFetcher):
 
203
    """This is a generic repo to repo fetcher.
 
204
 
 
205
    This makes minimal assumptions about repo layout and contents.
 
206
    It triggers a reconciliation after fetching to ensure integrity.
 
207
    """
 
208
 
 
209
    def _fetch_revision_texts(self, revs):
 
210
        """Fetch revision object texts"""
 
211
        rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
212
        try:
 
213
            to_txn = self.to_transaction = self.to_repository.get_transaction()
 
214
            count = 0
 
215
            total = len(revs)
 
216
            to_store = self.to_repository._revision_store
 
217
            for rev in revs:
 
218
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
166
219
                try:
167
 
                    to_weave.join(from_weave)
168
 
                except errors.WeaveParentMismatch:
169
 
                    to_weave.reweave(from_weave)
170
 
            else:
171
 
                # destination is empty, just replace it
172
 
                to_weave = from_weave.copy()
173
 
 
174
 
            self.to_weaves.put_weave(file_id, to_weave,
175
 
                self.to_repository.get_transaction())
176
 
        self.pb.clear()
177
 
 
178
 
    def _fetch_inventory_weave(self, revs):
179
 
        self.pb.update("inventory fetch", 0, 2)
180
 
        from_weave = self.from_repository.get_inventory_weave()
181
 
        to_weave = self.to_repository.get_inventory_weave()
182
 
        self.pb.update("inventory fetch", 1, 2)
183
 
        to_weave = self.to_control.get_weave('inventory',
184
 
                self.to_repository.get_transaction())
185
 
        self.pb.update("inventory fetch", 2, 2)
186
 
 
187
 
        if to_weave.numversions() > 0:
188
 
            # destination has contents, must merge
189
 
            try:
190
 
                to_weave.join(from_weave, pb=self.pb, msg='merge inventory')
191
 
            except errors.WeaveParentMismatch:
192
 
                to_weave.reweave(from_weave, pb=self.pb, msg='reweave inventory')
193
 
        else:
194
 
            # destination is empty, just replace it
195
 
            to_weave = from_weave.copy()
196
 
 
197
 
        self.to_control.put_weave('inventory', to_weave,
198
 
            self.to_repository.get_transaction())
199
 
 
200
 
        self.pb.clear()
 
220
                    pb.update('copying revisions', count, total)
 
221
                    try:
 
222
                        sig_text = self.from_repository.get_signature_text(rev)
 
223
                        to_store.add_revision_signature_text(rev, sig_text, to_txn)
 
224
                    except errors.NoSuchRevision:
 
225
                        # not signed.
 
226
                        pass
 
227
                    to_store.add_revision(self.from_repository.get_revision(rev),
 
228
                                          to_txn)
 
229
                    count += 1
 
230
                finally:
 
231
                    pb.finished()
 
232
            # fixup inventory if needed: 
 
233
            # this is expensive because we have no inverse index to current ghosts.
 
234
            # but on local disk its a few seconds and sftp push is already insane.
 
235
            # so we just-do-it.
 
236
            # FIXME: repository should inform if this is needed.
 
237
            self.to_repository.reconcile()
 
238
        finally:
 
239
            rev_pb.finished()
 
240
    
 
241
 
 
242
class KnitRepoFetcher(RepoFetcher):
 
243
    """This is a knit format repository specific fetcher.
 
244
 
 
245
    This differs from the GenericRepoFetcher by not doing a 
 
246
    reconciliation after copying, and using knit joining to
 
247
    copy revision texts.
 
248
    """
 
249
 
 
250
    def _fetch_revision_texts(self, revs):
 
251
        # may need to be a InterRevisionStore call here.
 
252
        from_transaction = self.from_repository.get_transaction()
 
253
        to_transaction = self.to_repository.get_transaction()
 
254
        to_sf = self.to_repository._revision_store.get_signature_file(
 
255
            to_transaction)
 
256
        from_sf = self.from_repository._revision_store.get_signature_file(
 
257
            from_transaction)
 
258
        to_sf.join(from_sf, version_ids=revs, ignore_missing=True)
 
259
        to_rf = self.to_repository._revision_store.get_revision_file(
 
260
            to_transaction)
 
261
        from_rf = self.from_repository._revision_store.get_revision_file(
 
262
            from_transaction)
 
263
        to_rf.join(from_rf, version_ids=revs)
201
264
 
202
265
 
203
266
class Fetcher(object):
204
 
    """Pull revisions and texts from one branch to another.
205
 
 
206
 
    This doesn't update the destination's history; that can be done
207
 
    separately if desired.  
208
 
 
209
 
    revision_limit
210
 
        If set, pull only up to this revision_id.
211
 
 
212
 
    After running:
213
 
 
214
 
    last_revision -- if last_revision
215
 
        is given it will be that, otherwise the last revision of
216
 
        from_branch
217
 
 
218
 
    count_copied -- number of revisions copied
219
 
 
220
 
    count_weaves -- number of file weaves copied
221
 
    """
 
267
    """Backwards compatability glue for branch.fetch()."""
 
268
 
 
269
    @deprecated_method(zero_eight)
222
270
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
223
 
        if to_branch.base == from_branch.base:
224
 
            raise Exception("can't fetch from a branch to itself %s, %s" % 
225
 
                            (from_branch.base, to_branch.base))
226
 
        
227
 
        self.to_branch = to_branch
228
 
        self.from_branch = from_branch
229
 
        self._last_revision = last_revision
230
 
        if pb is None:
231
 
            self.pb = bzrlib.ui.ui_factory.progress_bar()
232
 
        else:
233
 
            self.pb = pb
234
 
        self.from_branch.lock_read()
235
 
        try:
236
 
            self.to_branch.lock_write()
237
 
            try:
238
 
                self.__fetch()
239
 
            finally:
240
 
                self.to_branch.unlock()
241
 
        finally:
242
 
            self.from_branch.unlock()
243
 
 
244
 
    def __fetch(self):
245
 
        self._find_last_revision()
246
 
        repo_fetcher = RepoFetcher(to_repository=self.to_branch.repository,
247
 
                                   from_repository=self.from_branch.repository,
248
 
                                   pb=self.pb,
249
 
                                   last_revision=self._last_revision)
250
 
        self.failed_revisions = repo_fetcher.failed_revisions
251
 
        self.count_copied = repo_fetcher.count_copied
252
 
        self.count_total = repo_fetcher.count_total
253
 
        self.count_weaves = repo_fetcher.count_weaves
254
 
        self.copied_file_ids = repo_fetcher.copied_file_ids
255
 
 
256
 
    def _find_last_revision(self):
257
 
        """Find the limiting source revision.
258
 
 
259
 
        Every ancestor of that revision will be merged across.
260
 
 
261
 
        Returns the revision_id, or returns None if there's no history
262
 
        in the source branch."""
263
 
        if self._last_revision:
264
 
            return
265
 
        self.pb.update('get source history')
266
 
        from_history = self.from_branch.revision_history()
267
 
        self.pb.update('get destination history')
268
 
        if from_history:
269
 
            self._last_revision = from_history[-1]
270
 
        else:
271
 
            # no history in the source branch
272
 
            self._last_revision = NULL_REVISION
273
 
 
274
 
fetch = Fetcher
 
271
        """Please see branch.fetch()."""
 
272
        to_branch.fetch(from_branch, last_revision, pb)