/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-06 12:11:25 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060306121125-4f05992d44e3bda8
Convert Knit repositories to use knits.

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.  Therefore, we first pull the XML and hold it in
 
30
memory until we've updated all of the files referenced.
 
31
"""
 
32
 
 
33
import bzrlib
 
34
import bzrlib.errors as errors
 
35
from bzrlib.errors import (InstallFailed, NoSuchRevision,
 
36
                           MissingText)
 
37
from bzrlib.trace import mutter
 
38
from bzrlib.progress import ProgressBar
 
39
from bzrlib.reconcile import RepoReconciler
 
40
from bzrlib.revision import NULL_REVISION
 
41
from bzrlib.symbol_versioning import *
 
42
 
 
43
 
 
44
# TODO: Avoid repeatedly opening weaves so many times.
 
45
 
 
46
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
47
# all yet.  I'm not sure they really should be supported.
 
48
 
 
49
# NOTE: This doesn't copy revisions which may be present but not
 
50
# merged into the last revision.  I'm not sure we want to do that.
 
51
 
 
52
# - get a list of revisions that need to be pulled in
 
53
# - for each one, pull in that revision file
 
54
#   and get the inventory, and store the inventory with right
 
55
#   parents.
 
56
# - and get the ancestry, and store that with right parents too
 
57
# - and keep a note of all file ids and version seen
 
58
# - then go through all files; for each one get the weave,
 
59
#   and add in all file versions
 
60
 
 
61
 
 
62
@deprecated_function(zero_eight)
 
63
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
64
    """Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
 
65
    f = Fetcher(to_branch, from_branch, revision, pb)
 
66
    return f.count_copied, f.failed_revisions
 
67
 
 
68
fetch = greedy_fetch
 
69
 
 
70
 
 
71
class RepoFetcher(object):
 
72
    """Pull revisions and texts from one repository to another.
 
73
 
 
74
    last_revision
 
75
        if set, try to limit to the data this revision references.
 
76
 
 
77
    after running:
 
78
    count_copied -- number of revisions copied
 
79
 
 
80
    This should not be used directory, its essential a object to encapsulate
 
81
    the logic in InterRepository.fetch().
 
82
    """
 
83
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
 
84
        # result variables.
 
85
        self.failed_revisions = []
 
86
        self.count_copied = 0
 
87
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
 
88
            # check that last_revision is in 'from' and then return a no-operation.
 
89
            if last_revision not in (None, NULL_REVISION):
 
90
                from_repository.get_revision(last_revision)
 
91
            return
 
92
        self.to_repository = to_repository
 
93
        self.from_repository = from_repository
 
94
        # must not mutate self._last_revision as its potentially a shared instance
 
95
        self._last_revision = last_revision
 
96
        if pb is None:
 
97
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
98
        else:
 
99
            self.pb = pb
 
100
        self.from_repository.lock_read()
 
101
        try:
 
102
            self.to_repository.lock_write()
 
103
            try:
 
104
                self.__fetch()
 
105
            finally:
 
106
                self.to_repository.unlock()
 
107
        finally:
 
108
            self.from_repository.unlock()
 
109
 
 
110
    def __fetch(self):
 
111
        """Primary worker function.
 
112
 
 
113
        This initialises all the needed variables, and then fetches the 
 
114
        requested revisions, finally clearing the progress bar.
 
115
        """
 
116
        self.to_weaves = self.to_repository.weave_store
 
117
        self.to_control = self.to_repository.control_weaves
 
118
        self.from_weaves = self.from_repository.weave_store
 
119
        self.from_control = self.from_repository.control_weaves
 
120
        self.count_total = 0
 
121
        self.file_ids_names = {}
 
122
        try:
 
123
            revs = self._revids_to_fetch()
 
124
            # nothing to do
 
125
            if revs: 
 
126
                self._fetch_weave_texts(revs)
 
127
                self._fetch_inventory_weave(revs)
 
128
                self._fetch_revision_texts(revs)
 
129
                self.count_copied += len(revs)
 
130
        finally:
 
131
            self.pb.clear()
 
132
 
 
133
    def _revids_to_fetch(self):
 
134
        self.pb.update('get destination history')
 
135
        mutter('fetch up to rev {%s}', self._last_revision)
 
136
        if self._last_revision is NULL_REVISION:
 
137
            # explicit limit of no revisions needed
 
138
            return None
 
139
        if (self._last_revision != None and
 
140
            self.to_repository.has_revision(self._last_revision)):
 
141
            return None
 
142
            
 
143
        try:
 
144
            return self.to_repository.missing_revision_ids(self.from_repository,
 
145
                                                           self._last_revision)
 
146
        except errors.NoSuchRevision:
 
147
            raise InstallFailed([self._last_revision])
 
148
 
 
149
    def _fetch_weave_texts(self, revs):
 
150
        file_ids = self.from_repository.fileid_involved_by_set(revs)
 
151
        count = 0
 
152
        num_file_ids = len(file_ids)
 
153
        for file_id in file_ids:
 
154
            self.pb.update("merge weaves", count, num_file_ids)
 
155
            count +=1
 
156
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
157
                self.to_repository.get_transaction())
 
158
 
 
159
            if to_weave.num_versions() > 0:
 
160
                # destination has contents, must merge
 
161
                from_weave = self.from_weaves.get_weave(file_id,
 
162
                    self.from_repository.get_transaction())
 
163
                to_weave.join(from_weave)
 
164
            else:
 
165
                # destination is empty, just replace it
 
166
                self.to_weaves.copy_multi(self.from_weaves, [file_id], self.pb,
 
167
                                          self.from_repository.get_transaction())
 
168
        self.pb.clear()
 
169
 
 
170
    def _fetch_inventory_weave(self, revs):
 
171
        self.pb.update("inventory fetch", 0, 2)
 
172
        to_weave = self.to_control.get_weave('inventory',
 
173
                self.to_repository.get_transaction())
 
174
 
 
175
        if to_weave.num_versions() > 0:
 
176
            # destination has contents, must merge
 
177
            self.pb.update("inventory fetch", 1, 2)
 
178
            from_weave = self.from_repository.get_inventory_weave()
 
179
            self.pb.update("inventory fetch", 2, 2)
 
180
            to_weave.join(from_weave, pb=self.pb, msg='merge inventory')
 
181
        else:
 
182
            # destination is empty, just replace it
 
183
            self.to_control.copy_multi(self.from_control,
 
184
                                       ['inventory'],
 
185
                                       self.pb,
 
186
                                       self.from_repository.get_transaction())
 
187
 
 
188
        self.pb.clear()
 
189
 
 
190
 
 
191
class GenericRepoFetcher(RepoFetcher):
 
192
    """This is a generic repo to repo fetcher.
 
193
 
 
194
    This makes minimal assumptions about repo layout and contents.
 
195
    It triggers a reconciliation after fetching to ensure integrity.
 
196
    """
 
197
 
 
198
    def _fetch_revision_texts(self, revs):
 
199
        self.to_transaction = self.to_repository.get_transaction()
 
200
        count = 0
 
201
        total = len(revs)
 
202
        for rev in revs:
 
203
            self.pb.update('copying revisions', count, total)
 
204
            try:
 
205
                sig_text = self.from_repository.get_signature_text(rev)
 
206
                self.to_repository._revision_store.add_revision_signature_text(
 
207
                    rev, sig_text, self.to_transaction)
 
208
            except errors.NoSuchRevision:
 
209
                # not signed.
 
210
                pass
 
211
            self.to_repository._revision_store.add_revision(
 
212
                self.from_repository.get_revision(rev),
 
213
                self.to_transaction)
 
214
            count += 1
 
215
        self.pb.update('copying revisions', count, total)
 
216
        # fixup inventory if needed: 
 
217
        # this is expensive because we have no inverse index to current ghosts.
 
218
        # but on local disk its a few seconds and sftp push is already insane.
 
219
        # so we just-do-it.
 
220
        # FIXME: repository should inform if this is needed.
 
221
        reconciler = RepoReconciler(self.to_repository)
 
222
        reconciler.reconcile()
 
223
    
 
224
 
 
225
class KnitRepoFetcher(RepoFetcher):
 
226
    """This is a knit format repository specific fetcher.
 
227
 
 
228
    This differs from the GenericRepoFetcher by not doing a 
 
229
    reconciliation after copying, and using knit joining to
 
230
    copy revision texts.
 
231
    """
 
232
 
 
233
    def _fetch_revision_texts(self, revs):
 
234
        # may need to be a InterRevisionStore call here.
 
235
        from_transaction = self.from_repository.get_transaction()
 
236
        to_transaction = self.to_repository.get_transaction()
 
237
        to_sf = self.to_repository._revision_store._get_signature_file(
 
238
            to_transaction)
 
239
        from_sf = self.from_repository._revision_store._get_signature_file(
 
240
            from_transaction)
 
241
        to_sf.join(from_sf, version_ids=revs, pb=self.pb, ignore_missing=True)
 
242
        to_rf = self.to_repository._revision_store.get_revision_file(
 
243
            to_transaction)
 
244
        from_rf = self.from_repository._revision_store.get_revision_file(
 
245
            from_transaction)
 
246
        to_rf.join(from_rf, version_ids=revs, pb=self.pb)
 
247
        reconciler = RepoReconciler(self.to_repository)
 
248
        reconciler.reconcile()
 
249
 
 
250
 
 
251
class Fetcher(object):
 
252
    """Backwards compatability glue for branch.fetch()."""
 
253
 
 
254
    @deprecated_method(zero_eight)
 
255
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
256
        """Please see branch.fetch()."""
 
257
        to_branch.fetch(from_branch, last_revision, pb)