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