60
60
# and add in all file versions
63
@deprecated_function(zero_eight)
64
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
65
"""Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
66
f = Fetcher(to_branch, from_branch, revision, pb)
67
return f.count_copied, f.failed_revisions
72
63
class RepoFetcher(object):
73
64
"""Pull revisions and texts from one repository to another.
76
67
if set, try to limit to the data this revision references.
79
count_copied -- number of revisions copied
81
This should not be used directory, its essential a object to encapsulate
69
This should not be used directly, it's essential a object to encapsulate
82
70
the logic in InterRepository.fetch().
84
def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
86
self.failed_revisions = []
88
if to_repository.control_files._transport.base == from_repository.control_files._transport.base:
89
# check that last_revision is in 'from' and then return a no-operation.
90
if last_revision not in (None, NULL_REVISION):
91
from_repository.get_revision(last_revision)
73
def __init__(self, to_repository, from_repository, last_revision=None,
74
pb=None, find_ghosts=True, fetch_spec=None):
75
"""Create a repo fetcher.
77
:param find_ghosts: If True search the entire history for ghosts.
78
:param _write_group_acquired_callable: Don't use; this parameter only
79
exists to facilitate a hack done in InterPackRepo.fetch. We would
80
like to remove this parameter.
82
if to_repository.has_same_location(from_repository):
83
# repository.fetch should be taking care of this case.
84
raise errors.BzrError('RepoFetcher run '
85
'between two objects at the same location: '
86
'%r and %r' % (to_repository, from_repository))
93
87
self.to_repository = to_repository
94
88
self.from_repository = from_repository
89
self.sink = to_repository._get_sink()
95
90
# must not mutate self._last_revision as its potentially a shared instance
96
91
self._last_revision = last_revision
92
self._fetch_spec = fetch_spec
93
self.find_ghosts = find_ghosts
98
95
self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
99
96
self.nested_pb = self.pb
102
99
self.nested_pb = None
103
100
self.from_repository.lock_read()
105
self.to_repository.lock_write()
109
105
if self.nested_pb is not None:
110
106
self.nested_pb.finished()
111
self.to_repository.unlock()
113
108
self.from_repository.unlock()
115
110
def __fetch(self):
116
111
"""Primary worker function.
118
This initialises all the needed variables, and then fetches the
113
This initialises all the needed variables, and then fetches the
119
114
requested revisions, finally clearing the progress bar.
121
self.to_weaves = self.to_repository.weave_store
122
self.to_control = self.to_repository.control_weaves
123
self.from_weaves = self.from_repository.weave_store
124
self.from_control = self.from_repository.control_weaves
116
# Roughly this is what we're aiming for fetch to become:
118
# missing = self.sink.insert_stream(self.source.get_stream(search))
120
# missing = self.sink.insert_stream(self.source.get_items(missing))
125
122
self.count_total = 0
126
123
self.file_ids_names = {}
127
pp = ProgressPhase('fetch phase', 4, self.pb)
124
pp = ProgressPhase('Transferring', 4, self.pb)
129
revs = self._revids_to_fetch()
133
self._fetch_weave_texts(revs)
135
self._fetch_inventory_weave(revs)
137
self._fetch_revision_texts(revs)
138
self.count_copied += len(revs)
127
search = self._revids_to_fetch()
130
self._fetch_everything_for_search(search, pp)
134
def _fetch_everything_for_search(self, search, pp):
135
"""Fetch all data for the given set of revisions."""
136
# The first phase is "file". We pass the progress bar for it directly
137
# into item_keys_introduced_by, which has more information about how
138
# that phase is progressing than we do. Progress updates for the other
139
# phases are taken care of in this function.
140
# XXX: there should be a clear owner of the progress reporting. Perhaps
141
# item_keys_introduced_by should have a richer API than it does at the
142
# moment, so that it can feed the progress information back to this
144
if (self.from_repository._format.rich_root_data and
145
not self.to_repository._format.rich_root_data):
146
raise errors.IncompatibleRepositories(
147
self.from_repository, self.to_repository,
148
"different rich-root support")
149
self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
151
source = self.from_repository._get_source(
152
self.to_repository._format)
153
stream = source.get_stream(search)
154
from_format = self.from_repository._format
155
resume_tokens, missing_keys = self.sink.insert_stream(
156
stream, from_format, [])
158
stream = source.get_stream_for_missing_keys(missing_keys)
159
resume_tokens, missing_keys = self.sink.insert_stream(
160
stream, from_format, resume_tokens)
162
raise AssertionError(
163
"second push failed to complete a fetch %r." % (
166
raise AssertionError(
167
"second push failed to commit the fetch %r." % (
171
if self.pb is not None:
142
174
def _revids_to_fetch(self):
175
"""Determines the exact revisions needed from self.from_repository to
176
install self._last_revision in self.to_repository.
178
If no revisions need to be fetched, then this just returns None.
180
if self._fetch_spec is not None:
181
return self._fetch_spec
143
182
mutter('fetch up to rev {%s}', self._last_revision)
144
183
if self._last_revision is NULL_REVISION:
145
184
# explicit limit of no revisions needed
147
if (self._last_revision != None and
186
if (self._last_revision is not None and
148
187
self.to_repository.has_revision(self._last_revision)):
152
return self.to_repository.missing_revision_ids(self.from_repository,
154
except errors.NoSuchRevision:
190
return self.to_repository.search_missing_revision_ids(
191
self.from_repository, self._last_revision,
192
find_ghosts=self.find_ghosts)
193
except errors.NoSuchRevision, e:
155
194
raise InstallFailed([self._last_revision])
157
def _fetch_weave_texts(self, revs):
158
texts_pb = bzrlib.ui.ui_factory.nested_progress_bar()
160
file_ids = self.from_repository.fileid_involved_by_set(revs)
162
num_file_ids = len(file_ids)
163
for file_id in file_ids:
164
texts_pb.update("fetch texts", count, num_file_ids)
167
to_weave = self.to_weaves.get_weave(file_id,
168
self.to_repository.get_transaction())
169
except errors.NoSuchFile:
170
# destination is empty, just copy it.
171
# this copies all the texts, which is useful and
172
# on per-file basis quite cheap.
173
self.to_weaves.copy_multi(
177
self.from_repository.get_transaction(),
178
self.to_repository.get_transaction())
180
# destination has contents, must merge
181
from_weave = self.from_weaves.get_weave(file_id,
182
self.from_repository.get_transaction())
183
# we fetch all the texts, because texts do
184
# not reference anything, and its cheap enough
185
to_weave.join(from_weave)
189
def _fetch_inventory_weave(self, revs):
190
pb = bzrlib.ui.ui_factory.nested_progress_bar()
192
pb.update("fetch inventory", 0, 2)
193
to_weave = self.to_control.get_weave('inventory',
194
self.to_repository.get_transaction())
196
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
198
# just merge, this is optimisable and its means we dont
199
# copy unreferenced data such as not-needed inventories.
200
pb.update("fetch inventory", 1, 3)
201
from_weave = self.from_repository.get_inventory_weave()
202
pb.update("fetch inventory", 2, 3)
203
# we fetch only the referenced inventories because we do not
204
# know for unselected inventories whether all their required
205
# texts are present in the other repository - it could be
207
to_weave.join(from_weave, pb=child_pb, msg='merge inventory',
215
class GenericRepoFetcher(RepoFetcher):
216
"""This is a generic repo to repo fetcher.
218
This makes minimal assumptions about repo layout and contents.
219
It triggers a reconciliation after fetching to ensure integrity.
222
def _fetch_revision_texts(self, revs):
223
"""Fetch revision object texts"""
224
rev_pb = bzrlib.ui.ui_factory.nested_progress_bar()
226
to_txn = self.to_transaction = self.to_repository.get_transaction()
229
to_store = self.to_repository._revision_store
231
pb = bzrlib.ui.ui_factory.nested_progress_bar()
233
pb.update('copying revisions', count, total)
235
sig_text = self.from_repository.get_signature_text(rev)
236
to_store.add_revision_signature_text(rev, sig_text, to_txn)
237
except errors.NoSuchRevision:
240
to_store.add_revision(self.from_repository.get_revision(rev),
245
# fixup inventory if needed:
246
# this is expensive because we have no inverse index to current ghosts.
247
# but on local disk its a few seconds and sftp push is already insane.
249
# FIXME: repository should inform if this is needed.
250
self.to_repository.reconcile()
255
class KnitRepoFetcher(RepoFetcher):
256
"""This is a knit format repository specific fetcher.
258
This differs from the GenericRepoFetcher by not doing a
259
reconciliation after copying, and using knit joining to
263
def _fetch_revision_texts(self, revs):
264
# may need to be a InterRevisionStore call here.
265
from_transaction = self.from_repository.get_transaction()
266
to_transaction = self.to_repository.get_transaction()
267
to_sf = self.to_repository._revision_store.get_signature_file(
269
from_sf = self.from_repository._revision_store.get_signature_file(
271
to_sf.join(from_sf, version_ids=revs, ignore_missing=True)
272
to_rf = self.to_repository._revision_store.get_revision_file(
274
from_rf = self.from_repository._revision_store.get_revision_file(
276
to_rf.join(from_rf, version_ids=revs)
279
class Fetcher(object):
280
"""Backwards compatability glue for branch.fetch()."""
282
@deprecated_method(zero_eight)
283
def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
284
"""Please see branch.fetch()."""
285
to_branch.fetch(from_branch, last_revision, pb)
197
class Inter1and2Helper(object):
198
"""Helper for operations that convert data from model 1 and 2
200
This is for use by fetchers and converters.
203
def __init__(self, source):
206
:param source: The repository data comes from
210
def iter_rev_trees(self, revs):
211
"""Iterate through RevisionTrees efficiently.
213
Additionally, the inventory's revision_id is set if unset.
215
Trees are retrieved in batches of 100, and then yielded in the order
218
:param revs: A list of revision ids
220
# In case that revs is not a list.
223
for tree in self.source.revision_trees(revs[:100]):
224
if tree.inventory.revision_id is None:
225
tree.inventory.revision_id = tree.get_revision_id()
229
def _find_root_ids(self, revs, parent_map, graph):
231
planned_versions = {}
232
for tree in self.iter_rev_trees(revs):
233
revision_id = tree.inventory.root.revision
234
root_id = tree.get_root_id()
235
planned_versions.setdefault(root_id, []).append(revision_id)
236
revision_root[revision_id] = root_id
237
# Find out which parents we don't already know root ids for
239
for revision_parents in parent_map.itervalues():
240
parents.update(revision_parents)
241
parents.difference_update(revision_root.keys() + [NULL_REVISION])
242
# Limit to revisions present in the versionedfile
243
parents = graph.get_parent_map(parents).keys()
244
for tree in self.iter_rev_trees(parents):
245
root_id = tree.get_root_id()
246
revision_root[tree.get_revision_id()] = root_id
247
return revision_root, planned_versions
249
def generate_root_texts(self, revs):
250
"""Generate VersionedFiles for all root ids.
252
:param revs: the revisions to include
254
graph = self.source.get_graph()
255
parent_map = graph.get_parent_map(revs)
256
rev_order = topo_sort(parent_map)
257
rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
258
revs, parent_map, graph)
259
root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
261
# Guaranteed stable, this groups all the file id operations together
262
# retaining topological order within the revisions of a file id.
263
# File id splits and joins would invalidate this, but they don't exist
264
# yet, and are unlikely to in non-rich-root environments anyway.
265
root_id_order.sort(key=operator.itemgetter(0))
266
# Create a record stream containing the roots to create.
268
for key in root_id_order:
269
root_id, rev_id = key
270
rev_parents = parent_map[rev_id]
271
# We drop revision parents with different file-ids, because
272
# that represents a rename of the root to a different location
273
# - its not actually a parent for us. (We could look for that
274
# file id in the revision tree at considerably more expense,
275
# but for now this is sufficient (and reconcile will catch and
276
# correct this anyway).
277
# When a parent revision is a ghost, we guess that its root id
278
# was unchanged (rather than trimming it from the parent list).
279
parent_keys = tuple((root_id, parent) for parent in rev_parents
280
if parent != NULL_REVISION and
281
rev_id_to_root_id.get(parent, root_id) == root_id)
282
yield FulltextContentFactory(key, parent_keys, None, '')
283
return [('texts', yield_roots())]
added
removed
bzrlib/fetch.py
