21
21
that has merged into it. As the first step of a merge, pull, or
22
22
branch operation we copy history from the source into the destination
25
The copying is done in a slightly complicated order. We don't want to
26
add a revision to the store until everything it refers to is also
27
stored, so that if a revision is present we can totally recreate it.
28
However, we can't know what files are included in a revision until we
29
read its inventory. So we query the inventory store of the source for
30
the ids we need, and then pull those ids and finally actually join
33
from bzrlib.errors import InstallFailed
35
import bzrlib.errors as errors
36
from bzrlib.errors import (InstallFailed,
34
38
from bzrlib.progress import ProgressPhase
35
39
from bzrlib.revision import NULL_REVISION
36
from bzrlib.tsort import topo_sort
40
from bzrlib.symbol_versioning import (deprecated_function,
37
44
from bzrlib.trace import mutter
39
from bzrlib.versionedfile import FulltextContentFactory
48
# TODO: Avoid repeatedly opening weaves so many times.
50
# XXX: This doesn't handle ghost (not present in branch) revisions at
51
# all yet. I'm not sure they really should be supported.
53
# NOTE: This doesn't copy revisions which may be present but not
54
# merged into the last revision. I'm not sure we want to do that.
56
# - get a list of revisions that need to be pulled in
57
# - for each one, pull in that revision file
58
# and get the inventory, and store the inventory with right
60
# - and get the ancestry, and store that with right parents too
61
# - and keep a note of all file ids and version seen
62
# - then go through all files; for each one get the weave,
63
# and add in all file versions
66
@deprecated_function(zero_eight)
67
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
68
"""Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
69
f = Fetcher(to_branch, from_branch, revision, pb)
70
return f.count_copied, f.failed_revisions
42
75
class RepoFetcher(object):
43
76
"""Pull revisions and texts from one repository to another.
45
This should not be used directly, it's essential a object to encapsulate
79
if set, try to limit to the data this revision references.
82
count_copied -- number of revisions copied
84
This should not be used directory, its essential a object to encapsulate
46
85
the logic in InterRepository.fetch().
49
def __init__(self, to_repository, from_repository, last_revision=None,
50
pb=None, find_ghosts=True, fetch_spec=None):
51
"""Create a repo fetcher.
53
:param last_revision: If set, try to limit to the data this revision
55
:param find_ghosts: If True search the entire history for ghosts.
56
:param _write_group_acquired_callable: Don't use; this parameter only
57
exists to facilitate a hack done in InterPackRepo.fetch. We would
58
like to remove this parameter.
59
:param pb: ProgressBar object to use; deprecated and ignored.
60
This method will just create one on top of the stack.
63
symbol_versioning.warn(
64
symbol_versioning.deprecated_in((1, 14, 0))
65
% "pb parameter to RepoFetcher.__init__")
66
# and for simplicity it is in fact ignored
67
if to_repository.has_same_location(from_repository):
68
# repository.fetch should be taking care of this case.
69
raise errors.BzrError('RepoFetcher run '
70
'between two objects at the same location: '
71
'%r and %r' % (to_repository, from_repository))
87
def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
89
self.failed_revisions = []
91
if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
92
# check that last_revision is in 'from' and then return a no-operation.
93
if last_revision not in (None, NULL_REVISION):
94
from_repository.get_revision(last_revision)
72
96
self.to_repository = to_repository
73
97
self.from_repository = from_repository
74
self.sink = to_repository._get_sink()
75
98
# must not mutate self._last_revision as its potentially a shared instance
76
99
self._last_revision = last_revision
77
self._fetch_spec = fetch_spec
78
self.find_ghosts = find_ghosts
101
self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
102
self.nested_pb = self.pb
105
self.nested_pb = None
79
106
self.from_repository.lock_read()
80
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
81
self.from_repository, self.from_repository._format,
82
self.to_repository, self.to_repository._format)
108
self.to_repository.lock_write()
112
if self.nested_pb is not None:
113
self.nested_pb.finished()
114
self.to_repository.unlock()
86
116
self.from_repository.unlock()
88
118
def __fetch(self):
89
119
"""Primary worker function.
91
This initialises all the needed variables, and then fetches the
121
This initialises all the needed variables, and then fetches the
92
122
requested revisions, finally clearing the progress bar.
94
# Roughly this is what we're aiming for fetch to become:
96
# missing = self.sink.insert_stream(self.source.get_stream(search))
98
# missing = self.sink.insert_stream(self.source.get_items(missing))
124
self.to_weaves = self.to_repository.weave_store
125
self.to_control = self.to_repository.control_weaves
126
self.from_weaves = self.from_repository.weave_store
127
self.from_control = self.from_repository.control_weaves
100
128
self.count_total = 0
101
129
self.file_ids_names = {}
102
pb = bzrlib.ui.ui_factory.nested_progress_bar()
103
pb.show_pct = pb.show_count = False
105
pb.update("Finding revisions", 0, 2)
106
search = self._revids_to_fetch()
109
pb.update("Fetching revisions", 1, 2)
110
self._fetch_everything_for_search(search)
114
def _fetch_everything_for_search(self, search):
115
"""Fetch all data for the given set of revisions."""
116
# The first phase is "file". We pass the progress bar for it directly
117
# into item_keys_introduced_by, which has more information about how
118
# that phase is progressing than we do. Progress updates for the other
119
# phases are taken care of in this function.
120
# XXX: there should be a clear owner of the progress reporting. Perhaps
121
# item_keys_introduced_by should have a richer API than it does at the
122
# moment, so that it can feed the progress information back to this
124
if (self.from_repository._format.rich_root_data and
125
not self.to_repository._format.rich_root_data):
126
raise errors.IncompatibleRepositories(
127
self.from_repository, self.to_repository,
128
"different rich-root support")
129
pb = bzrlib.ui.ui_factory.nested_progress_bar()
131
pb.update("Get stream source")
132
source = self.from_repository._get_source(
133
self.to_repository._format)
134
stream = source.get_stream(search)
135
from_format = self.from_repository._format
136
pb.update("Inserting stream")
137
resume_tokens, missing_keys = self.sink.insert_stream(
138
stream, from_format, [])
140
pb.update("Missing keys")
141
stream = source.get_stream_for_missing_keys(missing_keys)
142
pb.update("Inserting missing keys")
143
resume_tokens, missing_keys = self.sink.insert_stream(
144
stream, from_format, resume_tokens)
146
raise AssertionError(
147
"second push failed to complete a fetch %r." % (
150
raise AssertionError(
151
"second push failed to commit the fetch %r." % (
153
pb.update("Finishing stream")
130
pp = ProgressPhase('Fetch phase', 4, self.pb)
133
revs = self._revids_to_fetch()
137
self._fetch_weave_texts(revs)
139
self._fetch_inventory_weave(revs)
141
self._fetch_revision_texts(revs)
142
self.count_copied += len(revs)
158
146
def _revids_to_fetch(self):
159
"""Determines the exact revisions needed from self.from_repository to
160
install self._last_revision in self.to_repository.
162
If no revisions need to be fetched, then this just returns None.
164
if self._fetch_spec is not None:
165
return self._fetch_spec
166
147
mutter('fetch up to rev {%s}', self._last_revision)
167
148
if self._last_revision is NULL_REVISION:
168
149
# explicit limit of no revisions needed
170
151
if (self._last_revision is not None and
171
152
self.to_repository.has_revision(self._last_revision)):
174
return self.to_repository.search_missing_revision_ids(
175
self.from_repository, self._last_revision,
176
find_ghosts=self.find_ghosts)
177
except errors.NoSuchRevision, e:
156
return self.to_repository.missing_revision_ids(self.from_repository,
158
except errors.NoSuchRevision:
178
159
raise InstallFailed([self._last_revision])
161
def _fetch_weave_texts(self, revs):
162
texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
164
# fileids_altered_by_revision_ids requires reading the inventory
165
# weave, we will need to read the inventory weave again when
166
# all this is done, so enable caching for that specific weave
167
inv_w = self.from_repository.get_inventory_weave()
169
file_ids = self.from_repository.fileids_altered_by_revision_ids(revs)
171
num_file_ids = len(file_ids)
172
for file_id, required_versions in file_ids.items():
173
texts_pb.update("fetch texts", count, num_file_ids)
175
to_weave = self.to_weaves.get_weave_or_empty(file_id,
176
self.to_repository.get_transaction())
177
from_weave = self.from_weaves.get_weave(file_id,
178
self.from_repository.get_transaction())
179
# we fetch all the texts, because texts do
180
# not reference anything, and its cheap enough
181
to_weave.join(from_weave, version_ids=required_versions)
182
# we don't need *all* of this data anymore, but we dont know
183
# what we do. This cache clearing will result in a new read
184
# of the knit data when we do the checkout, but probably we
185
# want to emit the needed data on the fly rather than at the
187
# the from weave should know not to cache data being joined,
188
# but its ok to ask it to clear.
189
from_weave.clear_cache()
190
to_weave.clear_cache()
194
def _fetch_inventory_weave(self, revs):
195
pb = bzrlib.ui.ui_factory.nested_progress_bar()
197
pb.update("fetch inventory", 0, 2)
198
to_weave = self.to_control.get_weave('inventory',
199
self.to_repository.get_transaction())
201
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
203
# just merge, this is optimisable and its means we don't
204
# copy unreferenced data such as not-needed inventories.
205
pb.update("fetch inventory", 1, 3)
206
from_weave = self.from_repository.get_inventory_weave()
207
pb.update("fetch inventory", 2, 3)
208
# we fetch only the referenced inventories because we do not
209
# know for unselected inventories whether all their required
210
# texts are present in the other repository - it could be
212
to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
214
from_weave.clear_cache()
221
class GenericRepoFetcher(RepoFetcher):
222
"""This is a generic repo to repo fetcher.
224
This makes minimal assumptions about repo layout and contents.
225
It triggers a reconciliation after fetching to ensure integrity.
228
def _fetch_revision_texts(self, revs):
229
"""Fetch revision object texts"""
230
rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
232
to_txn = self.to_transaction = self.to_repository.get_transaction()
235
to_store = self.to_repository._revision_store
237
pb = bzrlib.ui.ui_factory.nested_progress_bar()
239
pb.update('copying revisions', count, total)
241
sig_text = self.from_repository.get_signature_text(rev)
242
to_store.add_revision_signature_text(rev, sig_text, to_txn)
243
except errors.NoSuchRevision:
246
to_store.add_revision(self.from_repository.get_revision(rev),
251
# fixup inventory if needed:
252
# this is expensive because we have no inverse index to current ghosts.
253
# but on local disk its a few seconds and sftp push is already insane.
255
# FIXME: repository should inform if this is needed.
256
self.to_repository.reconcile()
261
class KnitRepoFetcher(RepoFetcher):
262
"""This is a knit format repository specific fetcher.
264
This differs from the GenericRepoFetcher by not doing a
265
reconciliation after copying, and using knit joining to
269
def _fetch_revision_texts(self, revs):
270
# may need to be a InterRevisionStore call here.
271
from_transaction = self.from_repository.get_transaction()
272
to_transaction = self.to_repository.get_transaction()
273
to_sf = self.to_repository._revision_store.get_signature_file(
275
from_sf = self.from_repository._revision_store.get_signature_file(
277
to_sf.join(from_sf, version_ids=revs, ignore_missing=True)
278
to_rf = self.to_repository._revision_store.get_revision_file(
280
from_rf = self.from_repository._revision_store.get_revision_file(
282
to_rf.join(from_rf, version_ids=revs)
181
285
class Inter1and2Helper(object):
182
286
"""Helper for operations that convert data from model 1 and 2
184
288
This is for use by fetchers and converters.
187
def __init__(self, source):
291
def __init__(self, source, target):
190
294
:param source: The repository data comes from
295
:param target: The repository data goes to
192
297
self.source = source
194
300
def iter_rev_trees(self, revs):
195
301
"""Iterate through RevisionTrees efficiently.
211
315
revs = revs[100:]
213
def _find_root_ids(self, revs, parent_map, graph):
215
planned_versions = {}
216
for tree in self.iter_rev_trees(revs):
217
revision_id = tree.inventory.root.revision
218
root_id = tree.get_root_id()
219
planned_versions.setdefault(root_id, []).append(revision_id)
220
revision_root[revision_id] = root_id
221
# Find out which parents we don't already know root ids for
223
for revision_parents in parent_map.itervalues():
224
parents.update(revision_parents)
225
parents.difference_update(revision_root.keys() + [NULL_REVISION])
226
# Limit to revisions present in the versionedfile
227
parents = graph.get_parent_map(parents).keys()
228
for tree in self.iter_rev_trees(parents):
229
root_id = tree.get_root_id()
230
revision_root[tree.get_revision_id()] = root_id
231
return revision_root, planned_versions
233
317
def generate_root_texts(self, revs):
234
318
"""Generate VersionedFiles for all root ids.
236
320
:param revs: the revisions to include
238
graph = self.source.get_graph()
239
parent_map = graph.get_parent_map(revs)
240
rev_order = topo_sort(parent_map)
241
rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
242
revs, parent_map, graph)
243
root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
245
# Guaranteed stable, this groups all the file id operations together
246
# retaining topological order within the revisions of a file id.
247
# File id splits and joins would invalidate this, but they don't exist
248
# yet, and are unlikely to in non-rich-root environments anyway.
249
root_id_order.sort(key=operator.itemgetter(0))
250
# Create a record stream containing the roots to create.
252
for key in root_id_order:
253
root_id, rev_id = key
254
rev_parents = parent_map[rev_id]
255
# We drop revision parents with different file-ids, because
256
# that represents a rename of the root to a different location
257
# - its not actually a parent for us. (We could look for that
258
# file id in the revision tree at considerably more expense,
259
# but for now this is sufficient (and reconcile will catch and
260
# correct this anyway).
261
# When a parent revision is a ghost, we guess that its root id
262
# was unchanged (rather than trimming it from the parent list).
263
parent_keys = tuple((root_id, parent) for parent in rev_parents
264
if parent != NULL_REVISION and
265
rev_id_to_root_id.get(parent, root_id) == root_id)
266
yield FulltextContentFactory(key, parent_keys, None, '')
267
return [('texts', yield_roots())]
322
inventory_weave = self.source.get_inventory_weave()
325
to_store = self.target.weave_store
326
for tree in self.iter_rev_trees(revs):
327
revision_id = tree.inventory.root.revision
328
root_id = tree.inventory.root.file_id
329
parents = inventory_weave.get_parents(revision_id)
330
if root_id not in versionedfile:
331
versionedfile[root_id] = to_store.get_weave_or_empty(root_id,
332
self.target.get_transaction())
333
parent_texts[root_id] = versionedfile[root_id].add_lines(
334
revision_id, parents, [], parent_texts)
336
def regenerate_inventory(self, revs):
337
"""Generate a new inventory versionedfile in target, convertin data.
339
The inventory is retrieved from the source, (deserializing it), and
340
stored in the target (reserializing it in a different format).
341
:param revs: The revisions to include
343
inventory_weave = self.source.get_inventory_weave()
344
for tree in self.iter_rev_trees(revs):
345
parents = inventory_weave.get_parents(tree.get_revision_id())
346
self.target.add_inventory(tree.get_revision_id(), tree.inventory,
350
class Model1toKnit2Fetcher(GenericRepoFetcher):
351
"""Fetch from a Model1 repository into a Knit2 repository
353
def __init__(self, to_repository, from_repository, last_revision=None,
355
self.helper = Inter1and2Helper(from_repository, to_repository)
356
GenericRepoFetcher.__init__(self, to_repository, from_repository,
359
def _fetch_weave_texts(self, revs):
360
GenericRepoFetcher._fetch_weave_texts(self, revs)
361
# Now generate a weave for the tree root
362
self.helper.generate_root_texts(revs)
364
def _fetch_inventory_weave(self, revs):
365
self.helper.regenerate_inventory(revs)
368
class Knit1to2Fetcher(KnitRepoFetcher):
369
"""Fetch from a Knit1 repository into a Knit2 repository"""
371
def __init__(self, to_repository, from_repository, last_revision=None,
373
self.helper = Inter1and2Helper(from_repository, to_repository)
374
KnitRepoFetcher.__init__(self, to_repository, from_repository,
377
def _fetch_weave_texts(self, revs):
378
KnitRepoFetcher._fetch_weave_texts(self, revs)
379
# Now generate a weave for the tree root
380
self.helper.generate_root_texts(revs)
382
def _fetch_inventory_weave(self, revs):
383
self.helper.regenerate_inventory(revs)
386
class Fetcher(object):
387
"""Backwards compatibility glue for branch.fetch()."""
389
@deprecated_method(zero_eight)
390
def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
391
"""Please see branch.fetch()."""
392
to_branch.fetch(from_branch, last_revision, pb)
added
removed
bzrlib/fetch.py
