~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Martin Pool
  • Date: 2005-09-13 09:06:10 UTC
  • Revision ID: mbp@sourcefrog.net-20050913090610-7ce557143a7ca17a
- remove a lot of dead code from fetch

Show diffs side-by-side

added added

removed removed

Lines of Context:
42
42
 
43
43
# TODO: Avoid repeatedly opening weaves so many times.
44
44
 
 
45
# XXX: This doesn't handle ghost (not present in branch) revisions at
 
46
# all yet.
 
47
 
 
48
# - get a list of revisions that need to be pulled in
 
49
# - for each one, pull in that revision file
 
50
#   and get the inventory, and store the inventory with right
 
51
#   parents.
 
52
# - and get the ancestry, and store that with right parents too
 
53
# - and keep a note of all file ids and version seen
 
54
# - then go through all files; for each one get the weave,
 
55
#   and add in all file versions
 
56
 
 
57
 
45
58
 
46
59
def greedy_fetch(to_branch, from_branch, revision, pb):
47
60
    f = Fetcher(to_branch, from_branch, revision, pb)
67
80
        self._load_histories()
68
81
        revs_to_fetch = self._compare_ancestries()
69
82
        self._copy_revisions(revs_to_fetch)
70
 
        # - get a list of revisions that need to be pulled in
71
 
        # - for each one, pull in that revision file
72
 
        #   and get the inventory, and store the inventory with right
73
 
        #   parents.
74
 
        # - and get the ancestry, and store that with right parents too
75
 
        # - and keep a note of all file ids and version seen
76
 
        # - then go through all files; for each one get the weave,
77
 
        #   and add in all file versions
78
 
 
79
83
 
80
84
    def _load_histories(self):
81
85
        """Load histories of both branches, up to the limit."""
162
166
        from_parents = map(from_weave.idx_to_name, from_weave.parents(from_idx))
163
167
        text_lines = from_weave.get(from_idx)
164
168
        to_weave = self.to_branch.weave_store.get_weave_or_empty(file_id)
165
 
        if rev_id in to_weave._name_map:
166
 
            warning('version {%s} already present in weave of file {%s}',
167
 
                    rev_id, file_id)
168
 
            return
169
169
        to_parents = map(to_weave.lookup, from_parents)
 
170
        # it's ok to add even if the text is already there
170
171
        to_weave.add(rev_id, to_parents, text_lines)
171
172
        self.to_branch.weave_store.put_weave(file_id, to_weave)
172
 
    
173
 
 
174
 
def has_revision(branch, revision_id):
175
 
    try:
176
 
        branch.get_revision_xml_file(revision_id)
177
 
        return True
178
 
    except bzrlib.errors.NoSuchRevision:
179
 
        return False
180
 
 
181
 
 
182
 
def old_greedy_fetch(to_branch, from_branch, revision=None, pb=None):
183
 
    """Copy all history from one branch to another.
184
 
 
185
 
    revision
186
 
        If set, copy only up to this point in the source branch.
187
 
 
188
 
    @returns: number copied, missing ids       
189
 
    """
190
 
    from_history = from_branch.revision_history()
191
 
    required_revisions = set(from_history)
192
 
    all_failed = set()
193
 
    if revision is not None:
194
 
        required_revisions.add(revision)
195
 
        try:
196
 
            rev_index = from_history.index(revision)
197
 
        except ValueError:
198
 
            rev_index = None
199
 
        if rev_index is not None:
200
 
            from_history = from_history[:rev_index + 1]
201
 
        else:
202
 
            from_history = [revision]
203
 
    to_history = to_branch.revision_history()
204
 
    missing = []
205
 
    for rev_id in from_history:
206
 
        if not has_revision(to_branch, rev_id):
207
 
            missing.append(rev_id)
208
 
 
209
 
    # recurse down through the revision graph, looking for things that
210
 
    # can't be found.
211
 
    count = 0
212
 
    while len(missing) > 0:
213
 
        installed, failed = to_branch.install_revisions(from_branch, 
214
 
                                                        revision_ids=missing,
215
 
                                                        pb=pb)
216
 
        count += installed
217
 
        required_failed = failed.intersection(required_revisions)
218
 
        if len(required_failed) > 0:
219
 
            raise bzrlib.errors.InstallFailed(required_failed)
220
 
        for rev_id in failed:
221
 
            note("Failed to install %s" % rev_id)
222
 
        all_failed.update(failed)
223
 
        new_missing = set() 
224
 
        for rev_id in missing:
225
 
            try:
226
 
                revision = from_branch.get_revision(rev_id)
227
 
            except bzrlib.errors.NoSuchRevision:
228
 
                if revision in from_history:
229
 
                    raise
230
 
                else:
231
 
                    continue
232
 
            for parent in [p.revision_id for p in revision.parents]:
233
 
                if not has_revision(to_branch, parent):
234
 
                    new_missing.add(parent)
235
 
        missing = new_missing
236
 
    return count, all_failed
237
 
 
238
 
 
239
 
def old_install_revisions(branch, other, revision_ids, pb):
240
 
    """Copy revisions from other branch into branch.
241
 
 
242
 
    This is a lower-level function used by a pull or a merge.  It
243
 
    incorporates some history from one branch into another, but
244
 
    does not update the revision history or operate on the working
245
 
    copy.
246
 
 
247
 
    revision_ids
248
 
        Sequence of revisions to copy.
249
 
 
250
 
    pb
251
 
        Progress bar for copying.
252
 
    """
253
 
    if False:
254
 
        if hasattr(other.revision_store, "prefetch"):
255
 
            other.revision_store.prefetch(revision_ids)
256
 
        if hasattr(other.inventory_store, "prefetch"):
257
 
            other.inventory_store.prefetch(revision_ids)
258
 
 
259
 
    if pb is None:
260
 
        pb = bzrlib.ui.ui_factory.progress_bar()
261
 
 
262
 
    revisions = []
263
 
    needed_texts = set()
264
 
    i = 0
265
 
 
266
 
    failures = set()
267
 
    for i, rev_id in enumerate(revision_ids):
268
 
        pb.update('fetching revision', i+1, len(revision_ids))
269
 
        try:
270
 
            rev = other.get_revision(rev_id)
271
 
        except bzrlib.errors.NoSuchRevision:
272
 
            failures.add(rev_id)
273
 
            continue
274
 
 
275
 
        revisions.append(rev)
276
 
        inv = other.get_inventory(rev_id)
277
 
        for key, entry in inv.iter_entries():
278
 
            if entry.text_id is None:
279
 
                continue
280
 
            if entry.text_id not in branch.text_store:
281
 
                needed_texts.add(entry.text_id)
282
 
 
283
 
    pb.clear()
284
 
 
285
 
    count, cp_fail = branch.text_store.copy_multi(other.text_store, 
286
 
                                                needed_texts)
287
 
    count, cp_fail = branch.inventory_store.copy_multi(other.inventory_store, 
288
 
                                                     revision_ids)
289
 
    count, cp_fail = branch.revision_store.copy_multi(other.revision_store, 
290
 
                                                    revision_ids,
291
 
                                                    permit_failure=True)
292
 
    assert len(cp_fail) == 0 
293
 
    return count, failures
294
 
 
295