/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-03-07 20:34:47 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060307203447-b7432f11cbd54c29
make push preserve tree formats.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
"""Copying of history from one branch to another.
 
19
 
 
20
The basic plan is that every branch knows the history of everything
 
21
that has merged into it.  As the first step of a merge, pull, or
 
22
branch operation we copy history from the source into the destination
 
23
branch.
 
24
 
 
25
The copying is done in a slightly complicated order.  We don't want to
 
26
add a revision to the store until everything it refers to is also
 
27
stored, so that if a revision is present we can totally recreate it.
 
28
However, we can't know what files are included in a revision until we
 
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.
 
32
"""
 
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
 
40
from bzrlib.reconcile import RepoReconciler
 
41
from bzrlib.revision import NULL_REVISION
 
42
from bzrlib.symbol_versioning import *
 
43
 
 
44
 
 
45
# TODO: Avoid repeatedly opening weaves so many times.
 
46
 
 
47
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
48
# all yet.  I'm not sure they really should be supported.
 
49
 
 
50
# NOTE: This doesn't copy revisions which may be present but not
 
51
# merged into the last revision.  I'm not sure we want to do that.
 
52
 
 
53
# - get a list of revisions that need to be pulled in
 
54
# - for each one, pull in that revision file
 
55
#   and get the inventory, and store the inventory with right
 
56
#   parents.
 
57
# - and get the ancestry, and store that with right parents too
 
58
# - and keep a note of all file ids and version seen
 
59
# - then go through all files; for each one get the weave,
 
60
#   and add in all file versions
 
61
 
 
62
 
 
63
@deprecated_function(zero_eight)
 
64
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
65
    """Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
 
66
    f = Fetcher(to_branch, from_branch, revision, pb)
 
67
    return f.count_copied, f.failed_revisions
 
68
 
 
69
fetch = greedy_fetch
 
70
 
 
71
 
 
72
class RepoFetcher(object):
 
73
    """Pull revisions and texts from one repository to another.
 
74
 
 
75
    last_revision
 
76
        if set, try to limit to the data this revision references.
 
77
 
 
78
    after running:
 
79
    count_copied -- number of revisions copied
 
80
 
 
81
    This should not be used directory, its essential a object to encapsulate
 
82
    the logic in InterRepository.fetch().
 
83
    """
 
84
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
 
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
 
93
        self.to_repository = to_repository
 
94
        self.from_repository = from_repository
 
95
        # must not mutate self._last_revision as its potentially a shared instance
 
96
        self._last_revision = last_revision
 
97
        if pb is None:
 
98
            self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
99
            self.nested_pb = self.pb
 
100
        else:
 
101
            self.pb = pb
 
102
            self.nested_pb = None
 
103
        self.from_repository.lock_read()
 
104
        try:
 
105
            self.to_repository.lock_write()
 
106
            try:
 
107
                self.__fetch()
 
108
            finally:
 
109
                if self.nested_pb is not None:
 
110
                    self.nested_pb.finished()
 
111
                self.to_repository.unlock()
 
112
        finally:
 
113
            self.from_repository.unlock()
 
114
 
 
115
    def __fetch(self):
 
116
        """Primary worker function.
 
117
 
 
118
        This initialises all the needed variables, and then fetches the 
 
119
        requested revisions, finally clearing the progress bar.
 
120
        """
 
121
        self.to_weaves = self.to_repository.weave_store
 
122
        self.to_control = self.to_repository.control_weaves
 
123
        self.from_weaves = self.from_repository.weave_store
 
124
        self.from_control = self.from_repository.control_weaves
 
125
        self.count_total = 0
 
126
        self.file_ids_names = {}
 
127
        try:
 
128
            revs = self._revids_to_fetch()
 
129
            # nothing to do
 
130
            if revs: 
 
131
                self._fetch_weave_texts(revs)
 
132
                self._fetch_inventory_weave(revs)
 
133
                self._fetch_revision_texts(revs)
 
134
                self.count_copied += len(revs)
 
135
        finally:
 
136
            self.pb.clear()
 
137
 
 
138
    def _revids_to_fetch(self):
 
139
        self.pb.update('get destination history')
 
140
        mutter('fetch up to rev {%s}', self._last_revision)
 
141
        if self._last_revision is NULL_REVISION:
 
142
            # explicit limit of no revisions needed
 
143
            return None
 
144
        if (self._last_revision != None and
 
145
            self.to_repository.has_revision(self._last_revision)):
 
146
            return None
 
147
            
 
148
        try:
 
149
            return self.to_repository.missing_revision_ids(self.from_repository,
 
150
                                                           self._last_revision)
 
151
        except errors.NoSuchRevision:
 
152
            raise InstallFailed([self._last_revision])
 
153
 
 
154
    def _fetch_weave_texts(self, revs):
 
155
        file_ids = self.from_repository.fileid_involved_by_set(revs)
 
156
        count = 0
 
157
        num_file_ids = len(file_ids)
 
158
        for file_id in file_ids:
 
159
            self.pb.update("merge weaves", count, num_file_ids)
 
160
            count +=1
 
161
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
162
                self.to_repository.get_transaction())
 
163
 
 
164
            if to_weave.num_versions() > 0:
 
165
                # destination has contents, must merge
 
166
                from_weave = self.from_weaves.get_weave(file_id,
 
167
                    self.from_repository.get_transaction())
 
168
                to_weave.join(from_weave)
 
169
            else:
 
170
                # destination is empty, just replace it
 
171
                self.to_weaves.copy_multi(self.from_weaves, [file_id], self.pb,
 
172
                                          self.from_repository.get_transaction(),
 
173
                                          self.to_repository.get_transaction())
 
174
        self.pb.clear()
 
175
 
 
176
    def _fetch_inventory_weave(self, revs):
 
177
        self.pb.update("inventory fetch", 0, 2)
 
178
        to_weave = self.to_control.get_weave('inventory',
 
179
                self.to_repository.get_transaction())
 
180
 
 
181
        if to_weave.num_versions() > 0:
 
182
            # destination has contents, must merge
 
183
            self.pb.update("inventory fetch", 1, 2)
 
184
            from_weave = self.from_repository.get_inventory_weave()
 
185
            self.pb.update("inventory fetch", 2, 2)
 
186
            to_weave.join(from_weave, pb=self.pb, msg='merge inventory')
 
187
        else:
 
188
            # destination is empty, just replace it
 
189
            self.to_control.copy_multi(self.from_control,
 
190
                                       ['inventory'],
 
191
                                       self.pb,
 
192
                                       self.from_repository.get_transaction(),
 
193
                                       self.to_repository.get_transaction())
 
194
 
 
195
        self.pb.clear()
 
196
 
 
197
 
 
198
class GenericRepoFetcher(RepoFetcher):
 
199
    """This is a generic repo to repo fetcher.
 
200
 
 
201
    This makes minimal assumptions about repo layout and contents.
 
202
    It triggers a reconciliation after fetching to ensure integrity.
 
203
    """
 
204
 
 
205
    def _fetch_revision_texts(self, revs):
 
206
        self.to_transaction = self.to_repository.get_transaction()
 
207
        count = 0
 
208
        total = len(revs)
 
209
        for rev in revs:
 
210
            self.pb.update('copying revisions', count, total)
 
211
            try:
 
212
                sig_text = self.from_repository.get_signature_text(rev)
 
213
                self.to_repository._revision_store.add_revision_signature_text(
 
214
                    rev, sig_text, self.to_transaction)
 
215
            except errors.NoSuchRevision:
 
216
                # not signed.
 
217
                pass
 
218
            self.to_repository._revision_store.add_revision(
 
219
                self.from_repository.get_revision(rev),
 
220
                self.to_transaction)
 
221
            count += 1
 
222
        self.pb.update('copying revisions', count, total)
 
223
        # fixup inventory if needed: 
 
224
        # this is expensive because we have no inverse index to current ghosts.
 
225
        # but on local disk its a few seconds and sftp push is already insane.
 
226
        # so we just-do-it.
 
227
        # FIXME: repository should inform if this is needed.
 
228
        reconciler = RepoReconciler(self.to_repository)
 
229
        reconciler.reconcile()
 
230
    
 
231
 
 
232
class KnitRepoFetcher(RepoFetcher):
 
233
    """This is a knit format repository specific fetcher.
 
234
 
 
235
    This differs from the GenericRepoFetcher by not doing a 
 
236
    reconciliation after copying, and using knit joining to
 
237
    copy revision texts.
 
238
    """
 
239
 
 
240
    def _fetch_revision_texts(self, revs):
 
241
        # may need to be a InterRevisionStore call here.
 
242
        from_transaction = self.from_repository.get_transaction()
 
243
        to_transaction = self.to_repository.get_transaction()
 
244
        to_sf = self.to_repository._revision_store.get_signature_file(
 
245
            to_transaction)
 
246
        from_sf = self.from_repository._revision_store.get_signature_file(
 
247
            from_transaction)
 
248
        to_sf.join(from_sf, version_ids=revs, pb=self.pb, ignore_missing=True)
 
249
        to_rf = self.to_repository._revision_store.get_revision_file(
 
250
            to_transaction)
 
251
        from_rf = self.from_repository._revision_store.get_revision_file(
 
252
            from_transaction)
 
253
        to_rf.join(from_rf, version_ids=revs, pb=self.pb)
 
254
        reconciler = RepoReconciler(self.to_repository)
 
255
        reconciler.reconcile()
 
256
 
 
257
 
 
258
class Fetcher(object):
 
259
    """Backwards compatability glue for branch.fetch()."""
 
260
 
 
261
    @deprecated_method(zero_eight)
 
262
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
263
        """Please see branch.fetch()."""
 
264
        to_branch.fetch(from_branch, last_revision, pb)