2346
2370
:param revision_ids: The expected revision ids of the inventories.
2371
:param ordering: optional ordering, e.g. 'topological'. If not
2372
specified, the order of revision_ids will be preserved (by
2373
buffering if necessary).
2347
2374
:return: An iterator of inventories.
2349
2376
if ((None in revision_ids)
2350
2377
or (_mod_revision.NULL_REVISION in revision_ids)):
2351
2378
raise ValueError('cannot get null revision inventory')
2352
return self._iter_inventories(revision_ids)
2379
return self._iter_inventories(revision_ids, ordering)
2354
def _iter_inventories(self, revision_ids):
2381
def _iter_inventories(self, revision_ids, ordering):
2355
2382
"""single-document based inventory iteration."""
2356
for text, revision_id in self._iter_inventory_xmls(revision_ids):
2383
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2384
for text, revision_id in inv_xmls:
2357
2385
yield self.deserialise_inventory(revision_id, text)
2359
def _iter_inventory_xmls(self, revision_ids):
2387
def _iter_inventory_xmls(self, revision_ids, ordering):
2388
if ordering is None:
2389
order_as_requested = True
2390
ordering = 'unordered'
2392
order_as_requested = False
2360
2393
keys = [(revision_id,) for revision_id in revision_ids]
2361
stream = self.inventories.get_record_stream(keys, 'unordered', True)
2396
if order_as_requested:
2397
key_iter = iter(keys)
2398
next_key = key_iter.next()
2399
stream = self.inventories.get_record_stream(keys, ordering, True)
2362
2400
text_chunks = {}
2363
2401
for record in stream:
2364
2402
if record.storage_kind != 'absent':
2365
text_chunks[record.key] = record.get_bytes_as('chunked')
2403
chunks = record.get_bytes_as('chunked')
2404
if order_as_requested:
2405
text_chunks[record.key] = chunks
2407
yield ''.join(chunks), record.key[-1]
2367
2409
raise errors.NoSuchRevision(self, record.key)
2369
chunks = text_chunks.pop(key)
2370
yield ''.join(chunks), key[-1]
2410
if order_as_requested:
2411
# Yield as many results as we can while preserving order.
2412
while next_key in text_chunks:
2413
chunks = text_chunks.pop(next_key)
2414
yield ''.join(chunks), next_key[-1]
2416
next_key = key_iter.next()
2417
except StopIteration:
2418
# We still want to fully consume the get_record_stream,
2419
# just in case it is not actually finished at this point
2372
2423
def deserialise_inventory(self, revision_id, xml):
2373
2424
"""Transform the xml into an inventory object.
3660
3721
# This is redundant with format.check_conversion_target(), however that
3661
3722
# raises an exception, and we just want to say "False" as in we won't
3662
3723
# support converting between these formats.
3724
if 'IDS_never' in debug.debug_flags:
3663
3726
if source.supports_rich_root() and not target.supports_rich_root():
3665
3728
if (source._format.supports_tree_reference
3666
3729
and not target._format.supports_tree_reference):
3731
if target._fallback_repositories and target._format.supports_chks:
3732
# IDS doesn't know how to copy CHKs for the parent inventories it
3733
# adds to stacked repos.
3735
if 'IDS_always' in debug.debug_flags:
3737
# Only use this code path for local source and target. IDS does far
3738
# too much IO (both bandwidth and roundtrips) over a network.
3739
if not source.bzrdir.transport.base.startswith('file:///'):
3741
if not target.bzrdir.transport.base.startswith('file:///'):
3670
def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3745
def _get_trees(self, revision_ids, cache):
3747
for rev_id in revision_ids:
3749
possible_trees.append((rev_id, cache[rev_id]))
3751
# Not cached, but inventory might be present anyway.
3753
tree = self.source.revision_tree(rev_id)
3754
except errors.NoSuchRevision:
3755
# Nope, parent is ghost.
3758
cache[rev_id] = tree
3759
possible_trees.append((rev_id, tree))
3760
return possible_trees
3762
def _get_delta_for_revision(self, tree, parent_ids, possible_trees):
3671
3763
"""Get the best delta and base for this revision.
3673
3765
:return: (basis_id, delta)
3675
possible_trees = [(parent_id, cache[parent_id])
3676
for parent_id in parent_ids
3677
if parent_id in cache]
3678
if len(possible_trees) == 0:
3679
# There either aren't any parents, or the parents aren't in the
3680
# cache, so just use the last converted tree
3681
possible_trees.append((basis_id, cache[basis_id]))
3768
# Generate deltas against each tree, to find the shortest.
3769
texts_possibly_new_in_tree = set()
3683
3770
for basis_id, basis_tree in possible_trees:
3684
3771
delta = tree.inventory._make_delta(basis_tree.inventory)
3772
for old_path, new_path, file_id, new_entry in delta:
3773
if new_path is None:
3774
# This file_id isn't present in the new rev, so we don't
3778
# Rich roots are handled elsewhere...
3780
kind = new_entry.kind
3781
if kind != 'directory' and kind != 'file':
3782
# No text record associated with this inventory entry.
3784
# This is a directory or file that has changed somehow.
3785
texts_possibly_new_in_tree.add((file_id, new_entry.revision))
3685
3786
deltas.append((len(delta), basis_id, delta))
3687
3788
return deltas[0][1:]
3689
def _get_parent_keys(self, root_key, parent_map):
3690
"""Get the parent keys for a given root id."""
3691
root_id, rev_id = root_key
3692
# Include direct parents of the revision, but only if they used
3693
# the same root_id and are heads.
3695
for parent_id in parent_map[rev_id]:
3696
if parent_id == _mod_revision.NULL_REVISION:
3698
if parent_id not in self._revision_id_to_root_id:
3699
# We probably didn't read this revision, go spend the
3700
# extra effort to actually check
3702
tree = self.source.revision_tree(parent_id)
3703
except errors.NoSuchRevision:
3704
# Ghost, fill out _revision_id_to_root_id in case we
3705
# encounter this again.
3706
# But set parent_root_id to None since we don't really know
3707
parent_root_id = None
3709
parent_root_id = tree.get_root_id()
3710
self._revision_id_to_root_id[parent_id] = None
3712
parent_root_id = self._revision_id_to_root_id[parent_id]
3713
if root_id == parent_root_id:
3714
# With stacking we _might_ want to refer to a non-local
3715
# revision, but this code path only applies when we have the
3716
# full content available, so ghosts really are ghosts, not just
3717
# the edge of local data.
3718
parent_keys.append((parent_id,))
3720
# root_id may be in the parent anyway.
3722
tree = self.source.revision_tree(parent_id)
3723
except errors.NoSuchRevision:
3724
# ghost, can't refer to it.
3728
parent_keys.append((tree.inventory[root_id].revision,))
3729
except errors.NoSuchId:
3732
g = graph.Graph(self.source.revisions)
3733
heads = g.heads(parent_keys)
3735
for key in parent_keys:
3736
if key in heads and key not in selected_keys:
3737
selected_keys.append(key)
3738
return tuple([(root_id,)+ key for key in selected_keys])
3790
def _fetch_parent_invs_for_stacking(self, parent_map, cache):
3791
"""Find all parent revisions that are absent, but for which the
3792
inventory is present, and copy those inventories.
3740
def _new_root_data_stream(self, root_keys_to_create, parent_map):
3741
for root_key in root_keys_to_create:
3742
parent_keys = self._get_parent_keys(root_key, parent_map)
3743
yield versionedfile.FulltextContentFactory(root_key,
3744
parent_keys, None, '')
3794
This is necessary to preserve correctness when the source is stacked
3795
without fallbacks configured. (Note that in cases like upgrade the
3796
source may be not have _fallback_repositories even though it is
3800
for parents in parent_map.values():
3801
parent_revs.update(parents)
3802
present_parents = self.source.get_parent_map(parent_revs)
3803
absent_parents = set(parent_revs).difference(present_parents)
3804
parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
3805
(rev_id,) for rev_id in absent_parents)
3806
parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
3807
for parent_tree in self.source.revision_trees(parent_inv_ids):
3808
current_revision_id = parent_tree.get_revision_id()
3809
parents_parents_keys = parent_invs_keys_for_stacking[
3810
(current_revision_id,)]
3811
parents_parents = [key[-1] for key in parents_parents_keys]
3812
basis_id = _mod_revision.NULL_REVISION
3813
basis_tree = self.source.revision_tree(basis_id)
3814
delta = parent_tree.inventory._make_delta(basis_tree.inventory)
3815
self.target.add_inventory_by_delta(
3816
basis_id, delta, current_revision_id, parents_parents)
3817
cache[current_revision_id] = parent_tree
3746
3819
def _fetch_batch(self, revision_ids, basis_id, cache):
3747
3820
"""Fetch across a few revisions.
3761
3834
pending_deltas = []
3762
3835
pending_revisions = []
3763
3836
parent_map = self.source.get_parent_map(revision_ids)
3837
self._fetch_parent_invs_for_stacking(parent_map, cache)
3764
3838
for tree in self.source.revision_trees(revision_ids):
3839
# Find a inventory delta for this revision.
3840
# Find text entries that need to be copied, too.
3765
3841
current_revision_id = tree.get_revision_id()
3766
3842
parent_ids = parent_map.get(current_revision_id, ())
3843
parent_trees = self._get_trees(parent_ids, cache)
3844
possible_trees = list(parent_trees)
3845
if len(possible_trees) == 0:
3846
# There either aren't any parents, or the parents are ghosts,
3847
# so just use the last converted tree.
3848
possible_trees.append((basis_id, cache[basis_id]))
3767
3849
basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3851
revision = self.source.get_revision(current_revision_id)
3852
pending_deltas.append((basis_id, delta,
3853
current_revision_id, revision.parent_ids))
3769
3854
if self._converting_to_rich_root:
3770
3855
self._revision_id_to_root_id[current_revision_id] = \
3771
3856
tree.get_root_id()
3772
# Find text entries that need to be copied
3857
# Determine which texts are in present in this revision but not in
3858
# any of the available parents.
3859
texts_possibly_new_in_tree = set()
3773
3860
for old_path, new_path, file_id, entry in delta:
3774
if new_path is not None:
3777
if not self.target.supports_rich_root():
3778
# The target doesn't support rich root, so we don't
3781
if self._converting_to_rich_root:
3782
# This can't be copied normally, we have to insert
3784
root_keys_to_create.add((file_id, entry.revision))
3786
text_keys.add((file_id, entry.revision))
3787
revision = self.source.get_revision(current_revision_id)
3788
pending_deltas.append((basis_id, delta,
3789
current_revision_id, revision.parent_ids))
3861
if new_path is None:
3862
# This file_id isn't present in the new rev
3866
if not self.target.supports_rich_root():
3867
# The target doesn't support rich root, so we don't
3870
if self._converting_to_rich_root:
3871
# This can't be copied normally, we have to insert
3873
root_keys_to_create.add((file_id, entry.revision))
3876
texts_possibly_new_in_tree.add((file_id, entry.revision))
3877
for basis_id, basis_tree in possible_trees:
3878
basis_inv = basis_tree.inventory
3879
for file_key in list(texts_possibly_new_in_tree):
3880
file_id, file_revision = file_key
3882
entry = basis_inv[file_id]
3883
except errors.NoSuchId:
3885
if entry.revision == file_revision:
3886
texts_possibly_new_in_tree.remove(file_key)
3887
text_keys.update(texts_possibly_new_in_tree)
3790
3888
pending_revisions.append(revision)
3791
3889
cache[current_revision_id] = tree
3792
3890
basis_id = current_revision_id
4228
4346
self.target_repo.pack(hint=hint)
4229
4347
return [], set()
4231
def _extract_and_insert_inventories(self, substream, serializer):
4349
def _extract_and_insert_inventory_deltas(self, substream, serializer):
4350
target_rich_root = self.target_repo._format.rich_root_data
4351
target_tree_refs = self.target_repo._format.supports_tree_reference
4352
for record in substream:
4353
# Insert the delta directly
4354
inventory_delta_bytes = record.get_bytes_as('fulltext')
4355
deserialiser = inventory_delta.InventoryDeltaDeserializer()
4357
parse_result = deserialiser.parse_text_bytes(
4358
inventory_delta_bytes)
4359
except inventory_delta.IncompatibleInventoryDelta, err:
4360
trace.mutter("Incompatible delta: %s", err.msg)
4361
raise errors.IncompatibleRevision(self.target_repo._format)
4362
basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4363
revision_id = new_id
4364
parents = [key[0] for key in record.parents]
4365
self.target_repo.add_inventory_by_delta(
4366
basis_id, inv_delta, revision_id, parents)
4368
def _extract_and_insert_inventories(self, substream, serializer,
4232
4370
"""Generate a new inventory versionedfile in target, converting data.
4234
4372
The inventory is retrieved from the source, (deserializing it), and
4235
4373
stored in the target (reserializing it in a different format).
4375
target_rich_root = self.target_repo._format.rich_root_data
4376
target_tree_refs = self.target_repo._format.supports_tree_reference
4237
4377
for record in substream:
4378
# It's not a delta, so it must be a fulltext in the source
4379
# serializer's format.
4238
4380
bytes = record.get_bytes_as('fulltext')
4239
4381
revision_id = record.key[0]
4240
4382
inv = serializer.read_inventory_from_string(bytes, revision_id)
4241
4383
parents = [key[0] for key in record.parents]
4242
4384
self.target_repo.add_inventory(revision_id, inv, parents)
4385
# No need to keep holding this full inv in memory when the rest of
4386
# the substream is likely to be all deltas.
4244
4389
def _extract_and_insert_revisions(self, substream, serializer):
4245
4390
for record in substream:
4403
4554
return (not self.from_repository._format.rich_root_data and
4404
4555
self.to_format.rich_root_data)
4406
def _get_inventory_stream(self, revision_ids):
4557
def _get_inventory_stream(self, revision_ids, missing=False):
4407
4558
from_format = self.from_repository._format
4408
if (from_format.supports_chks and self.to_format.supports_chks
4409
and (from_format._serializer == self.to_format._serializer)):
4410
# Both sides support chks, and they use the same serializer, so it
4411
# is safe to transmit the chk pages and inventory pages across
4413
return self._get_chk_inventory_stream(revision_ids)
4414
elif (not from_format.supports_chks):
4415
# Source repository doesn't support chks. So we can transmit the
4416
# inventories 'as-is' and either they are just accepted on the
4417
# target, or the Sink will properly convert it.
4418
return self._get_simple_inventory_stream(revision_ids)
4559
if (from_format.supports_chks and self.to_format.supports_chks and
4560
from_format.network_name() == self.to_format.network_name()):
4561
raise AssertionError(
4562
"this case should be handled by GroupCHKStreamSource")
4563
elif 'forceinvdeltas' in debug.debug_flags:
4564
return self._get_convertable_inventory_stream(revision_ids,
4565
delta_versus_null=missing)
4566
elif from_format.network_name() == self.to_format.network_name():
4568
return self._get_simple_inventory_stream(revision_ids,
4570
elif (not from_format.supports_chks and not self.to_format.supports_chks
4571
and from_format._serializer == self.to_format._serializer):
4572
# Essentially the same format.
4573
return self._get_simple_inventory_stream(revision_ids,
4420
# XXX: Hack to make not-chk->chk fetch: copy the inventories as
4421
# inventories. Note that this should probably be done somehow
4422
# as part of bzrlib.repository.StreamSink. Except JAM couldn't
4423
# figure out how a non-chk repository could possibly handle
4424
# deserializing an inventory stream from a chk repo, as it
4425
# doesn't have a way to understand individual pages.
4426
return self._get_convertable_inventory_stream(revision_ids)
4576
# Any time we switch serializations, we want to use an
4577
# inventory-delta based approach.
4578
return self._get_convertable_inventory_stream(revision_ids,
4579
delta_versus_null=missing)
4428
def _get_simple_inventory_stream(self, revision_ids):
4581
def _get_simple_inventory_stream(self, revision_ids, missing=False):
4582
# NB: This currently reopens the inventory weave in source;
4583
# using a single stream interface instead would avoid this.
4429
4584
from_weave = self.from_repository.inventories
4586
delta_closure = True
4588
delta_closure = not self.delta_on_metadata()
4430
4589
yield ('inventories', from_weave.get_record_stream(
4431
4590
[(rev_id,) for rev_id in revision_ids],
4432
self.inventory_fetch_order(),
4433
not self.delta_on_metadata()))
4435
def _get_chk_inventory_stream(self, revision_ids):
4436
"""Fetch the inventory texts, along with the associated chk maps."""
4437
# We want an inventory outside of the search set, so that we can filter
4438
# out uninteresting chk pages. For now we use
4439
# _find_revision_outside_set, but if we had a Search with cut_revs, we
4440
# could use that instead.
4441
start_rev_id = self.from_repository._find_revision_outside_set(
4443
start_rev_key = (start_rev_id,)
4444
inv_keys_to_fetch = [(rev_id,) for rev_id in revision_ids]
4445
if start_rev_id != _mod_revision.NULL_REVISION:
4446
inv_keys_to_fetch.append((start_rev_id,))
4447
# Any repo that supports chk_bytes must also support out-of-order
4448
# insertion. At least, that is how we expect it to work
4449
# We use get_record_stream instead of iter_inventories because we want
4450
# to be able to insert the stream as well. We could instead fetch
4451
# allowing deltas, and then iter_inventories, but we don't know whether
4452
# source or target is more 'local' anway.
4453
inv_stream = self.from_repository.inventories.get_record_stream(
4454
inv_keys_to_fetch, 'unordered',
4455
True) # We need them as full-texts so we can find their references
4456
uninteresting_chk_roots = set()
4457
interesting_chk_roots = set()
4458
def filter_inv_stream(inv_stream):
4459
for idx, record in enumerate(inv_stream):
4460
### child_pb.update('fetch inv', idx, len(inv_keys_to_fetch))
4461
bytes = record.get_bytes_as('fulltext')
4462
chk_inv = inventory.CHKInventory.deserialise(
4463
self.from_repository.chk_bytes, bytes, record.key)
4464
if record.key == start_rev_key:
4465
uninteresting_chk_roots.add(chk_inv.id_to_entry.key())
4466
p_id_map = chk_inv.parent_id_basename_to_file_id
4467
if p_id_map is not None:
4468
uninteresting_chk_roots.add(p_id_map.key())
4471
interesting_chk_roots.add(chk_inv.id_to_entry.key())
4472
p_id_map = chk_inv.parent_id_basename_to_file_id
4473
if p_id_map is not None:
4474
interesting_chk_roots.add(p_id_map.key())
4475
### pb.update('fetch inventory', 0, 2)
4476
yield ('inventories', filter_inv_stream(inv_stream))
4477
# Now that we have worked out all of the interesting root nodes, grab
4478
# all of the interesting pages and insert them
4479
### pb.update('fetch inventory', 1, 2)
4480
interesting = chk_map.iter_interesting_nodes(
4481
self.from_repository.chk_bytes, interesting_chk_roots,
4482
uninteresting_chk_roots)
4483
def to_stream_adapter():
4484
"""Adapt the iter_interesting_nodes result to a single stream.
4486
iter_interesting_nodes returns records as it processes them, along
4487
with keys. However, we only want to return the records themselves.
4489
for record, items in interesting:
4490
if record is not None:
4492
# XXX: We could instead call get_record_stream(records.keys())
4493
# ATM, this will always insert the records as fulltexts, and
4494
# requires that you can hang on to records once you have gone
4495
# on to the next one. Further, it causes the target to
4496
# recompress the data. Testing shows it to be faster than
4497
# requesting the records again, though.
4498
yield ('chk_bytes', to_stream_adapter())
4499
### pb.update('fetch inventory', 2, 2)
4501
def _get_convertable_inventory_stream(self, revision_ids):
4502
# XXX: One of source or target is using chks, and they don't have
4503
# compatible serializations. The StreamSink code expects to be
4504
# able to convert on the target, so we need to put
4505
# bytes-on-the-wire that can be converted
4506
yield ('inventories', self._stream_invs_as_fulltexts(revision_ids))
4508
def _stream_invs_as_fulltexts(self, revision_ids):
4591
self.inventory_fetch_order(), delta_closure))
4593
def _get_convertable_inventory_stream(self, revision_ids,
4594
delta_versus_null=False):
4595
# The source is using CHKs, but the target either doesn't or it has a
4596
# different serializer. The StreamSink code expects to be able to
4597
# convert on the target, so we need to put bytes-on-the-wire that can
4598
# be converted. That means inventory deltas (if the remote is <1.19,
4599
# RemoteStreamSink will fallback to VFS to insert the deltas).
4600
yield ('inventory-deltas',
4601
self._stream_invs_as_deltas(revision_ids,
4602
delta_versus_null=delta_versus_null))
4604
def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
4605
"""Return a stream of inventory-deltas for the given rev ids.
4607
:param revision_ids: The list of inventories to transmit
4608
:param delta_versus_null: Don't try to find a minimal delta for this
4609
entry, instead compute the delta versus the NULL_REVISION. This
4610
effectively streams a complete inventory. Used for stuff like
4611
filling in missing parents, etc.
4509
4613
from_repo = self.from_repository
4510
from_serializer = from_repo._format._serializer
4511
4614
revision_keys = [(rev_id,) for rev_id in revision_ids]
4512
4615
parent_map = from_repo.inventories.get_parent_map(revision_keys)
4513
for inv in self.from_repository.iter_inventories(revision_ids):
4514
# XXX: This is a bit hackish, but it works. Basically,
4515
# CHKSerializer 'accidentally' supports
4516
# read/write_inventory_to_string, even though that is never
4517
# the format that is stored on disk. It *does* give us a
4518
# single string representation for an inventory, so live with
4520
# This would be far better if we had a 'serialized inventory
4521
# delta' form. Then we could use 'inventory._make_delta', and
4522
# transmit that. This would both be faster to generate, and
4523
# result in fewer bytes-on-the-wire.
4524
as_bytes = from_serializer.write_inventory_to_string(inv)
4616
# XXX: possibly repos could implement a more efficient iter_inv_deltas
4618
inventories = self.from_repository.iter_inventories(
4619
revision_ids, 'topological')
4620
format = from_repo._format
4621
invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4622
inventory_cache = lru_cache.LRUCache(50)
4623
null_inventory = from_repo.revision_tree(
4624
_mod_revision.NULL_REVISION).inventory
4625
# XXX: ideally the rich-root/tree-refs flags would be per-revision, not
4626
# per-repo (e.g. streaming a non-rich-root revision out of a rich-root
4627
# repo back into a non-rich-root repo ought to be allowed)
4628
serializer = inventory_delta.InventoryDeltaSerializer(
4629
versioned_root=format.rich_root_data,
4630
tree_references=format.supports_tree_reference)
4631
for inv in inventories:
4525
4632
key = (inv.revision_id,)
4526
4633
parent_keys = parent_map.get(key, ())
4635
if not delta_versus_null and parent_keys:
4636
# The caller did not ask for complete inventories and we have
4637
# some parents that we can delta against. Make a delta against
4638
# each parent so that we can find the smallest.
4639
parent_ids = [parent_key[0] for parent_key in parent_keys]
4640
for parent_id in parent_ids:
4641
if parent_id not in invs_sent_so_far:
4642
# We don't know that the remote side has this basis, so
4645
if parent_id == _mod_revision.NULL_REVISION:
4646
parent_inv = null_inventory
4648
parent_inv = inventory_cache.get(parent_id, None)
4649
if parent_inv is None:
4650
parent_inv = from_repo.get_inventory(parent_id)
4651
candidate_delta = inv._make_delta(parent_inv)
4652
if (delta is None or
4653
len(delta) > len(candidate_delta)):
4654
delta = candidate_delta
4655
basis_id = parent_id
4657
# Either none of the parents ended up being suitable, or we
4658
# were asked to delta against NULL
4659
basis_id = _mod_revision.NULL_REVISION
4660
delta = inv._make_delta(null_inventory)
4661
invs_sent_so_far.add(inv.revision_id)
4662
inventory_cache[inv.revision_id] = inv
4663
delta_serialized = ''.join(
4664
serializer.delta_to_lines(basis_id, key[-1], delta))
4527
4665
yield versionedfile.FulltextContentFactory(
4528
key, parent_keys, None, as_bytes)
4666
key, parent_keys, None, delta_serialized)
4531
4669
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
added
removed
bzrlib/repository.py
