~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2005-10-09 23:42:12 UTC
  • Revision ID: robertc@robertcollins.net-20051009234212-7973344d900afb0b
merge in niemeyers prefixed-store patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
import sys
18
17
import os
 
18
from cStringIO import StringIO
19
19
 
20
 
import bzrlib.errors
21
 
from bzrlib.trace import mutter, note
 
20
import bzrlib
 
21
import bzrlib.errors as errors
 
22
from bzrlib.errors import InstallFailed, NoSuchRevision, WeaveError
 
23
from bzrlib.trace import mutter, note, warning
22
24
from bzrlib.branch import Branch
23
25
from bzrlib.progress import ProgressBar
24
 
 
25
 
 
26
 
def greedy_fetch(to_branch, from_branch, revision, pb):
 
26
from bzrlib.xml5 import serializer_v5
 
27
from bzrlib.osutils import sha_string, split_lines
 
28
 
 
29
"""Copying of history from one branch to another.
 
30
 
 
31
The basic plan is that every branch knows the history of everything
 
32
that has merged into it.  As the first step of a merge, pull, or
 
33
branch operation we copy history from the source into the destination
 
34
branch.
 
35
 
 
36
The copying is done in a slightly complicated order.  We don't want to
 
37
add a revision to the store until everything it refers to is also
 
38
stored, so that if a revision is present we can totally recreate it.
 
39
However, we can't know what files are included in a revision until we
 
40
read its inventory.  Therefore, we first pull the XML and hold it in
 
41
memory until we've updated all of the files referenced.
 
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
 
 
63
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
27
64
    f = Fetcher(to_branch, from_branch, revision, pb)
28
65
    return f.count_copied, f.failed_revisions
29
66
 
30
67
 
 
68
 
31
69
class Fetcher(object):
32
 
    """Pull history from one branch to another."""
33
 
    def __init__(self, to_branch, from_branch, revision_limit=None, pb=None):
 
70
    """Pull revisions and texts from one branch to another.
 
71
 
 
72
    This doesn't update the destination's history; that can be done
 
73
    separately if desired.  
 
74
 
 
75
    revision_limit
 
76
        If set, pull only up to this revision_id.
 
77
 
 
78
    After running:
 
79
 
 
80
    last_revision -- if last_revision
 
81
        is given it will be that, otherwise the last revision of
 
82
        from_branch
 
83
 
 
84
    count_copied -- number of revisions copied
 
85
 
 
86
    count_weaves -- number of file weaves copied
 
87
    """
 
88
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
89
        if to_branch == from_branch:
 
90
            raise Exception("can't fetch from a branch to itself")
34
91
        self.to_branch = to_branch
 
92
        self.to_weaves = to_branch.weave_store
 
93
        self.to_control = to_branch.control_weaves
35
94
        self.from_branch = from_branch
36
 
        self.revision_limit = revision_limit
 
95
        self.from_weaves = from_branch.weave_store
 
96
        self.from_control = from_branch.control_weaves
 
97
        self.failed_revisions = []
 
98
        self.count_copied = 0
 
99
        self.count_total = 0
 
100
        self.count_weaves = 0
 
101
        self.copied_file_ids = set()
37
102
        if pb is None:
38
103
            self.pb = bzrlib.ui.ui_factory.progress_bar()
39
104
        else:
40
105
            self.pb = pb
41
 
        self._scan_histories()
42
 
        self.failed_revisions = []
43
 
        self.count_copied = 0
44
 
        self._copy()
45
 
 
46
 
 
47
 
    def _scan_histories(self):
48
 
        self.from_history = from_branch.revision_history()
49
 
        self.required_revisions = set(from_history)
50
 
        self.to_history = to_branch.revision_history()
51
 
        if self.revision_limit:
52
 
            raise NotImplementedError('sorry, revision_limit not handled yet')
53
 
        self.need_revisions = []
54
 
        for rev_id in self.from_history:
55
 
            if not has_revision(self.to_branch):
56
 
                self.need_revisions.append(rev_id)
 
106
        try:
 
107
            self._fetch_revisions(last_revision)
 
108
        finally:
 
109
            self.pb.clear()
 
110
 
 
111
    def _fetch_revisions(self, last_revision):
 
112
        try:
 
113
            self.last_revision = self._find_last_revision(last_revision)
 
114
        except NoSuchRevision, e:
 
115
            mutter('failed getting last revision: %s', e)
 
116
            raise InstallFailed([last_revision])
 
117
        mutter('fetch up to rev {%s}', self.last_revision)
 
118
        try:
 
119
            revs_to_fetch = self._compare_ancestries()
 
120
        except WeaveError:
 
121
            raise InstallFailed([self.last_revision])
 
122
        self._copy_revisions(revs_to_fetch)
 
123
        self.new_ancestry = revs_to_fetch
 
124
 
 
125
    def _find_last_revision(self, last_revision):
 
126
        """Find the limiting source revision.
 
127
 
 
128
        Every ancestor of that revision will be merged across.
 
129
 
 
130
        Returns the revision_id, or returns None if there's no history
 
131
        in the source branch."""
 
132
        self.pb.update('get source history')
 
133
        from_history = self.from_branch.revision_history()
 
134
        self.pb.update('get destination history')
 
135
        if last_revision:
 
136
            self.from_branch.get_revision(last_revision)
 
137
            return last_revision
 
138
        elif from_history:
 
139
            return from_history[-1]
 
140
        else:
 
141
            return None                 # no history in the source branch
 
142
            
 
143
 
 
144
    def _compare_ancestries(self):
 
145
        """Get a list of revisions that must be copied.
 
146
 
 
147
        That is, every revision that's in the ancestry of the source
 
148
        branch and not in the destination branch."""
 
149
        self.pb.update('get source ancestry')
 
150
        self.from_ancestry = self.from_branch.get_ancestry(self.last_revision)
 
151
 
 
152
        dest_last_rev = self.to_branch.last_revision()
 
153
        self.pb.update('get destination ancestry')
 
154
        if dest_last_rev:
 
155
            dest_ancestry = self.to_branch.get_ancestry(dest_last_rev)
 
156
        else:
 
157
            dest_ancestry = []
 
158
        ss = set(dest_ancestry)
 
159
        to_fetch = []
 
160
        for rev_id in self.from_ancestry:
 
161
            if rev_id not in ss:
 
162
                to_fetch.append(rev_id)
57
163
                mutter('need to get revision {%s}', rev_id)
58
 
 
59
 
 
60
 
    def _copy(self):
61
 
        while self.need_revisions:
62
 
            rev_id = self.need_revisions.pop()
63
 
            mutter('try to get revision {%s}', rev_id)
64
 
 
65
 
    
66
 
        
67
 
    
68
 
 
69
 
def has_revision(branch, revision_id):
70
 
    try:
71
 
        branch.get_revision_xml(revision_id)
72
 
        return True
73
 
    except bzrlib.errors.NoSuchRevision:
74
 
        return False
75
 
 
76
 
 
77
 
def old_greedy_fetch(to_branch, from_branch, revision=None, pb=None):
78
 
    """Copy all history from one branch to another.
79
 
 
80
 
    revision
81
 
        If set, copy only up to this point in the source branch.
82
 
 
83
 
    @returns: number copied, missing ids       
84
 
    """
85
 
    from_history = from_branch.revision_history()
86
 
    required_revisions = set(from_history)
87
 
    all_failed = set()
88
 
    if revision is not None:
89
 
        required_revisions.add(revision)
90
 
        try:
91
 
            rev_index = from_history.index(revision)
92
 
        except ValueError:
93
 
            rev_index = None
94
 
        if rev_index is not None:
95
 
            from_history = from_history[:rev_index + 1]
96
 
        else:
97
 
            from_history = [revision]
98
 
    to_history = to_branch.revision_history()
99
 
    missing = []
100
 
    for rev_id in from_history:
101
 
        if not has_revision(to_branch, rev_id):
102
 
            missing.append(rev_id)
103
 
 
104
 
    # recurse down through the revision graph, looking for things that
105
 
    # can't be found.
106
 
    count = 0
107
 
    while len(missing) > 0:
108
 
        installed, failed = to_branch.install_revisions(from_branch, 
109
 
                                                        revision_ids=missing,
110
 
                                                        pb=pb)
111
 
        count += installed
112
 
        required_failed = failed.intersection(required_revisions)
113
 
        if len(required_failed) > 0:
114
 
            raise bzrlib.errors.InstallFailed(required_failed)
115
 
        for rev_id in failed:
116
 
            note("Failed to install %s" % rev_id)
117
 
        all_failed.update(failed)
118
 
        new_missing = set() 
119
 
        for rev_id in missing:
120
 
            try:
121
 
                revision = from_branch.get_revision(rev_id)
122
 
            except bzrlib.errors.NoSuchRevision:
123
 
                if revision in from_history:
124
 
                    raise
125
 
                else:
126
 
                    continue
127
 
            for parent in [p.revision_id for p in revision.parents]:
128
 
                if not has_revision(to_branch, parent):
129
 
                    new_missing.add(parent)
130
 
        missing = new_missing
131
 
    return count, all_failed
132
 
 
133
 
 
134
 
def old_install_revisions(branch, other, revision_ids, pb):
135
 
    """Copy revisions from other branch into branch.
136
 
 
137
 
    This is a lower-level function used by a pull or a merge.  It
138
 
    incorporates some history from one branch into another, but
139
 
    does not update the revision history or operate on the working
140
 
    copy.
141
 
 
142
 
    revision_ids
143
 
        Sequence of revisions to copy.
144
 
 
145
 
    pb
146
 
        Progress bar for copying.
147
 
    """
148
 
    if False:
149
 
        if hasattr(other.revision_store, "prefetch"):
150
 
            other.revision_store.prefetch(revision_ids)
151
 
        if hasattr(other.inventory_store, "prefetch"):
152
 
            other.inventory_store.prefetch(revision_ids)
153
 
 
154
 
    if pb is None:
155
 
        pb = bzrlib.ui.ui_factory.progress_bar()
156
 
 
157
 
    revisions = []
158
 
    needed_texts = set()
159
 
    i = 0
160
 
 
161
 
    failures = set()
162
 
    for i, rev_id in enumerate(revision_ids):
163
 
        pb.update('fetching revision', i+1, len(revision_ids))
164
 
        try:
165
 
            rev = other.get_revision(rev_id)
166
 
        except bzrlib.errors.NoSuchRevision:
167
 
            failures.add(rev_id)
168
 
            continue
169
 
 
170
 
        revisions.append(rev)
171
 
        inv = other.get_inventory(rev_id)
172
 
        for key, entry in inv.iter_entries():
173
 
            if entry.text_id is None:
174
 
                continue
175
 
            if entry.text_id not in branch.text_store:
176
 
                needed_texts.add(entry.text_id)
177
 
 
178
 
    pb.clear()
179
 
 
180
 
    count, cp_fail = branch.text_store.copy_multi(other.text_store, 
181
 
                                                needed_texts)
182
 
    count, cp_fail = branch.inventory_store.copy_multi(other.inventory_store, 
183
 
                                                     revision_ids)
184
 
    count, cp_fail = branch.revision_store.copy_multi(other.revision_store, 
185
 
                                                    revision_ids,
186
 
                                                    permit_failure=True)
187
 
    assert len(cp_fail) == 0 
188
 
    return count, failures
189
 
 
190
 
 
 
164
        mutter('need to get %d revisions in total', len(to_fetch))
 
165
        self.count_total = len(to_fetch)
 
166
        return to_fetch
 
167
 
 
168
    def _copy_revisions(self, revs_to_fetch):
 
169
        i = 0
 
170
        for rev_id in revs_to_fetch:
 
171
            i += 1
 
172
            if rev_id is None:
 
173
                continue
 
174
            if self.to_branch.has_revision(rev_id):
 
175
                continue
 
176
            self.pb.update('fetch revision', i, self.count_total)
 
177
            self._copy_one_revision(rev_id)
 
178
            self.count_copied += 1
 
179
 
 
180
 
 
181
    def _copy_one_revision(self, rev_id):
 
182
        """Copy revision and everything referenced by it."""
 
183
        mutter('copying revision {%s}', rev_id)
 
184
        rev_xml = self.from_branch.get_revision_xml(rev_id)
 
185
        inv_xml = self.from_branch.get_inventory_xml(rev_id)
 
186
        rev = serializer_v5.read_revision_from_string(rev_xml)
 
187
        inv = serializer_v5.read_inventory_from_string(inv_xml)
 
188
        assert rev.revision_id == rev_id
 
189
        assert rev.inventory_sha1 == sha_string(inv_xml)
 
190
        mutter('  commiter %s, %d parents',
 
191
               rev.committer,
 
192
               len(rev.parent_ids))
 
193
        self._copy_new_texts(rev_id, inv)
 
194
        parents = rev.parent_ids
 
195
        for parent in parents:
 
196
            if not self.to_branch.has_revision(parent):
 
197
                parents.pop(parents.index(parent))
 
198
        self._copy_inventory(rev_id, inv_xml, parents)
 
199
        self.to_branch.revision_store.add(StringIO(rev_xml), rev_id)
 
200
        mutter('copied revision %s', rev_id)
 
201
 
 
202
 
 
203
    def _copy_inventory(self, rev_id, inv_xml, parent_ids):
 
204
        self.to_control.add_text('inventory', rev_id,
 
205
                                split_lines(inv_xml), parent_ids,
 
206
                                self.to_branch.get_transaction())
 
207
 
 
208
    def _copy_new_texts(self, rev_id, inv):
 
209
        """Copy any new texts occuring in this revision."""
 
210
        # TODO: Rather than writing out weaves every time, hold them
 
211
        # in memory until everything's done?  But this way is nicer
 
212
        # if it's interrupted.
 
213
        for path, ie in inv.iter_entries():
 
214
            if ie.revision != rev_id:
 
215
                continue
 
216
            mutter('%s {%s} is changed in this revision',
 
217
                   path, ie.file_id)
 
218
            self._copy_one_weave(rev_id, ie.file_id)
 
219
 
 
220
 
 
221
    def _copy_one_weave(self, rev_id, file_id):
 
222
        """Copy one file weave."""
 
223
        mutter('copy file {%s} modified in {%s}', file_id, rev_id)
 
224
        if file_id in self.copied_file_ids:
 
225
            mutter('file {%s} already copied', file_id)
 
226
            return
 
227
        from_weave = self.from_weaves.get_weave(file_id,
 
228
            self.from_branch.get_transaction())
 
229
        to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
230
            self.to_branch.get_transaction())
 
231
        try:
 
232
            to_weave.join(from_weave)
 
233
        except errors.WeaveParentMismatch:
 
234
            to_weave.reweave(from_weave)
 
235
        self.to_weaves.put_weave(file_id, to_weave,
 
236
            self.to_branch.get_transaction())
 
237
        self.count_weaves += 1
 
238
        self.copied_file_ids.add(file_id)
 
239
        mutter('copied file {%s}', file_id)
 
240
 
 
241
 
 
242
fetch = Fetcher