63
58
# and add in all file versions
66
@deprecated_function(zero_eight)
67
62
def greedy_fetch(to_branch, from_branch, revision=None, pb=None):
68
"""Legacy API, please see branch.fetch(from_branch, last_revision, pb)."""
69
63
f = Fetcher(to_branch, from_branch, revision, pb)
70
64
return f.count_copied, f.failed_revisions
75
class RepoFetcher(object):
76
"""Pull revisions and texts from one repository to another.
79
if set, try to limit to the data this revision references.
68
class Fetcher(object):
69
"""Pull revisions and texts from one branch to another.
71
This doesn't update the destination's history; that can be done
72
separately if desired.
75
If set, pull only up to this revision_id.
79
last_revision -- if last_revision
80
is given it will be that, otherwise the last revision of
82
83
count_copied -- number of revisions copied
84
This should not be used directory, its essential a object to encapsulate
85
the logic in InterRepository.fetch().
85
count_texts -- number of file texts copied
87
def __init__(self, to_repository, from_repository, last_revision=None, pb=None):
87
def __init__(self, to_branch, from_branch, last_revision=None, pb=None):
88
if to_branch == from_branch:
89
raise Exception("can't fetch from a branch to itself")
90
self.to_branch = to_branch
91
self.to_weaves = to_branch.weave_store
92
self.to_control = to_branch.control_weaves
93
self.from_branch = from_branch
94
self.from_weaves = from_branch.weave_store
95
self.from_control = from_branch.control_weaves
89
96
self.failed_revisions = []
90
97
self.count_copied = 0
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)
96
self.to_repository = to_repository
97
self.from_repository = from_repository
98
# must not mutate self._last_revision as its potentially a shared instance
99
self._last_revision = last_revision
101
self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
102
self.nested_pb = self.pb
101
self.pb = bzrlib.ui.ui_factory.progress_bar()
105
self.nested_pb = None
106
self.from_repository.lock_read()
108
self.to_repository.lock_write()
112
if self.nested_pb is not None:
113
self.nested_pb.finished()
114
self.to_repository.unlock()
116
self.from_repository.unlock()
119
"""Primary worker function.
121
This initialises all the needed variables, and then fetches the
122
requested revisions, finally clearing the progress bar.
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
129
self.file_ids_names = {}
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)
146
def _revids_to_fetch(self):
147
mutter('fetch up to rev {%s}', self._last_revision)
148
if self._last_revision is NULL_REVISION:
149
# explicit limit of no revisions needed
151
if (self._last_revision is not None and
152
self.to_repository.has_revision(self._last_revision)):
105
self.last_revision = self._find_last_revision(last_revision)
106
except NoSuchRevision, e:
107
mutter('failed getting last revision: %s', e)
108
raise InstallFailed([last_revision])
109
mutter('fetch up to rev {%s}', self.last_revision)
111
revs_to_fetch = self._compare_ancestries()
113
raise InstallFailed([self.last_revision])
114
self._copy_revisions(revs_to_fetch)
115
self.new_ancestry = revs_to_fetch
118
def _find_last_revision(self, last_revision):
119
"""Find the limiting source revision.
121
Every ancestor of that revision will be merged across.
123
Returns the revision_id, or returns None if there's no history
124
in the source branch."""
125
self.pb.update('get source history')
126
from_history = self.from_branch.revision_history()
127
self.pb.update('get destination history')
129
self.from_branch.get_revision(last_revision)
132
return from_history[-1]
134
return None # no history in the source branch
156
return self.to_repository.missing_revision_ids(self.from_repository,
158
except errors.NoSuchRevision:
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)
285
class Inter1and2Helper(object):
286
"""Helper for operations that convert data from model 1 and 2
288
This is for use by fetchers and converters.
291
def __init__(self, source, target):
294
:param source: The repository data comes from
295
:param target: The repository data goes to
300
def iter_rev_trees(self, revs):
301
"""Iterate through RevisionTrees efficiently.
303
Additionally, the inventory's revision_id is set if unset.
305
Trees are retrieved in batches of 100, and then yielded in the order
308
:param revs: A list of revision ids
311
for tree in self.source.revision_trees(revs[:100]):
312
if tree.inventory.revision_id is None:
313
tree.inventory.revision_id = tree.get_revision_id()
317
def generate_root_texts(self, revs):
318
"""Generate VersionedFiles for all root ids.
320
:param revs: the revisions to include
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)
137
def _compare_ancestries(self):
138
"""Get a list of revisions that must be copied.
140
That is, every revision that's in the ancestry of the source
141
branch and not in the destination branch."""
142
self.pb.update('get source ancestry')
143
self.from_ancestry = self.from_branch.get_ancestry(self.last_revision)
145
dest_last_rev = self.to_branch.last_revision()
146
self.pb.update('get destination ancestry')
148
dest_ancestry = self.to_branch.get_ancestry(dest_last_rev)
151
ss = set(dest_ancestry)
153
for rev_id in self.from_ancestry:
155
to_fetch.append(rev_id)
156
mutter('need to get revision {%s}', rev_id)
157
mutter('need to get %d revisions in total', len(to_fetch))
158
self.count_total = len(to_fetch)
161
def _copy_revisions(self, revs_to_fetch):
163
for rev_id in revs_to_fetch:
167
if self.to_branch.has_revision(rev_id):
169
self.pb.update('fetch revision', i, self.count_total)
170
self._copy_one_revision(rev_id)
171
self.count_copied += 1
174
def _copy_one_revision(self, rev_id):
175
"""Copy revision and everything referenced by it."""
176
mutter('copying revision {%s}', rev_id)
177
rev_xml = self.from_branch.get_revision_xml(rev_id)
178
inv_xml = self.from_branch.get_inventory_xml(rev_id)
179
rev = serializer_v5.read_revision_from_string(rev_xml)
180
inv = serializer_v5.read_inventory_from_string(inv_xml)
181
assert rev.revision_id == rev_id
182
assert rev.inventory_sha1 == sha_string(inv_xml)
183
mutter(' commiter %s, %d parents',
186
self._copy_new_texts(rev_id, inv)
187
self._copy_inventory(rev_id, inv_xml, rev.parent_ids)
188
self._copy_ancestry(rev_id, rev.parent_ids)
189
self.to_branch.revision_store.add(StringIO(rev_xml), rev_id)
192
def _copy_inventory(self, rev_id, inv_xml, parent_ids):
193
self.to_control.add_text('inventory', rev_id,
194
split_lines(inv_xml), parent_ids)
197
def _copy_ancestry(self, rev_id, parent_ids):
198
ancestry_lines = self.from_control.get_lines('ancestry', rev_id)
199
self.to_control.add_text('ancestry', rev_id, ancestry_lines,
203
def _copy_new_texts(self, rev_id, inv):
204
"""Copy any new texts occuring in this revision."""
205
# TODO: Rather than writing out weaves every time, hold them
206
# in memory until everything's done? But this way is nicer
207
# if it's interrupted.
208
for path, ie in inv.iter_entries():
209
if ie.kind != 'file':
211
if ie.text_version != rev_id:
213
mutter('%s {%s} is changed in this revision',
215
self._copy_one_text(rev_id, ie.file_id)
218
def _copy_one_text(self, rev_id, file_id):
219
"""Copy one file text."""
220
mutter('copy text version {%s} of file {%s}',
222
from_weave = self.from_weaves.get_weave(file_id)
223
from_idx = from_weave.lookup(rev_id)
224
from_parents = map(from_weave.idx_to_name, from_weave.parents(from_idx))
225
text_lines = from_weave.get(from_idx)
226
to_weave = self.to_weaves.get_weave_or_empty(file_id)
227
to_parents = map(to_weave.lookup, from_parents)
228
# it's ok to add even if the text is already there
229
to_weave.add(rev_id, to_parents, text_lines)
230
self.to_weaves.put_weave(file_id, to_weave)
231
self.count_texts += 1
added
removed
bzrlib/fetch.py
