~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Robert Collins
  • Date: 2006-03-02 03:12:34 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060302031234-cf6b75961f27c5df
InterVersionedFile implemented.

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
 
 
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.revision import NULL_REVISION
 
40
from bzrlib.symbol_versioning import *
 
41
 
 
42
 
 
43
# TODO: Avoid repeatedly opening weaves so many times.
 
44
 
 
45
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
46
# all yet.  I'm not sure they really should be supported.
 
47
 
 
48
# NOTE: This doesn't copy revisions which may be present but not
 
49
# merged into the last revision.  I'm not sure we want to do that.
 
50
 
 
51
# - get a list of revisions that need to be pulled in
 
52
# - for each one, pull in that revision file
 
53
#   and get the inventory, and store the inventory with right
 
54
#   parents.
 
55
# - and get the ancestry, and store that with right parents too
 
56
# - and keep a note of all file ids and version seen
 
57
# - then go through all files; for each one get the weave,
 
58
#   and add in all file versions
 
59
 
 
60
 
 
61
@deprecated_function(zero_eight)
 
62
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
 
63
    """Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
 
64
    f = Fetcher(to_branch, from_branch, revision, pb)
 
65
    return f.count_copied, f.failed_revisions
 
66
 
 
67
fetch = greedy_fetch
 
68
 
 
69
 
 
70
class RepoFetcher(object):
 
71
    """Pull revisions and texts from one repository to another.
 
72
 
 
73
    last_revision
 
74
        if set, try to limit to the data this revision references.
 
75
 
 
76
    after running:
 
77
    count_copied -- number of revisions copied
 
78
 
 
79
    This should not be used directory, its essential a object to encapsulate
 
80
    the logic in InterRepository.fetch().
 
81
    """
 
82
    def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
 
83
        # result variables.
 
84
        self.failed_revisions = []
 
85
        self.count_copied = 0
 
86
        if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
 
87
            # check that last_revision is in 'from' and then return a no-operation.
 
88
            if last_revision not in (None, NULL_REVISION):
 
89
                from_repository.get_revision(last_revision)
 
90
            return
 
91
        self.to_repository = to_repository
 
92
        self.from_repository = from_repository
 
93
        # must not mutate self._last_revision as its potentially a shared instance
 
94
        self._last_revision = last_revision
 
95
        if pb is None:
 
96
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
97
        else:
 
98
            self.pb = pb
 
99
        self.from_repository.lock_read()
 
100
        try:
 
101
            self.to_repository.lock_write()
 
102
            try:
 
103
                self.__fetch()
 
104
            finally:
 
105
                self.to_repository.unlock()
 
106
        finally:
 
107
            self.from_repository.unlock()
 
108
 
 
109
    def __fetch(self):
 
110
        """Primary worker function.
 
111
 
 
112
        This initialises all the needed variables, and then fetches the 
 
113
        requested revisions, finally clearing the progress bar.
 
114
        """
 
115
        self.to_weaves = self.to_repository.weave_store
 
116
        self.to_control = self.to_repository.control_weaves
 
117
        self.from_weaves = self.from_repository.weave_store
 
118
        self.from_control = self.from_repository.control_weaves
 
119
        self.count_total = 0
 
120
        self.file_ids_names = {}
 
121
        try:
 
122
            revs = self._revids_to_fetch()
 
123
            # nothing to do
 
124
            if revs: 
 
125
                self._fetch_weave_texts(revs)
 
126
                self._fetch_inventory_weave(revs)
 
127
                self._fetch_revision_texts(revs)
 
128
                self.count_copied += len(revs)
 
129
        finally:
 
130
            self.pb.clear()
 
131
 
 
132
    def _revids_to_fetch(self):
 
133
        self.pb.update('get destination history')
 
134
        mutter('fetch up to rev {%s}', self._last_revision)
 
135
        if self._last_revision is NULL_REVISION:
 
136
            # explicit limit of no revisions needed
 
137
            return None
 
138
        if (self._last_revision != None and
 
139
            self.to_repository.has_revision(self._last_revision)):
 
140
            return None
 
141
            
 
142
        try:
 
143
            return self.to_repository.missing_revision_ids(self.from_repository,
 
144
                                                           self._last_revision)
 
145
        except errors.NoSuchRevision:
 
146
            raise InstallFailed([self._last_revision])
 
147
 
 
148
    def _fetch_revision_texts(self, revs):
 
149
        self.to_repository.revision_store.copy_multi(
 
150
            self.from_repository.revision_store,
 
151
            revs,
 
152
            pb=self.pb)
 
153
 
 
154
    def _fetch_weave_texts(self, revs):
 
155
        file_ids = self.from_repository.fileid_involved_by_set(revs)
 
156
        count = 0
 
157
        num_file_ids = len(file_ids)
 
158
        for file_id in file_ids:
 
159
            self.pb.update("merge weaves", count, num_file_ids)
 
160
            count +=1
 
161
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
162
                self.to_repository.get_transaction())
 
163
 
 
164
            if to_weave.numversions() > 0:
 
165
                # destination has contents, must merge
 
166
                from_weave = self.from_weaves.get_weave(file_id,
 
167
                    self.from_repository.get_transaction())
 
168
                to_weave.join(from_weave)
 
169
            else:
 
170
                # destination is empty, just replace it
 
171
                self.to_weaves.copy_multi(self.from_weaves, [file_id], self.pb)
 
172
        self.pb.clear()
 
173
 
 
174
    def _fetch_inventory_weave(self, revs):
 
175
        self.pb.update("inventory fetch", 0, 2)
 
176
        to_weave = self.to_control.get_weave('inventory',
 
177
                self.to_repository.get_transaction())
 
178
 
 
179
        if to_weave.numversions() > 0:
 
180
            # destination has contents, must merge
 
181
            self.pb.update("inventory fetch", 1, 2)
 
182
            from_weave = self.from_repository.get_inventory_weave()
 
183
            self.pb.update("inventory fetch", 2, 2)
 
184
            to_weave.join(from_weave, pb=self.pb, msg='merge inventory')
 
185
        else:
 
186
            # destination is empty, just replace it
 
187
            self.to_control.copy_multi(self.from_control,
 
188
                                       ['inventory'],
 
189
                                       self.pb,
 
190
                                       self.from_repository.get_transaction())
 
191
 
 
192
        self.pb.clear()
 
193
 
 
194
 
 
195
class Fetcher(object):
 
196
    """Backwards compatability glue for branch.fetch()."""
 
197
 
 
198
    @deprecated_method(zero_eight)
 
199
    def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
 
200
        """Please see branch.fetch()."""
 
201
        to_branch.fetch(from_branch, last_revision, pb)