1
# Copyright (C) 2005 by Canonical Ltd
 
 
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.
 
 
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.
 
 
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
 
 
19
from cStringIO import StringIO
 
 
22
import bzrlib.errors as errors
 
 
23
from bzrlib.errors import (InstallFailed, NoSuchRevision, WeaveError,
 
 
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
 
 
31
"""Copying of history from one branch to another.
 
 
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
 
 
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.
 
 
46
# TODO: Avoid repeatedly opening weaves so many times.
 
 
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.
 
 
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.
 
 
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
 
 
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
 
 
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
 
 
71
class Fetcher(object):
 
 
72
    """Pull revisions and texts from one branch to another.
 
 
74
    This doesn't update the destination's history; that can be done
 
 
75
    separately if desired.  
 
 
78
        If set, pull only up to this revision_id.
 
 
82
    last_revision -- if last_revision
 
 
83
        is given it will be that, otherwise the last revision of
 
 
86
    count_copied -- number of revisions copied
 
 
88
    count_weaves -- number of file weaves copied
 
 
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
 
 
102
        self.count_weaves = 0
 
 
103
        self.copied_file_ids = set()
 
 
104
        self.file_ids_names = {}
 
 
106
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
 
109
        self.from_branch.lock_read()
 
 
111
            revs = self._revids_to_fetch(last_revision )
 
 
114
                self._fetch_revision_texts( revs )
 
 
115
                self._fetch_weave_texts( revs )
 
 
116
                self._fetch_inventory_weave( revs )
 
 
117
                self.count_copied += len(revs)
 
 
119
            self.from_branch.unlock()
 
 
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)):
 
 
129
            branch_from_revs = set(self.from_branch.get_ancestry(self.last_revision))
 
 
131
            raise InstallFailed([self.last_revision])
 
 
133
        self.dest_last_rev = self.to_branch.last_revision()
 
 
134
        branch_to_revs = set(self.to_branch.get_ancestry(self.dest_last_rev))
 
 
136
        return branch_from_revs.difference( branch_to_revs )
 
 
138
    def _fetch_revision_texts( self, revs ):
 
 
139
        self.to_branch.revision_store.copy_multi(
 
 
140
            self.from_branch.revision_store, revs )
 
 
142
    def _fetch_weave_texts( self, revs ):
 
 
143
        file_ids = self.from_branch.fileid_involved_by_set( revs )
 
 
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)
 
 
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())
 
 
154
            if to_weave.numversions() > 0:
 
 
155
                # destination has contents, must merge
 
 
157
                    to_weave.join(from_weave)
 
 
158
                except errors.WeaveParentMismatch:
 
 
159
                    to_weave.reweave(from_weave)
 
 
161
                # destination is empty, just replace it
 
 
162
                to_weave = from_weave.copy( )
 
 
164
            self.to_weaves.put_weave(file_id, to_weave,
 
 
165
                self.to_branch.get_transaction())
 
 
169
    def _fetch_inventory_weave( self, revs ):
 
 
170
        self.pb.update( "inventory merge",0,1)
 
 
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())
 
 
177
        if to_weave.numversions() > 0:
 
 
178
            # destination has contents, must merge
 
 
180
                to_weave.join(from_weave)
 
 
181
            except errors.WeaveParentMismatch:
 
 
182
                to_weave.reweave(from_weave)
 
 
184
            # destination is empty, just replace it
 
 
185
            to_weave = from_weave.copy( )
 
 
187
        self.to_control.put_weave('inventory', to_weave,
 
 
188
            self.to_branch.get_transaction())
 
 
192
    def _find_last_revision(self, last_revision):
 
 
193
        """Find the limiting source revision.
 
 
195
        Every ancestor of that revision will be merged across.
 
 
197
        Returns the revision_id, or returns None if there's no history
 
 
198
        in the source branch."""
 
 
201
        self.pb.update('get source history')
 
 
202
        from_history = self.from_branch.revision_history()
 
 
203
        self.pb.update('get destination history')
 
 
205
            return from_history[-1]
 
 
207
            return None                 # no history in the source branch