53
54
def __init__(self, to_repository, from_repository, last_revision=None,
54
find_ghosts=True, fetch_spec=None):
55
pb=None, find_ghosts=True, fetch_spec=None):
55
56
"""Create a repo fetcher.
57
58
:param last_revision: If set, try to limit to the data this revision
59
:param fetch_spec: A SearchResult specifying which revisions to fetch.
60
If set, this overrides last_revision.
61
60
:param find_ghosts: If True search the entire history for ghosts.
61
:param pb: ProgressBar object to use; deprecated and ignored.
62
This method will just create one on top of the stack.
65
symbol_versioning.warn(
66
symbol_versioning.deprecated_in((1, 14, 0))
67
% "pb parameter to RepoFetcher.__init__")
68
# and for simplicity it is in fact ignored
63
69
# repository.fetch has the responsibility for short-circuiting
64
70
# attempts to copy between a repository and itself.
65
71
self.to_repository = to_repository
95
101
pb = ui.ui_factory.nested_progress_bar()
96
102
pb.show_pct = pb.show_count = False
98
pb.update(gettext("Finding revisions"), 0, 2)
99
search_result = self._revids_to_fetch()
100
mutter('fetching: %s', search_result)
101
if search_result.is_empty():
104
pb.update("Finding revisions", 0, 2)
105
search = self._revids_to_fetch()
103
pb.update(gettext("Fetching revisions"), 1, 2)
104
self._fetch_everything_for_search(search_result)
108
pb.update("Fetching revisions", 1, 2)
109
self._fetch_everything_for_search(search)
153
161
"""Determines the exact revisions needed from self.from_repository to
154
162
install self._last_revision in self.to_repository.
156
:returns: A SearchResult of some sort. (Possibly a
157
PendingAncestryResult, EmptySearchResult, etc.)
164
If no revisions need to be fetched, then this just returns None.
159
166
if self._fetch_spec is not None:
160
# The fetch spec is already a concrete search result.
161
167
return self._fetch_spec
162
elif self._last_revision == NULL_REVISION:
163
# fetch_spec is None + last_revision is null => empty fetch.
168
mutter('fetch up to rev {%s}', self._last_revision)
169
if self._last_revision is NULL_REVISION:
164
170
# explicit limit of no revisions needed
165
return vf_search.EmptySearchResult()
166
elif self._last_revision is not None:
167
return vf_search.NotInOtherForRevs(self.to_repository,
168
self.from_repository, [self._last_revision],
169
find_ghosts=self.find_ghosts).execute()
170
else: # self._last_revision is None:
171
return vf_search.EverythingNotInOther(self.to_repository,
172
self.from_repository,
173
find_ghosts=self.find_ghosts).execute()
172
return self.to_repository.search_missing_revision_ids(
173
self.from_repository, self._last_revision,
174
find_ghosts=self.find_ghosts)
176
def _parent_inventories(self, revision_ids):
177
# Find all the parent revisions referenced by the stream, but
178
# not present in the stream, and make sure we send their
180
parent_maps = self.to_repository.get_parent_map(revision_ids)
182
map(parents.update, parent_maps.itervalues())
183
parents.discard(NULL_REVISION)
184
parents.difference_update(revision_ids)
185
missing_keys = set(('inventories', rev_id) for rev_id in parents)
176
189
class Inter1and2Helper(object):
203
213
revs = list(revs)
205
215
for tree in self.source.revision_trees(revs[:100]):
206
if tree.root_inventory.revision_id is None:
207
tree.root_inventory.revision_id = tree.get_revision_id()
216
if tree.inventory.revision_id is None:
217
tree.inventory.revision_id = tree.get_revision_id()
209
219
revs = revs[100:]
211
221
def _find_root_ids(self, revs, parent_map, graph):
212
222
revision_root = {}
213
223
for tree in self.iter_rev_trees(revs):
224
revision_id = tree.inventory.root.revision
214
225
root_id = tree.get_root_id()
215
revision_id = tree.get_file_revision(root_id, u"")
216
226
revision_root[revision_id] = root_id
217
227
# Find out which parents we don't already know root ids for
243
253
# yet, and are unlikely to in non-rich-root environments anyway.
244
254
root_id_order.sort(key=operator.itemgetter(0))
245
255
# Create a record stream containing the roots to create.
246
if len(revs) > self.known_graph_threshold:
247
graph = self.source.get_known_graph_ancestry(revs)
257
# XXX: not covered by tests, should have a flag to always run
258
# this. -- mbp 20100129
259
graph = _get_rich_root_heads_graph(self.source, revs)
248
260
new_roots_stream = _new_root_data_stream(
249
261
root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
250
262
return [('texts', new_roots_stream)]
265
def _get_rich_root_heads_graph(source_repo, revision_ids):
266
"""Get a Graph object suitable for asking heads() for new rich roots."""
267
st = static_tuple.StaticTuple
268
revision_keys = [st(r_id).intern() for r_id in revision_ids]
269
known_graph = source_repo.revisions.get_known_graph_ancestry(
271
return _mod_graph.GraphThunkIdsToKeys(known_graph)
253
274
def _new_root_data_stream(
254
275
root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
255
276
"""Generate a texts substream of synthesised root entries.
333
354
selected_ids.append(parent_id)
334
355
parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
335
356
return parent_keys
338
class TargetRepoKinds(object):
339
"""An enum-like set of constants.
341
They are the possible values of FetchSpecFactory.target_repo_kinds.
344
PREEXISTING = 'preexisting'
349
class FetchSpecFactory(object):
350
"""A helper for building the best fetch spec for a sprout call.
352
Factors that go into determining the sort of fetch to perform:
353
* did the caller specify any revision IDs?
354
* did the caller specify a source branch (need to fetch its
355
heads_to_fetch(), usually the tip + tags)
356
* is there an existing target repo (don't need to refetch revs it
358
* target is stacked? (similar to pre-existing target repo: even if
359
the target itself is new don't want to refetch existing revs)
361
:ivar source_branch: the source branch if one specified, else None.
362
:ivar source_branch_stop_revision_id: fetch up to this revision of
363
source_branch, rather than its tip.
364
:ivar source_repo: the source repository if one found, else None.
365
:ivar target_repo: the target repository acquired by sprout.
366
:ivar target_repo_kind: one of the TargetRepoKinds constants.
370
self._explicit_rev_ids = set()
371
self.source_branch = None
372
self.source_branch_stop_revision_id = None
373
self.source_repo = None
374
self.target_repo = None
375
self.target_repo_kind = None
378
def add_revision_ids(self, revision_ids):
379
"""Add revision_ids to the set of revision_ids to be fetched."""
380
self._explicit_rev_ids.update(revision_ids)
382
def make_fetch_spec(self):
383
"""Build a SearchResult or PendingAncestryResult or etc."""
384
if self.target_repo_kind is None or self.source_repo is None:
385
raise AssertionError(
386
'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
387
if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
388
if self.limit is not None:
389
raise NotImplementedError(
390
"limit is only supported with a source branch set")
391
# Caller hasn't specified any revisions or source branch
392
if self.target_repo_kind == TargetRepoKinds.EMPTY:
393
return vf_search.EverythingResult(self.source_repo)
395
# We want everything not already in the target (or target's
397
return vf_search.EverythingNotInOther(
398
self.target_repo, self.source_repo).execute()
399
heads_to_fetch = set(self._explicit_rev_ids)
400
if self.source_branch is not None:
401
must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
402
if self.source_branch_stop_revision_id is not None:
403
# Replace the tip rev from must_fetch with the stop revision
404
# XXX: this might be wrong if the tip rev is also in the
405
# must_fetch set for other reasons (e.g. it's the tip of
406
# multiple loom threads?), but then it's pretty unclear what it
407
# should mean to specify a stop_revision in that case anyway.
408
must_fetch.discard(self.source_branch.last_revision())
409
must_fetch.add(self.source_branch_stop_revision_id)
410
heads_to_fetch.update(must_fetch)
412
if_present_fetch = set()
413
if self.target_repo_kind == TargetRepoKinds.EMPTY:
414
# PendingAncestryResult does not raise errors if a requested head
415
# is absent. Ideally it would support the
416
# required_ids/if_present_ids distinction, but in practice
417
# heads_to_fetch will almost certainly be present so this doesn't
419
all_heads = heads_to_fetch.union(if_present_fetch)
420
ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
421
if self.limit is not None:
422
graph = self.source_repo.get_graph()
423
topo_order = list(graph.iter_topo_order(ret.get_keys()))
424
result_set = topo_order[:self.limit]
425
ret = self.source_repo.revision_ids_to_search_result(result_set)
428
return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
429
required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
430
limit=self.limit).execute()
added
removed
bzrlib/fetch.py
