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
47
from bzrlib.lazy_import import lazy_import
49
# TODO: Avoid repeatedly opening weaves so many times.
51
# XXX: This doesn't handle ghost (not present in branch) revisions at
52
# all yet. I'm not sure they really should be supported.
54
# NOTE: This doesn't copy revisions which may be present but not
55
# merged into the last revision. I'm not sure we want to do that.
57
# - get a list of revisions that need to be pulled in
58
# - for each one, pull in that revision file
59
# and get the inventory, and store the inventory with right
61
# - and get the ancestry, and store that with right parents too
62
# - and keep a note of all file ids and version seen
63
# - then go through all files; for each one get the weave,
64
# and add in all file versions
67
@deprecated_function(zero_eight)
68
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
69
"""Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
70
f = Fetcher(to_branch, from_branch, revision, pb)
71
return f.count_copied, f.failed_revisions
42
76
class RepoFetcher(object):
43
77
"""Pull revisions and texts from one repository to another.
45
This should not be used directly, it's essential a object to encapsulate
80
if set, try to limit to the data this revision references.
83
count_copied -- number of revisions copied
85
This should not be used directory, its essential a object to encapsulate
46
86
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))
88
def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
90
self.failed_revisions = []
92
if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
93
# check that last_revision is in 'from' and then return a no-operation.
94
if last_revision not in (None, NULL_REVISION):
95
to_repository.get_revision(last_revision)
72
97
self.to_repository = to_repository
73
98
self.from_repository = from_repository
74
self.sink = to_repository._get_sink()
75
99
# must not mutate self._last_revision as its potentially a shared instance
76
100
self._last_revision = last_revision
77
self._fetch_spec = fetch_spec
78
self.find_ghosts = find_ghosts
102
self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
103
self.nested_pb = self.pb
106
self.nested_pb = None
79
107
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)
109
self.to_repository.lock_write()
113
if self.nested_pb is not None:
114
self.nested_pb.finished()
115
self.to_repository.unlock()
86
117
self.from_repository.unlock()
88
119
def __fetch(self):
89
120
"""Primary worker function.
91
This initialises all the needed variables, and then fetches the
122
This initialises all the needed variables, and then fetches the
92
123
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))
125
self.to_weaves = self.to_repository.weave_store
126
self.to_control = self.to_repository.control_weaves
127
self.from_weaves = self.from_repository.weave_store
128
self.from_control = self.from_repository.control_weaves
100
129
self.count_total = 0
101
130
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")
131
pp = ProgressPhase('Fetch phase', 4, self.pb)
134
revs = self._revids_to_fetch()
138
self._fetch_weave_texts(revs)
140
self._fetch_inventory_weave(revs)
142
self._fetch_revision_texts(revs)
143
self.count_copied += len(revs)
158
147
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
148
mutter('fetch up to rev {%s}', self._last_revision)
167
149
if self._last_revision is NULL_REVISION:
168
150
# explicit limit of no revisions needed
170
152
if (self._last_revision is not None and
171
153
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:
157
return self.to_repository.missing_revision_ids(self.from_repository,
159
except errors.NoSuchRevision:
178
160
raise InstallFailed([self._last_revision])
162
def _fetch_weave_texts(self, revs):
163
texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
165
# fileids_altered_by_revision_ids requires reading the inventory
166
# weave, we will need to read the inventory weave again when
167
# all this is done, so enable caching for that specific weave
168
inv_w = self.from_repository.get_inventory_weave()
170
file_ids = self.from_repository.fileids_altered_by_revision_ids(revs)
172
num_file_ids = len(file_ids)
173
for file_id, required_versions in file_ids.items():
174
texts_pb.update("fetch texts", count, num_file_ids)
176
to_weave = self.to_weaves.get_weave_or_empty(file_id,
177
self.to_repository.get_transaction())
178
from_weave = self.from_weaves.get_weave(file_id,
179
self.from_repository.get_transaction())
180
# we fetch all the texts, because texts do
181
# not reference anything, and its cheap enough
182
to_weave.join(from_weave, version_ids=required_versions)
183
# we don't need *all* of this data anymore, but we dont know
184
# what we do. This cache clearing will result in a new read
185
# of the knit data when we do the checkout, but probably we
186
# want to emit the needed data on the fly rather than at the
188
# the from weave should know not to cache data being joined,
189
# but its ok to ask it to clear.
190
from_weave.clear_cache()
191
to_weave.clear_cache()
195
def _fetch_inventory_weave(self, revs):
196
pb = bzrlib.ui.ui_factory.nested_progress_bar()
198
pb.update("fetch inventory", 0, 2)
199
to_weave = self.to_control.get_weave('inventory',
200
self.to_repository.get_transaction())
202
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
204
# just merge, this is optimisable and its means we don't
205
# copy unreferenced data such as not-needed inventories.
206
pb.update("fetch inventory", 1, 3)
207
from_weave = self.from_repository.get_inventory_weave()
208
pb.update("fetch inventory", 2, 3)
209
# we fetch only the referenced inventories because we do not
210
# know for unselected inventories whether all their required
211
# texts are present in the other repository - it could be
213
to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
215
from_weave.clear_cache()
222
class GenericRepoFetcher(RepoFetcher):
223
"""This is a generic repo to repo fetcher.
225
This makes minimal assumptions about repo layout and contents.
226
It triggers a reconciliation after fetching to ensure integrity.
229
def _fetch_revision_texts(self, revs):
230
"""Fetch revision object texts"""
231
rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
233
to_txn = self.to_transaction = self.to_repository.get_transaction()
236
to_store = self.to_repository._revision_store
238
pb = bzrlib.ui.ui_factory.nested_progress_bar()
240
pb.update('copying revisions', count, total)
242
sig_text = self.from_repository.get_signature_text(rev)
243
to_store.add_revision_signature_text(rev, sig_text, to_txn)
244
except errors.NoSuchRevision:
247
to_store.add_revision(self.from_repository.get_revision(rev),
252
# fixup inventory if needed:
253
# this is expensive because we have no inverse index to current ghosts.
254
# but on local disk its a few seconds and sftp push is already insane.
256
# FIXME: repository should inform if this is needed.
257
self.to_repository.reconcile()
262
class KnitRepoFetcher(RepoFetcher):
263
"""This is a knit format repository specific fetcher.
265
This differs from the GenericRepoFetcher by not doing a
266
reconciliation after copying, and using knit joining to
270
def _fetch_revision_texts(self, revs):
271
# may need to be a InterRevisionStore call here.
272
from_transaction = self.from_repository.get_transaction()
273
to_transaction = self.to_repository.get_transaction()
274
to_sf = self.to_repository._revision_store.get_signature_file(
276
from_sf = self.from_repository._revision_store.get_signature_file(
278
to_sf.join(from_sf, version_ids=revs, ignore_missing=True)
279
to_rf = self.to_repository._revision_store.get_revision_file(
281
from_rf = self.from_repository._revision_store.get_revision_file(
283
to_rf.join(from_rf, version_ids=revs)
181
286
class Inter1and2Helper(object):
182
287
"""Helper for operations that convert data from model 1 and 2
184
289
This is for use by fetchers and converters.
187
def __init__(self, source):
292
def __init__(self, source, target):
190
295
:param source: The repository data comes from
296
:param target: The repository data goes to
192
298
self.source = source
194
301
def iter_rev_trees(self, revs):
195
302
"""Iterate through RevisionTrees efficiently.
211
316
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
318
def generate_root_texts(self, revs):
234
319
"""Generate VersionedFiles for all root ids.
236
321
: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())]
323
inventory_weave = self.source.get_inventory_weave()
326
to_store = self.target.weave_store
327
for tree in self.iter_rev_trees(revs):
328
revision_id = tree.inventory.root.revision
329
root_id = tree.inventory.root.file_id
330
parents = inventory_weave.get_parents(revision_id)
331
if root_id not in versionedfile:
332
versionedfile[root_id] = to_store.get_weave_or_empty(root_id,
333
self.target.get_transaction())
334
parent_texts[root_id] = versionedfile[root_id].add_lines(
335
revision_id, parents, [], parent_texts)
337
def regenerate_inventory(self, revs):
338
"""Generate a new inventory versionedfile in target, convertin data.
340
The inventory is retrieved from the source, (deserializing it), and
341
stored in the target (reserializing it in a different format).
342
:param revs: The revisions to include
344
inventory_weave = self.source.get_inventory_weave()
345
for tree in self.iter_rev_trees(revs):
346
parents = inventory_weave.get_parents(tree.get_revision_id())
347
self.target.add_inventory(tree.get_revision_id(), tree.inventory,
351
class Model1toKnit2Fetcher(GenericRepoFetcher):
352
"""Fetch from a Model1 repository into a Knit2 repository
354
def __init__(self, to_repository, from_repository, last_revision=None,
356
self.helper = Inter1and2Helper(from_repository, to_repository)
357
GenericRepoFetcher.__init__(self, to_repository, from_repository,
360
def _fetch_weave_texts(self, revs):
361
GenericRepoFetcher._fetch_weave_texts(self, revs)
362
# Now generate a weave for the tree root
363
self.helper.generate_root_texts(revs)
365
def _fetch_inventory_weave(self, revs):
366
self.helper.regenerate_inventory(revs)
369
class Knit1to2Fetcher(KnitRepoFetcher):
370
"""Fetch from a Knit1 repository into a Knit2 repository"""
372
def __init__(self, to_repository, from_repository, last_revision=None,
374
self.helper = Inter1and2Helper(from_repository, to_repository)
375
KnitRepoFetcher.__init__(self, to_repository, from_repository,
378
def _fetch_weave_texts(self, revs):
379
KnitRepoFetcher._fetch_weave_texts(self, revs)
380
# Now generate a weave for the tree root
381
self.helper.generate_root_texts(revs)
383
def _fetch_inventory_weave(self, revs):
384
self.helper.regenerate_inventory(revs)
387
class Fetcher(object):
388
"""Backwards compatibility glue for branch.fetch()."""
390
@deprecated_method(zero_eight)
391
def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
392
"""Please see branch.fetch()."""
393
to_branch.fetch(from_branch, last_revision, pb)
added
removed
bzrlib/fetch.py
