~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

[merge] jam-integration

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
from copy import copy
17
18
import os
18
19
from cStringIO import StringIO
19
20
 
20
21
import bzrlib
21
22
import bzrlib.errors as errors
22
 
from bzrlib.errors import InstallFailed, NoSuchRevision, WeaveError
 
23
from bzrlib.errors import (InstallFailed, NoSuchRevision, WeaveError,
 
24
                           MissingText)
23
25
from bzrlib.trace import mutter, note, warning
24
26
from bzrlib.branch import Branch
25
27
from bzrlib.progress import ProgressBar
86
88
    count_weaves -- number of file weaves copied
87
89
    """
88
90
    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")
 
91
        if to_branch.base == from_branch.base:
 
92
            raise Exception("can't fetch from a branch to itself %s, %s" % 
 
93
                            (from_branch.base, to_branch.base))
 
94
        
91
95
        self.to_branch = to_branch
92
 
        self.to_weaves = to_branch.weave_store
93
 
        self.to_control = to_branch.control_weaves
94
96
        self.from_branch = from_branch
95
 
        self.from_weaves = from_branch.weave_store
96
 
        self.from_control = from_branch.control_weaves
 
97
        self._last_revision = last_revision
 
98
        if pb is None:
 
99
            self.pb = bzrlib.ui.ui_factory.progress_bar()
 
100
        else:
 
101
            self.pb = pb
 
102
        self.from_branch.lock_read()
 
103
        try:
 
104
            self.to_branch.lock_write()
 
105
            try:
 
106
                self.__fetch()
 
107
            finally:
 
108
                self.to_branch.unlock()
 
109
        finally:
 
110
            self.from_branch.unlock()
 
111
 
 
112
    def __fetch(self):
 
113
        """Primary worker function.
 
114
 
 
115
        This initialises all the needed variables, and then fetches the 
 
116
        requested revisions, finally clearing the progress bar.
 
117
        """
 
118
        self.to_repository = self.to_branch.repository
 
119
        self.to_weaves = self.to_repository.weave_store
 
120
        self.to_control = self.to_repository.control_weaves
 
121
        self.from_repository = self.from_branch.repository
 
122
        self.from_weaves = self.from_repository.weave_store
 
123
        self.from_control = self.from_repository.control_weaves
97
124
        self.failed_revisions = []
98
125
        self.count_copied = 0
99
126
        self.count_total = 0
100
127
        self.count_weaves = 0
101
128
        self.copied_file_ids = set()
102
 
        if pb is None:
103
 
            self.pb = bzrlib.ui.ui_factory.progress_bar()
104
 
        else:
105
 
            self.pb = pb
106
 
        self.from_branch.lock_read()
 
129
        self.file_ids_names = {}
107
130
        try:
108
 
            self._fetch_revisions(last_revision)
 
131
            revs = self._revids_to_fetch()
 
132
            # nothing to do
 
133
            if revs: 
 
134
                self._fetch_weave_texts(revs)
 
135
                self._fetch_inventory_weave(revs)
 
136
                self._fetch_revision_texts(revs)
 
137
                self.count_copied += len(revs)
109
138
        finally:
110
 
            self.from_branch.unlock()
111
139
            self.pb.clear()
112
140
 
113
 
    def _fetch_revisions(self, last_revision):
114
 
        try:
115
 
            self.last_revision = self._find_last_revision(last_revision)
116
 
        except NoSuchRevision, e:
117
 
            mutter('failed getting last revision: %s', e)
118
 
            raise InstallFailed([last_revision])
119
 
        mutter('fetch up to rev {%s}', self.last_revision)
120
 
        if (self.last_revision is not None and 
121
 
            self.to_branch.has_revision(self.last_revision)):
 
141
    def _revids_to_fetch(self):
 
142
        self._find_last_revision()
 
143
        mutter('fetch up to rev {%s}', self._last_revision)
 
144
        if (self._last_revision is not None and 
 
145
            self.to_repository.has_revision(self._last_revision)):
122
146
            return
123
147
        try:
124
 
            revs_to_fetch = self._compare_ancestries()
 
148
            branch_from_revs = set(self.from_repository.get_ancestry(self._last_revision))
125
149
        except WeaveError:
126
 
            raise InstallFailed([self.last_revision])
127
 
        self._copy_revisions(revs_to_fetch)
128
 
        self.new_ancestry = revs_to_fetch
129
 
 
130
 
    def _find_last_revision(self, last_revision):
 
150
            raise InstallFailed([self._last_revision])
 
151
 
 
152
        self.dest_last_rev = self.to_branch.last_revision()
 
153
        branch_to_revs = set(self.to_repository.get_ancestry(self.dest_last_rev))
 
154
 
 
155
        return branch_from_revs.difference(branch_to_revs)
 
156
 
 
157
    def _fetch_revision_texts(self, revs):
 
158
        self.to_repository.revision_store.copy_multi(
 
159
            self.from_repository.revision_store, revs)
 
160
 
 
161
    def _fetch_weave_texts(self, revs):
 
162
        file_ids = self.from_branch.fileid_involved_by_set(revs)
 
163
        count = 0
 
164
        num_file_ids = len(file_ids)
 
165
        for file_id in file_ids:
 
166
            self.pb.update("merge weave merge", count, num_file_ids)
 
167
            count +=1
 
168
            to_weave = self.to_weaves.get_weave_or_empty(file_id,
 
169
                self.to_branch.get_transaction())
 
170
            from_weave = self.from_weaves.get_weave(file_id,
 
171
                self.from_branch.get_transaction())
 
172
 
 
173
            if to_weave.numversions() > 0:
 
174
                # destination has contents, must merge
 
175
                try:
 
176
                    to_weave.join(from_weave)
 
177
                except errors.WeaveParentMismatch:
 
178
                    to_weave.reweave(from_weave)
 
179
            else:
 
180
                # destination is empty, just replace it
 
181
                to_weave = from_weave.copy()
 
182
 
 
183
            self.to_weaves.put_weave(file_id, to_weave,
 
184
                self.to_branch.get_transaction())
 
185
 
 
186
        self.pb.clear()
 
187
 
 
188
    def _fetch_inventory_weave(self, revs):
 
189
        self.pb.update("inventory fetch", 0, 2)
 
190
        from_weave = self.from_repository.get_inventory_weave()
 
191
        to_weave = self.to_repository.get_inventory_weave()
 
192
        self.pb.update("inventory fetch", 1, 2)
 
193
        to_weave = self.to_control.get_weave('inventory',
 
194
                self.to_branch.get_transaction())
 
195
        self.pb.update("inventory fetch", 2, 2)
 
196
 
 
197
        if to_weave.numversions() > 0:
 
198
            # destination has contents, must merge
 
199
            try:
 
200
                to_weave.join(from_weave, pb=self.pb, msg='merge inventory')
 
201
            except errors.WeaveParentMismatch:
 
202
                to_weave.reweave(from_weave, pb=self.pb, msg='reweave inventory')
 
203
        else:
 
204
            # destination is empty, just replace it
 
205
            to_weave = from_weave.copy()
 
206
 
 
207
        self.to_control.put_weave('inventory', to_weave,
 
208
            self.to_branch.get_transaction())
 
209
 
 
210
        self.pb.clear()
 
211
 
 
212
    def _find_last_revision(self):
131
213
        """Find the limiting source revision.
132
214
 
133
215
        Every ancestor of that revision will be merged across.
134
216
 
135
217
        Returns the revision_id, or returns None if there's no history
136
218
        in the source branch."""
 
219
        if self._last_revision:
 
220
            return
137
221
        self.pb.update('get source history')
138
222
        from_history = self.from_branch.revision_history()
139
223
        self.pb.update('get destination history')
140
 
        if last_revision:
141
 
            self.from_branch.get_revision(last_revision)
142
 
            return last_revision
143
 
        elif from_history:
144
 
            return from_history[-1]
145
 
        else:
146
 
            return None                 # no history in the source branch
147
 
            
148
 
 
149
 
    def _compare_ancestries(self):
150
 
        """Get a list of revisions that must be copied.
151
 
 
152
 
        That is, every revision that's in the ancestry of the source
153
 
        branch and not in the destination branch."""
154
 
        self.pb.update('get source ancestry')
155
 
        self.from_ancestry = self.from_branch.get_ancestry(self.last_revision)
156
 
 
157
 
        dest_last_rev = self.to_branch.last_revision()
158
 
        self.pb.update('get destination ancestry')
159
 
        if dest_last_rev:
160
 
            dest_ancestry = self.to_branch.get_ancestry(dest_last_rev)
161
 
        else:
162
 
            dest_ancestry = []
163
 
        ss = set(dest_ancestry)
164
 
        to_fetch = []
165
 
        for rev_id in self.from_ancestry:
166
 
            if rev_id not in ss:
167
 
                to_fetch.append(rev_id)
168
 
                mutter('need to get revision {%s}', rev_id)
169
 
        mutter('need to get %d revisions in total', len(to_fetch))
170
 
        self.count_total = len(to_fetch)
171
 
        return to_fetch
172
 
 
173
 
    def _copy_revisions(self, revs_to_fetch):
174
 
        i = 0
175
 
        for rev_id in revs_to_fetch:
176
 
            i += 1
177
 
            if rev_id is None:
178
 
                continue
179
 
            if self.to_branch.has_revision(rev_id):
180
 
                continue
181
 
            self.pb.update('fetch revision', i, self.count_total)
182
 
            self._copy_one_revision(rev_id)
183
 
            self.count_copied += 1
184
 
 
185
 
 
186
 
    def _copy_one_revision(self, rev_id):
187
 
        """Copy revision and everything referenced by it."""
188
 
        mutter('copying revision {%s}', rev_id)
189
 
        rev_xml = self.from_branch.get_revision_xml(rev_id)
190
 
        inv_xml = self.from_branch.get_inventory_xml(rev_id)
191
 
        rev = serializer_v5.read_revision_from_string(rev_xml)
192
 
        inv = serializer_v5.read_inventory_from_string(inv_xml)
193
 
        assert rev.revision_id == rev_id
194
 
        assert rev.inventory_sha1 == sha_string(inv_xml)
195
 
        mutter('  commiter %s, %d parents',
196
 
               rev.committer,
197
 
               len(rev.parent_ids))
198
 
        self._copy_new_texts(rev_id, inv)
199
 
        parents = rev.parent_ids
200
 
        for parent in parents:
201
 
            if not self.to_branch.has_revision(parent):
202
 
                parents.pop(parents.index(parent))
203
 
        self._copy_inventory(rev_id, inv_xml, parents)
204
 
        self.to_branch.revision_store.add(StringIO(rev_xml), rev_id)
205
 
        mutter('copied revision %s', rev_id)
206
 
 
207
 
 
208
 
    def _copy_inventory(self, rev_id, inv_xml, parent_ids):
209
 
        self.to_control.add_text('inventory', rev_id,
210
 
                                split_lines(inv_xml), parent_ids,
211
 
                                self.to_branch.get_transaction())
212
 
 
213
 
    def _copy_new_texts(self, rev_id, inv):
214
 
        """Copy any new texts occuring in this revision."""
215
 
        # TODO: Rather than writing out weaves every time, hold them
216
 
        # in memory until everything's done?  But this way is nicer
217
 
        # if it's interrupted.
218
 
        for path, ie in inv.iter_entries():
219
 
            if ie.revision != rev_id:
220
 
                continue
221
 
            mutter('%s {%s} is changed in this revision',
222
 
                   path, ie.file_id)
223
 
            self._copy_one_weave(rev_id, ie.file_id)
224
 
 
225
 
 
226
 
    def _copy_one_weave(self, rev_id, file_id):
227
 
        """Copy one file weave."""
228
 
        mutter('copy file {%s} modified in {%s}', file_id, rev_id)
229
 
        if file_id in self.copied_file_ids:
230
 
            mutter('file {%s} already copied', file_id)
231
 
            return
232
 
        from_weave = self.from_weaves.get_weave(file_id,
233
 
            self.from_branch.get_transaction())
234
 
        to_weave = self.to_weaves.get_weave_or_empty(file_id,
235
 
            self.to_branch.get_transaction())
236
 
        try:
237
 
            to_weave.join(from_weave)
238
 
        except errors.WeaveParentMismatch:
239
 
            to_weave.reweave(from_weave)
240
 
        self.to_weaves.put_weave(file_id, to_weave,
241
 
            self.to_branch.get_transaction())
242
 
        self.count_weaves += 1
243
 
        self.copied_file_ids.add(file_id)
244
 
        mutter('copied file {%s}', file_id)
245
 
 
 
224
        if from_history:
 
225
            self._last_revision = from_history[-1]
 
226
        else:
 
227
            # no history in the source branch
 
228
            self._last_revision = None
246
229
 
247
230
fetch = Fetcher