94
92
pb = ui.ui_factory.nested_progress_bar()
95
93
pb.show_pct = pb.show_count = False
97
pb.update(gettext("Finding revisions"), 0, 2)
98
search_result = self._revids_to_fetch()
99
mutter('fetching: %s', search_result)
100
if search_result.is_empty():
95
pb.update("Finding revisions", 0, 2)
96
search = self._revids_to_fetch()
102
pb.update(gettext("Fetching revisions"), 1, 2)
103
self._fetch_everything_for_search(search_result)
99
pb.update("Fetching revisions", 1, 2)
100
self._fetch_everything_for_search(search)
152
152
"""Determines the exact revisions needed from self.from_repository to
153
153
install self._last_revision in self.to_repository.
155
:returns: A SearchResult of some sort. (Possibly a
156
PendingAncestryResult, EmptySearchResult, etc.)
155
If no revisions need to be fetched, then this just returns None.
158
157
if self._fetch_spec is not None:
159
# The fetch spec is already a concrete search result.
160
158
return self._fetch_spec
161
elif self._last_revision == NULL_REVISION:
162
# fetch_spec is None + last_revision is null => empty fetch.
159
mutter('fetch up to rev {%s}', self._last_revision)
160
if self._last_revision is NULL_REVISION:
163
161
# explicit limit of no revisions needed
164
return _mod_graph.EmptySearchResult()
165
elif self._last_revision is not None:
166
return _mod_graph.NotInOtherForRevs(self.to_repository,
167
self.from_repository, [self._last_revision],
168
find_ghosts=self.find_ghosts).execute()
169
else: # self._last_revision is None:
170
return _mod_graph.EverythingNotInOther(self.to_repository,
171
self.from_repository,
172
find_ghosts=self.find_ghosts).execute()
163
return self.to_repository.search_missing_revision_ids(
164
self.from_repository, self._last_revision,
165
find_ghosts=self.find_ghosts)
167
def _parent_inventories(self, revision_ids):
168
# Find all the parent revisions referenced by the stream, but
169
# not present in the stream, and make sure we send their
171
parent_maps = self.to_repository.get_parent_map(revision_ids)
173
map(parents.update, parent_maps.itervalues())
174
parents.discard(NULL_REVISION)
175
parents.difference_update(revision_ids)
176
missing_keys = set(('inventories', rev_id) for rev_id in parents)
175
180
class Inter1and2Helper(object):
242
244
# yet, and are unlikely to in non-rich-root environments anyway.
243
245
root_id_order.sort(key=operator.itemgetter(0))
244
246
# Create a record stream containing the roots to create.
245
if len(revs) > self.known_graph_threshold:
246
graph = self.source.get_known_graph_ancestry(revs)
248
# XXX: not covered by tests, should have a flag to always run
249
# this. -- mbp 20100129
250
graph = self.source_repo.get_known_graph_ancestry(revs)
247
251
new_roots_stream = _new_root_data_stream(
248
252
root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
249
253
return [('texts', new_roots_stream)]
256
def _get_rich_root_heads_graph(source_repo, revision_ids):
257
"""Get a Graph object suitable for asking heads() for new rich roots."""
252
261
def _new_root_data_stream(
253
262
root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
254
263
"""Generate a texts substream of synthesised root entries.
332
341
selected_ids.append(parent_id)
333
342
parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
334
343
return parent_keys
337
class TargetRepoKinds(object):
338
"""An enum-like set of constants.
340
They are the possible values of FetchSpecFactory.target_repo_kinds.
343
PREEXISTING = 'preexisting'
348
class FetchSpecFactory(object):
349
"""A helper for building the best fetch spec for a sprout call.
351
Factors that go into determining the sort of fetch to perform:
352
* did the caller specify any revision IDs?
353
* did the caller specify a source branch (need to fetch its
354
heads_to_fetch(), usually the tip + tags)
355
* is there an existing target repo (don't need to refetch revs it
357
* target is stacked? (similar to pre-existing target repo: even if
358
the target itself is new don't want to refetch existing revs)
360
:ivar source_branch: the source branch if one specified, else None.
361
:ivar source_branch_stop_revision_id: fetch up to this revision of
362
source_branch, rather than its tip.
363
:ivar source_repo: the source repository if one found, else None.
364
:ivar target_repo: the target repository acquired by sprout.
365
:ivar target_repo_kind: one of the TargetRepoKinds constants.
369
self._explicit_rev_ids = set()
370
self.source_branch = None
371
self.source_branch_stop_revision_id = None
372
self.source_repo = None
373
self.target_repo = None
374
self.target_repo_kind = None
377
def add_revision_ids(self, revision_ids):
378
"""Add revision_ids to the set of revision_ids to be fetched."""
379
self._explicit_rev_ids.update(revision_ids)
381
def make_fetch_spec(self):
382
"""Build a SearchResult or PendingAncestryResult or etc."""
383
if self.target_repo_kind is None or self.source_repo is None:
384
raise AssertionError(
385
'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
386
if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
387
if self.limit is not None:
388
raise NotImplementedError(
389
"limit is only supported with a source branch set")
390
# Caller hasn't specified any revisions or source branch
391
if self.target_repo_kind == TargetRepoKinds.EMPTY:
392
return _mod_graph.EverythingResult(self.source_repo)
394
# We want everything not already in the target (or target's
396
return _mod_graph.EverythingNotInOther(
397
self.target_repo, self.source_repo).execute()
398
heads_to_fetch = set(self._explicit_rev_ids)
399
if self.source_branch is not None:
400
must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
401
if self.source_branch_stop_revision_id is not None:
402
# Replace the tip rev from must_fetch with the stop revision
403
# XXX: this might be wrong if the tip rev is also in the
404
# must_fetch set for other reasons (e.g. it's the tip of
405
# multiple loom threads?), but then it's pretty unclear what it
406
# should mean to specify a stop_revision in that case anyway.
407
must_fetch.discard(self.source_branch.last_revision())
408
must_fetch.add(self.source_branch_stop_revision_id)
409
heads_to_fetch.update(must_fetch)
411
if_present_fetch = set()
412
if self.target_repo_kind == TargetRepoKinds.EMPTY:
413
# PendingAncestryResult does not raise errors if a requested head
414
# is absent. Ideally it would support the
415
# required_ids/if_present_ids distinction, but in practice
416
# heads_to_fetch will almost certainly be present so this doesn't
418
all_heads = heads_to_fetch.union(if_present_fetch)
419
ret = _mod_graph.PendingAncestryResult(all_heads, self.source_repo)
420
if self.limit is not None:
421
graph = self.source_repo.get_graph()
422
topo_order = list(graph.iter_topo_order(ret.get_keys()))
423
result_set = topo_order[:self.limit]
424
ret = self.source_repo.revision_ids_to_search_result(result_set)
427
return _mod_graph.NotInOtherForRevs(self.target_repo, self.source_repo,
428
required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
429
limit=self.limit).execute()
added
removed
bzrlib/fetch.py
