/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

Fixup pb usage to use nested_progress_bar.

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, WeaveError,
 
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.nested_progress_bar()
 
98
            self.nested_pb = self.pb
 
99
        else:
 
100
            self.pb = pb
 
101
            self.nested_pb = None
 
102
        self.from_repository.lock_read()
 
103
        try:
 
104
            self.to_repository.lock_write()
 
105
            try:
 
106
                self.__fetch()
 
107
            finally:
 
108
                if self.nested_pb is not None:
 
109
                    self.nested_pb.finished()
 
110
                self.to_repository.unlock()
 
111
        finally:
 
112
            self.from_repository.unlock()
 
113
 
 
114
    def __fetch(self):
 
115
        """Primary worker function.
 
116
 
 
117
        This initialises all the needed variables, and then fetches the 
 
118
        requested revisions, finally clearing the progress bar.
 
119
        """
 
120
        self.to_weaves = self.to_repository.weave_store
 
121
        self.to_control = self.to_repository.control_weaves
 
122
        self.from_weaves = self.from_repository.weave_store
 
123
        self.from_control = self.from_repository.control_weaves
 
124
        self.count_total = 0
 
125
        self.file_ids_names = {}
 
126
        try:
 
127
            revs = self._revids_to_fetch()
 
128
            # nothing to do
 
129
            if revs: 
 
130
                self._fetch_weave_texts(revs)
 
131
                self._fetch_inventory_weave(revs)
 
132
                self._fetch_revision_texts(revs)
 
133
                self.count_copied += len(revs)
 
134
        finally:
 
135
            self.pb.clear()
 
136
 
 
137
    def _revids_to_fetch(self):
 
138
        self.pb.update('get destination history')
 
139
        mutter('fetch up to rev {%s}', self._last_revision)
 
140
        if self._last_revision is NULL_REVISION:
 
141
            # explicit limit of no revisions needed
 
142
            return None
 
143
        if (self._last_revision != None and
 
144
            self.to_repository.has_revision(self._last_revision)):
 
145
            return None
 
146
            
 
147
        try:
 
148
            return self.to_repository.missing_revision_ids(self.from_repository,
 
149
                                                           self._last_revision)
 
150
        except errors.NoSuchRevision:
 
151
            raise InstallFailed([self._last_revision])
 
152
 
 
153
    def _fetch_revision_texts(self, revs):
 
154
        self.to_repository.revision_store.copy_multi(
 
155
            self.from_repository.revision_store,
 
156
            revs,
 
157
            pb=self.pb)
 
158
        # fixup inventory if needed:
 
159
        # this is expensive because we have no inverse index to current ghosts.
 
160
        # but on local disk its a few seconds and sftp push is already insane.
 
161
        # so we just-do-it.
 
162
        # FIXME: the generic code path should not need this, if it truely is
 
163
        # generic.
 
164
        reconciler = RepoReconciler(self.to_repository)
 
165
        reconciler.reconcile()
 
166
 
 
167
    def _fetch_weave_texts(self, revs):
 
168
        file_ids = self.from_repository.fileid_involved_by_set(revs)
 
169
        count = 0
 
170
        num_file_ids = len(file_ids)
 
171
        for file_id in file_ids:
 
172
            self.pb.update("merge weaves", count, num_file_ids)
 
173
            count +=1
 
174
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
175
                self.to_repository.get_transaction())
 
176
            from_weave = self.from_weaves.get_weave(file_id,
 
177
                self.from_repository.get_transaction())
 
178
 
 
179
            if to_weave.numversions() > 0:
 
180
                # destination has contents, must merge
 
181
                try:
 
182
                    to_weave.join(from_weave)
 
183
                except errors.WeaveParentMismatch:
 
184
                    to_weave.reweave(from_weave)
 
185
            else:
 
186
                # destination is empty, just replace it
 
187
                to_weave = from_weave.copy()
 
188
 
 
189
            self.to_weaves.put_weave(file_id, to_weave,
 
190
                self.to_repository.get_transaction())
 
191
        self.pb.clear()
 
192
 
 
193
    def _fetch_inventory_weave(self, revs):
 
194
        self.pb.update("inventory fetch", 0, 2)
 
195
        from_weave = self.from_repository.get_inventory_weave()
 
196
        self.to_inventory_weave = self.to_repository.get_inventory_weave()
 
197
        self.pb.update("inventory fetch", 1, 2)
 
198
        self.to_inventory_weave = self.to_control.get_weave('inventory',
 
199
                self.to_repository.get_transaction())
 
200
        self.pb.update("inventory fetch", 2, 2)
 
201
 
 
202
        if self.to_inventory_weave.numversions() > 0:
 
203
            # destination has contents, must merge
 
204
            try:
 
205
                self.to_inventory_weave.join(from_weave, pb=self.pb, msg='merge inventory')
 
206
            except errors.WeaveParentMismatch:
 
207
                self.to_inventory_weave.reweave(from_weave, pb=self.pb, msg='reweave inventory')
 
208
        else:
 
209
            # destination is empty, just replace it
 
210
            self.to_inventory_weave = from_weave.copy()
 
211
 
 
212
        # must be written before pulling any revisions
 
213
        self.to_control.put_weave('inventory', self.to_inventory_weave,
 
214
            self.to_repository.get_transaction())
 
215
 
 
216
        self.pb.clear()
 
217
 
 
218
 
 
219
class Fetcher(object):
 
220
    """Backwards compatability glue for branch.fetch()."""
 
221
 
 
222
    @deprecated_method(zero_eight)
 
223
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
224
        """Please see branch.fetch()."""
 
225
        to_branch.fetch(from_branch, last_revision, pb)