~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

[merge] 0.7-bugfix: Fix fileid_involved to unescape xml characters, fix StubServer to handle paramiko > 1.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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
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.xml5 import serializer_v5
 
29
from bzrlib.osutils import sha_string, split_lines
 
30
 
 
31
"""Copying of history from one branch to another.
 
32
 
 
33
The basic plan is that every branch knows the history of everything
 
34
that has merged into it.  As the first step of a merge, pull, or
 
35
branch operation we copy history from the source into the destination
 
36
branch.
 
37
 
 
38
The copying is done in a slightly complicated order.  We don't want to
 
39
add a revision to the store until everything it refers to is also
 
40
stored, so that if a revision is present we can totally recreate it.
 
41
However, we can't know what files are included in a revision until we
 
42
read its inventory.  Therefore, we first pull the XML and hold it in
 
43
memory until we've updated all of the files referenced.
 
44
"""
 
45
 
 
46
# TODO: Avoid repeatedly opening weaves so many times.
 
47
 
 
48
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
49
# all yet.  I'm not sure they really should be supported.
 
50
 
 
51
# NOTE: This doesn't copy revisions which may be present but not
 
52
# merged into the last revision.  I'm not sure we want to do that.
 
53
 
 
54
# - get a list of revisions that need to be pulled in
 
55
# - for each one, pull in that revision file
 
56
#   and get the inventory, and store the inventory with right
 
57
#   parents.
 
58
# - and get the ancestry, and store that with right parents too
 
59
# - and keep a note of all file ids and version seen
 
60
# - then go through all files; for each one get the weave,
 
61
#   and add in all file versions
 
62
 
 
63
 
 
64
 
 
65
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
66
    f = Fetcher(to_branch, from_branch, revision, pb)
 
67
    return f.count_copied, f.failed_revisions
 
68
 
 
69
 
 
70
 
 
71
class Fetcher(object):
 
72
    """Pull revisions and texts from one branch to another.
 
73
 
 
74
    This doesn't update the destination's history; that can be done
 
75
    separately if desired.  
 
76
 
 
77
    revision_limit
 
78
        If set, pull only up to this revision_id.
 
79
 
 
80
    After running:
 
81
 
 
82
    last_revision -- if last_revision
 
83
        is given it will be that, otherwise the last revision of
 
84
        from_branch
 
85
 
 
86
    count_copied -- number of revisions copied
 
87
 
 
88
    count_weaves -- number of file weaves copied
 
89
    """
 
90
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
91
        if to_branch == from_branch:
 
92
            raise Exception("can't fetch from a branch to itself")
 
93
        self.to_branch = to_branch
 
94
        self.to_weaves = to_branch.weave_store
 
95
        self.to_control = to_branch.control_weaves
 
96
        self.from_branch = from_branch
 
97
        self.from_weaves = from_branch.weave_store
 
98
        self.from_control = from_branch.control_weaves
 
99
        self.failed_revisions = []
 
100
        self.count_copied = 0
 
101
        self.count_total = 0
 
102
        self.count_weaves = 0
 
103
        self.copied_file_ids = set()
 
104
        self.file_ids_names = {}
 
105
        if pb is None:
 
106
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
107
        else:
 
108
            self.pb = pb
 
109
        self.from_branch.lock_read()
 
110
        try:
 
111
            revs = self._revids_to_fetch(last_revision )
 
112
            # nothing to do
 
113
            if revs: 
 
114
                self._fetch_revision_texts( revs )
 
115
                self._fetch_weave_texts( revs )
 
116
                self._fetch_inventory_weave( revs )
 
117
                self.count_copied += len(revs)
 
118
        finally:
 
119
            self.from_branch.unlock()
 
120
            self.pb.clear()
 
121
 
 
122
    def _revids_to_fetch(self, last_revision):
 
123
        self.last_revision = self._find_last_revision(last_revision)
 
124
        mutter('fetch up to rev {%s}', self.last_revision)
 
125
        if (self.last_revision is not None and 
 
126
            self.to_branch.has_revision(self.last_revision)):
 
127
            return
 
128
        try:
 
129
            branch_from_revs = set(self.from_branch.get_ancestry(self.last_revision))
 
130
        except WeaveError:
 
131
            raise InstallFailed([self.last_revision])
 
132
 
 
133
        self.dest_last_rev = self.to_branch.last_revision()
 
134
        branch_to_revs = set(self.to_branch.get_ancestry(self.dest_last_rev))
 
135
 
 
136
        return branch_from_revs.difference( branch_to_revs )
 
137
 
 
138
    def _fetch_revision_texts( self, revs ):
 
139
        self.to_branch.revision_store.copy_multi(
 
140
            self.from_branch.revision_store, revs )
 
141
 
 
142
    def _fetch_weave_texts( self, revs ):
 
143
        file_ids = self.from_branch.fileid_involved_by_set( revs )
 
144
        count = 0
 
145
        num_file_ids = len(file_ids)
 
146
        for file_id in file_ids:
 
147
            self.pb.update( "merge weave merge",count,num_file_ids)
 
148
            count +=1
 
149
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
150
                self.to_branch.get_transaction())
 
151
            from_weave = self.from_weaves.get_weave(file_id,
 
152
                self.from_branch.get_transaction())
 
153
 
 
154
            if to_weave.numversions() > 0:
 
155
                # destination has contents, must merge
 
156
                try:
 
157
                    to_weave.join(from_weave)
 
158
                except errors.WeaveParentMismatch:
 
159
                    to_weave.reweave(from_weave)
 
160
            else:
 
161
                # destination is empty, just replace it
 
162
                to_weave = from_weave.copy( )
 
163
 
 
164
            self.to_weaves.put_weave(file_id, to_weave,
 
165
                self.to_branch.get_transaction())
 
166
 
 
167
        self.pb.clear( )
 
168
 
 
169
    def _fetch_inventory_weave( self, revs ):
 
170
        self.pb.update( "inventory merge",0,1)
 
171
 
 
172
        from_weave = self.from_control.get_weave('inventory',
 
173
                self.from_branch.get_transaction())
 
174
        to_weave = self.to_control.get_weave('inventory',
 
175
                self.to_branch.get_transaction())
 
176
 
 
177
        if to_weave.numversions() > 0:
 
178
            # destination has contents, must merge
 
179
            try:
 
180
                to_weave.join(from_weave)
 
181
            except errors.WeaveParentMismatch:
 
182
                to_weave.reweave(from_weave)
 
183
        else:
 
184
            # destination is empty, just replace it
 
185
            to_weave = from_weave.copy( )
 
186
 
 
187
        self.to_control.put_weave('inventory', to_weave,
 
188
            self.to_branch.get_transaction())
 
189
 
 
190
        self.pb.clear( )
 
191
 
 
192
    def _find_last_revision(self, last_revision):
 
193
        """Find the limiting source revision.
 
194
 
 
195
        Every ancestor of that revision will be merged across.
 
196
 
 
197
        Returns the revision_id, or returns None if there's no history
 
198
        in the source branch."""
 
199
        if last_revision:
 
200
            return last_revision
 
201
        self.pb.update('get source history')
 
202
        from_history = self.from_branch.revision_history()
 
203
        self.pb.update('get destination history')
 
204
        if from_history:
 
205
            return from_history[-1]
 
206
        else:
 
207
            return None                 # no history in the source branch
 
208
 
 
209
fetch = Fetcher