← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
"""Copying of history from one branch to another.
19
18
 
20
19
The basic plan is that every branch knows the history of everything
23
22
branch.
24
23
"""
25
24
 
 
25
from __future__ import absolute_import
 
26
 
26
27
import operator
27
28
 
28
29
from bzrlib.lazy_import import lazy_import
29
30
lazy_import(globals(), """
30
31
from bzrlib import (
31
 
    graph as _mod_graph,
32
32
    tsort,
33
33
    versionedfile,
 
34
    vf_search,
34
35
    )
35
36
""")
36
37
from bzrlib import (
161
162
        elif self._last_revision == NULL_REVISION:
162
163
            # fetch_spec is None + last_revision is null => empty fetch.
163
164
            # explicit limit of no revisions needed
164
 
            return _mod_graph.EmptySearchResult()
 
165
            return vf_search.EmptySearchResult()
165
166
        elif self._last_revision is not None:
166
 
            return _mod_graph.NotInOtherForRevs(self.to_repository,
 
167
            return vf_search.NotInOtherForRevs(self.to_repository,
167
168
                self.from_repository, [self._last_revision],
168
169
                find_ghosts=self.find_ghosts).execute()
169
170
        else: # self._last_revision is None:
170
 
            return _mod_graph.EverythingNotInOther(self.to_repository,
 
171
            return vf_search.EverythingNotInOther(self.to_repository,
171
172
                self.from_repository,
172
173
                find_ghosts=self.find_ghosts).execute()
173
174
 
202
203
        revs = list(revs)
203
204
        while revs:
204
205
            for tree in self.source.revision_trees(revs[:100]):
205
 
                if tree.inventory.revision_id is None:
206
 
                    tree.inventory.revision_id = tree.get_revision_id()
 
206
                if tree.root_inventory.revision_id is None:
 
207
                    tree.root_inventory.revision_id = tree.get_revision_id()
207
208
                yield tree
208
209
            revs = revs[100:]
209
210
 
210
211
    def _find_root_ids(self, revs, parent_map, graph):
211
212
        revision_root = {}
212
213
        for tree in self.iter_rev_trees(revs):
213
 
            revision_id = tree.inventory.root.revision
214
214
            root_id = tree.get_root_id()
 
215
            revision_id = tree.get_file_revision(root_id, u"")
215
216
            revision_root[revision_id] = root_id
216
217
        # Find out which parents we don't already know root ids for
217
218
        parents = set()
389
390
                    "limit is only supported with a source branch set")
390
391
            # Caller hasn't specified any revisions or source branch
391
392
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
392
 
                return _mod_graph.EverythingResult(self.source_repo)
 
393
                return vf_search.EverythingResult(self.source_repo)
393
394
            else:
394
395
                # We want everything not already in the target (or target's
395
396
                # fallbacks).
396
 
                return _mod_graph.EverythingNotInOther(
 
397
                return vf_search.EverythingNotInOther(
397
398
                    self.target_repo, self.source_repo).execute()
398
399
        heads_to_fetch = set(self._explicit_rev_ids)
399
400
        if self.source_branch is not None:
416
417
            # heads_to_fetch will almost certainly be present so this doesn't
417
418
            # matter much.
418
419
            all_heads = heads_to_fetch.union(if_present_fetch)
419
 
            ret = _mod_graph.PendingAncestryResult(all_heads, self.source_repo)
 
420
            ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
420
421
            if self.limit is not None:
421
422
                graph = self.source_repo.get_graph()
422
423
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
424
425
                ret = self.source_repo.revision_ids_to_search_result(result_set)
425
426
            return ret
426
427
        else:
427
 
            return _mod_graph.NotInOtherForRevs(self.target_repo, self.source_repo,
 
428
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
428
429
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
429
430
                limit=self.limit).execute()