52
52
from bzrlib.testament import Testament
60
55
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
61
56
from bzrlib.inter import InterObject
62
57
from bzrlib.inventory import (
68
from bzrlib.recordcounter import RecordCounter
69
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
63
from bzrlib.lock import _RelockDebugMixin
64
from bzrlib import registry
70
65
from bzrlib.trace import (
71
66
log_exception_quietly, note, mutter, mutter_callsite, warning)
75
70
_deprecation_warning_done = False
78
class IsInWriteGroupError(errors.InternalBzrError):
80
_fmt = "May not refresh_data of repo %(repo)s while in a write group."
82
def __init__(self, repo):
83
errors.InternalBzrError.__init__(self, repo=repo)
86
73
class CommitBuilder(object):
87
74
"""Provides an interface to build up a commit.
244
231
def _gen_revision_id(self):
245
232
"""Return new revision-id."""
246
return generate_ids.gen_revision_id(self._committer, self._timestamp)
233
return generate_ids.gen_revision_id(self._config.username(),
248
236
def _generate_revision_if_needed(self):
249
237
"""Create a revision id if None was supplied.
290
278
:param tree: The tree which is being committed.
292
if len(self.parents) == 0:
293
raise errors.RootMissing()
280
# NB: if there are no parents then this method is not called, so no
281
# need to guard on parents having length.
294
282
entry = entry_factory['directory'](tree.path2id(''), '',
296
284
entry.revision = self._new_revision_id
435
423
# we don't need to commit this, because the caller already
436
424
# determined that an existing revision of this file is
437
# appropriate. If it's not being considered for committing then
425
# appropriate. If its not being considered for committing then
438
426
# it and all its parents to the root must be unaltered so
439
427
# no-change against the basis.
440
428
if ie.revision == self._new_revision_id:
756
744
# after iter_changes examines and decides it has changed,
757
745
# we will unconditionally record a new version even if some
758
746
# other process reverts it while commit is running (with
759
# the revert happening after iter_changes did its
747
# the revert happening after iter_changes did it's
762
750
entry.executable = True
871
859
# versioned roots do not change unless the tree found a change.
874
class RepositoryWriteLockResult(LogicalLockResult):
875
"""The result of write locking a repository.
877
:ivar repository_token: The token obtained from the underlying lock, or
879
:ivar unlock: A callable which will unlock the lock.
882
def __init__(self, unlock, repository_token):
883
LogicalLockResult.__init__(self, unlock)
884
self.repository_token = repository_token
887
return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
891
862
######################################################################
895
class Repository(_RelockDebugMixin, controldir.ControlComponent):
866
class Repository(_RelockDebugMixin):
896
867
"""Repository holding history for one or more branches.
898
869
The repository holds and retrieves historical information including
945
916
pointing to .bzr/repository.
948
# What class to use for a CommitBuilder. Often it's simpler to change this
919
# What class to use for a CommitBuilder. Often its simpler to change this
949
920
# in a Repository class subclass rather than to override
950
921
# get_commit_builder.
951
922
_commit_builder_class = CommitBuilder
1046
1017
" id and insertion revid (%r, %r)"
1047
1018
% (inv.revision_id, revision_id))
1048
1019
if inv.root is None:
1049
raise errors.RootMissing()
1020
raise AssertionError()
1050
1021
return self._add_inventory_checked(revision_id, inv, parents)
1052
1023
def _add_inventory_checked(self, revision_id, inv, parents):
1057
1028
:seealso: add_inventory, for the contract.
1059
inv_lines = self._serializer.write_inventory_to_lines(inv)
1030
inv_lines = self._serialise_inventory_to_lines(inv)
1060
1031
return self._inventory_add_lines(revision_id, parents,
1061
1032
inv_lines, check_content=False)
1269
1240
"""Check a single text from this repository."""
1270
1241
if kind == 'inventories':
1271
1242
rev_id = record.key[0]
1272
inv = self._deserialise_inventory(rev_id,
1243
inv = self.deserialise_inventory(rev_id,
1273
1244
record.get_bytes_as('fulltext'))
1274
1245
if last_object is not None:
1275
1246
delta = inv._make_delta(last_object)
1320
1291
:param _format: The format of the repository on disk.
1321
1292
:param a_bzrdir: The BzrDir of the repository.
1294
In the future we will have a single api for all stores for
1295
getting file texts, inventories and revisions, then
1296
this construct will accept instances of those things.
1323
# In the future we will have a single api for all stores for
1324
# getting file texts, inventories and revisions, then
1325
# this construct will accept instances of those things.
1326
1298
super(Repository, self).__init__()
1327
1299
self._format = _format
1328
1300
# the following are part of the public API for Repository:
1343
1315
# rather copying them?
1344
1316
self._safe_to_return_from_cache = False
1347
def user_transport(self):
1348
return self.bzrdir.user_transport
1351
def control_transport(self):
1352
return self._transport
1354
1318
def __repr__(self):
1355
1319
if self._fallback_repositories:
1356
1320
return '%s(%r, fallback_repositories=%r)' % (
1404
1368
data during reads, and allows a 'write_group' to be obtained. Write
1405
1369
groups must be used for actual data insertion.
1407
A token should be passed in if you know that you have locked the object
1408
some other way, and need to synchronise this object's state with that
1411
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1413
1371
:param token: if this is already locked, then lock_write will fail
1414
1372
unless the token matches the existing lock.
1415
1373
:returns: a token if this instance supports tokens, otherwise None.
1418
1376
:raises MismatchedToken: if the specified token doesn't match the token
1419
1377
of the existing lock.
1420
1378
:seealso: start_write_group.
1421
:return: A RepositoryWriteLockResult.
1380
A token should be passed in if you know that you have locked the object
1381
some other way, and need to synchronise this object's state with that
1384
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1423
1386
locked = self.is_locked()
1424
token = self.control_files.lock_write(token=token)
1387
result = self.control_files.lock_write(token=token)
1426
1389
self._warn_if_deprecated()
1427
1390
self._note_lock('w')
1429
1392
# Writes don't affect fallback repos
1430
1393
repo.lock_read()
1431
1394
self._refresh_data()
1432
return RepositoryWriteLockResult(self.unlock, token)
1434
1397
def lock_read(self):
1435
"""Lock the repository for read operations.
1437
:return: An object with an unlock method which will release the lock
1440
1398
locked = self.is_locked()
1441
1399
self.control_files.lock_read()
1512
1469
# now gather global repository information
1513
1470
# XXX: This is available for many repos regardless of listability.
1514
if self.user_transport.listable():
1471
if self.bzrdir.root_transport.listable():
1515
1472
# XXX: do we want to __define len__() ?
1516
1473
# Maybe the versionedfiles object should provide a different
1517
1474
# method to get the number of keys.
1527
1484
:param using: If True, list only branches using this repository.
1529
1486
if using and not self.is_shared():
1530
return self.bzrdir.list_branches()
1488
return [self.bzrdir.open_branch()]
1489
except errors.NotBranchError:
1531
1491
class Evaluator(object):
1533
1493
def __init__(self):
1542
1502
except errors.NoRepositoryPresent:
1545
return False, ([], repository)
1505
return False, (None, repository)
1546
1506
self.first_call = False
1547
value = (bzrdir.list_branches(), None)
1508
value = (bzrdir.open_branch(), None)
1509
except errors.NotBranchError:
1510
value = (None, None)
1548
1511
return True, value
1551
for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1552
self.user_transport, evaluate=Evaluator()):
1553
if branches is not None:
1554
ret.extend(branches)
1514
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
1515
self.bzrdir.root_transport, evaluate=Evaluator()):
1516
if branch is not None:
1517
branches.append(branch)
1555
1518
if not using and repository is not None:
1556
ret.extend(repository.find_branches())
1519
branches.extend(repository.find_branches())
1559
1522
@needs_read_lock
1560
1523
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1669
1632
return missing_keys
1671
1634
def refresh_data(self):
1672
"""Re-read any data needed to synchronise with disk.
1635
"""Re-read any data needed to to synchronise with disk.
1674
1637
This method is intended to be called after another repository instance
1675
1638
(such as one used by a smart server) has inserted data into the
1676
repository. On all repositories this will work outside of write groups.
1677
Some repository formats (pack and newer for bzrlib native formats)
1678
support refresh_data inside write groups. If called inside a write
1679
group on a repository that does not support refreshing in a write group
1680
IsInWriteGroupError will be raised.
1639
repository. It may not be called during a write group, but may be
1640
called at any other time.
1642
if self.is_in_write_group():
1643
raise errors.InternalBzrError(
1644
"May not refresh_data while in a write group.")
1682
1645
self._refresh_data()
1684
1647
def resume_write_group(self, tokens):
1723
1686
"May not fetch while in a write group.")
1724
1687
# fast path same-url fetch operations
1725
1688
# TODO: lift out to somewhere common with RemoteRepository
1726
# <https://bugs.launchpad.net/bzr/+bug/401646>
1689
# <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1727
1690
if (self.has_same_location(source)
1728
1691
and fetch_spec is None
1729
1692
and self._has_same_fallbacks(source)):
1938
1901
rev = self._serializer.read_revision_from_string(text)
1939
1902
yield (revid, rev)
1905
def get_revision_xml(self, revision_id):
1906
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1907
# would have already do it.
1908
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1909
# TODO: this can't just be replaced by:
1910
# return self._serializer.write_revision_to_string(
1911
# self.get_revision(revision_id))
1912
# as cStringIO preservers the encoding unlike write_revision_to_string
1913
# or some other call down the path.
1914
rev = self.get_revision(revision_id)
1915
rev_tmp = cStringIO.StringIO()
1916
# the current serializer..
1917
self._serializer.write_revision(rev, rev_tmp)
1919
return rev_tmp.getvalue()
1941
1921
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1942
1922
"""Produce a generator of revision deltas.
2186
2166
selected_keys = set((revid,) for revid in revision_ids)
2187
2167
w = _inv_weave or self.inventories
2188
return self._find_file_ids_from_xml_inventory_lines(
2189
w.iter_lines_added_or_present_in_keys(
2190
selected_keys, pb=None),
2168
pb = ui.ui_factory.nested_progress_bar()
2170
return self._find_file_ids_from_xml_inventory_lines(
2171
w.iter_lines_added_or_present_in_keys(
2172
selected_keys, pb=pb),
2193
2177
def iter_files_bytes(self, desired_files):
2194
2178
"""Iterate through file versions.
2404
2388
"""single-document based inventory iteration."""
2405
2389
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2406
2390
for text, revision_id in inv_xmls:
2407
yield self._deserialise_inventory(revision_id, text)
2391
yield self.deserialise_inventory(revision_id, text)
2409
2393
def _iter_inventory_xmls(self, revision_ids, ordering):
2410
2394
if ordering is None:
2442
2426
next_key = None
2445
def _deserialise_inventory(self, revision_id, xml):
2429
def deserialise_inventory(self, revision_id, xml):
2446
2430
"""Transform the xml into an inventory object.
2448
2432
:param revision_id: The expected revision id of the inventory.
2456
2440
result.revision_id, revision_id))
2443
def serialise_inventory(self, inv):
2444
return self._serializer.write_inventory_to_string(inv)
2446
def _serialise_inventory_to_lines(self, inv):
2447
return self._serializer.write_inventory_to_lines(inv)
2459
2449
def get_serializer_format(self):
2460
2450
return self._serializer.format_num
2462
2452
@needs_read_lock
2463
def _get_inventory_xml(self, revision_id):
2464
"""Get serialized inventory as a string."""
2453
def get_inventory_xml(self, revision_id):
2454
"""Get inventory XML as a file object."""
2465
2455
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2467
2457
text, revision_id = texts.next()
2469
2459
raise errors.HistoryMissing(self, 'inventory', revision_id)
2463
def get_inventory_sha1(self, revision_id):
2464
"""Return the sha1 hash of the inventory entry
2466
return self.get_revision(revision_id).inventory_sha1
2472
2468
def get_rev_id_for_revno(self, revno, known_pair):
2473
2469
"""Return the revision id of a revno, given a later (revno, revid)
2474
2470
pair in the same history.
2511
2507
ancestors will be traversed.
2513
2509
graph = self.get_graph()
2514
stop_revisions = (None, _mod_revision.NULL_REVISION)
2515
return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
2510
next_id = revision_id
2512
if next_id in (None, _mod_revision.NULL_REVISION):
2515
parents = graph.get_parent_map([next_id])[next_id]
2517
raise errors.RevisionNotPresent(next_id, self)
2519
if len(parents) == 0:
2522
next_id = parents[0]
2525
def get_revision_inventory(self, revision_id):
2526
"""Return inventory of a past revision."""
2527
# TODO: Unify this with get_inventory()
2528
# bzr 0.0.6 and later imposes the constraint that the inventory_id
2529
# must be the same as its revision, so this is trivial.
2530
if revision_id is None:
2531
# This does not make sense: if there is no revision,
2532
# then it is the current tree inventory surely ?!
2533
# and thus get_root_id() is something that looks at the last
2534
# commit on the branch, and the get_root_id is an inventory check.
2535
raise NotImplementedError
2536
# return Inventory(self.get_root_id())
2538
return self.get_inventory(revision_id)
2517
2540
def is_shared(self):
2518
2541
"""Return True if this repository is flagged as a shared repository."""
2553
2576
return RevisionTree(self, Inventory(root_id=None),
2554
2577
_mod_revision.NULL_REVISION)
2556
inv = self.get_inventory(revision_id)
2579
inv = self.get_revision_inventory(revision_id)
2557
2580
return RevisionTree(self, inv, revision_id)
2559
2582
def revision_trees(self, revision_ids):
2612
2635
keys = tsort.topo_sort(parent_map)
2613
2636
return [None] + list(keys)
2615
def pack(self, hint=None, clean_obsolete_packs=False):
2638
def pack(self, hint=None):
2616
2639
"""Compress the data within the repository.
2618
2641
This operation only makes sense for some repository types. For other
2619
2642
types it should be a no-op that just returns.
2621
2644
This stub method does not require a lock, but subclasses should use
2622
@needs_write_lock as this is a long running call it's reasonable to
2645
@needs_write_lock as this is a long running call its reasonable to
2623
2646
implicitly lock for the user.
2625
2648
:param hint: If not supplied, the whole repository is packed.
2628
2651
obtained from the result of commit_write_group(). Out of
2629
2652
date hints are simply ignored, because concurrent operations
2630
2653
can obsolete them rapidly.
2632
:param clean_obsolete_packs: Clean obsolete packs immediately after
2636
2656
def get_transaction(self):
2661
2681
def _make_parents_provider(self):
2665
def get_known_graph_ancestry(self, revision_ids):
2666
"""Return the known graph for a set of revision ids and their ancestors.
2668
st = static_tuple.StaticTuple
2669
revision_keys = [st(r_id).intern() for r_id in revision_ids]
2670
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2671
return graph.GraphThunkIdsToKeys(known_graph)
2673
2684
def get_graph(self, other_repository=None):
2674
2685
"""Return the graph walker for this repository format"""
2675
2686
parents_provider = self._make_parents_provider()
3074
3085
pack_compresses = False
3075
3086
# Does the repository inventory storage understand references to trees?
3076
3087
supports_tree_reference = None
3077
# Is the format experimental ?
3078
experimental = False
3081
return "%s()" % self.__class__.__name__
3090
return "<%s>" % self.__class__.__name__
3083
3092
def __eq__(self, other):
3084
3093
# format objects are generally stateless
3203
3212
raise NotImplementedError(self.open)
3205
def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3206
from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3207
hooks = BzrDir.hooks['post_repo_init']
3210
params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3215
3215
class MetaDirRepositoryFormat(RepositoryFormat):
3216
3216
"""Common base class for the new repositories using the metadir layout."""
3378
3378
'bzrlib.repofmt.groupcompress_repo',
3379
3379
'RepositoryFormat2a',
3381
format_registry.register_lazy(
3382
'Bazaar development format 8\n',
3383
'bzrlib.repofmt.groupcompress_repo',
3384
'RepositoryFormat2aSubtree',
3388
3383
class InterRepository(InterObject):
3427
3422
:param revision_id: if None all content is copied, if NULL_REVISION no
3428
3423
content is copied.
3424
:param pb: optional progress bar to use for progress reports. If not
3425
provided a default one will be created.
3432
ui.ui_factory.warn_experimental_format_fetch(self)
3433
from bzrlib.fetch import RepoFetcher
3434
# See <https://launchpad.net/bugs/456077> asking for a warning here
3435
if self.source._format.network_name() != self.target._format.network_name():
3436
ui.ui_factory.show_user_warning('cross_format_fetch',
3437
from_format=self.source._format,
3438
to_format=self.target._format)
3439
f = RepoFetcher(to_repository=self.target,
3428
f = _mod_fetch.RepoFetcher(to_repository=self.target,
3440
3429
from_repository=self.source,
3441
3430
last_revision=revision_id,
3442
3431
fetch_spec=fetch_spec,
3443
find_ghosts=find_ghosts)
3432
pb=pb, find_ghosts=find_ghosts)
3445
3434
def _walk_to_common_revisions(self, revision_ids):
3446
3435
"""Walk out from revision_ids in source to revisions target has.
3842
3831
basis_id, delta, current_revision_id, parents_parents)
3843
3832
cache[current_revision_id] = parent_tree
3845
def _fetch_batch(self, revision_ids, basis_id, cache):
3834
def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
3846
3835
"""Fetch across a few revisions.
3848
3837
:param revision_ids: The revisions to copy
3849
3838
:param basis_id: The revision_id of a tree that must be in cache, used
3850
3839
as a basis for delta when no other base is available
3851
3840
:param cache: A cache of RevisionTrees that we can use.
3841
:param a_graph: A Graph object to determine the heads() of the
3842
rich-root data stream.
3852
3843
:return: The revision_id of the last converted tree. The RevisionTree
3853
3844
for it will be in cache
3922
3913
if root_keys_to_create:
3923
3914
root_stream = _mod_fetch._new_root_data_stream(
3924
3915
root_keys_to_create, self._revision_id_to_root_id, parent_map,
3916
self.source, graph=a_graph)
3926
3917
to_texts.insert_record_stream(root_stream)
3927
3918
to_texts.insert_record_stream(from_texts.get_record_stream(
3928
3919
text_keys, self.target._format._fetch_order,
3985
3976
cache[basis_id] = basis_tree
3986
3977
del basis_tree # We don't want to hang on to it here
3979
if self._converting_to_rich_root and len(revision_ids) > 100:
3980
a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3990
3985
for offset in range(0, len(revision_ids), batch_size):
3991
3986
self.target.start_write_group()
3993
3988
pb.update('Transferring revisions', offset,
3994
3989
len(revision_ids))
3995
3990
batch = revision_ids[offset:offset+batch_size]
3996
basis_id = self._fetch_batch(batch, basis_id, cache)
3991
basis_id = self._fetch_batch(batch, basis_id, cache,
3998
3994
self.source._safe_to_return_from_cache = False
3999
3995
self.target.abort_write_group()
4013
4009
"""See InterRepository.fetch()."""
4014
4010
if fetch_spec is not None:
4015
4011
raise AssertionError("Not implemented yet...")
4016
ui.ui_factory.warn_experimental_format_fetch(self)
4012
# See <https://launchpad.net/bugs/456077> asking for a warning here
4014
# nb this is only active for local-local fetches; other things using
4016
ui.ui_factory.warn_cross_format_fetch(self.source._format,
4017
self.target._format)
4017
4018
if (not self.source.supports_rich_root()
4018
4019
and self.target.supports_rich_root()):
4019
4020
self._converting_to_rich_root = True
4020
4021
self._revision_id_to_root_id = {}
4022
4023
self._converting_to_rich_root = False
4023
# See <https://launchpad.net/bugs/456077> asking for a warning here
4024
if self.source._format.network_name() != self.target._format.network_name():
4025
ui.ui_factory.show_user_warning('cross_format_fetch',
4026
from_format=self.source._format,
4027
to_format=self.target._format)
4028
4024
revision_ids = self.target.search_missing_revision_ids(self.source,
4029
4025
revision_id, find_ghosts=find_ghosts).get_keys()
4030
4026
if not revision_ids:
4065
4061
basis_id = first_rev.parent_ids[0]
4066
4062
# only valid as a basis if the target has it
4067
4063
self.target.get_revision(basis_id)
4068
# Try to get a basis tree - if it's a ghost it will hit the
4064
# Try to get a basis tree - if its a ghost it will hit the
4069
4065
# NoSuchRevision case.
4070
4066
basis_tree = self.source.revision_tree(basis_id)
4071
4067
except (IndexError, errors.NoSuchRevision):
4099
4095
:param to_convert: The disk object to convert.
4100
4096
:param pb: a progress bar to use for progress information.
4102
pb = ui.ui_factory.nested_progress_bar()
4105
4101
# this is only useful with metadir layouts - separated repo content.
4106
4102
# trigger an assertion if not such
4107
4103
repo._format.get_format_string()
4108
4104
self.repo_dir = repo.bzrdir
4109
pb.update('Moving repository to repository.backup')
4105
self.step('Moving repository to repository.backup')
4110
4106
self.repo_dir.transport.move('repository', 'repository.backup')
4111
4107
backup_transport = self.repo_dir.transport.clone('repository.backup')
4112
4108
repo._format.check_conversion_target(self.target_format)
4113
4109
self.source_repo = repo._format.open(self.repo_dir,
4115
4111
_override_transport=backup_transport)
4116
pb.update('Creating new repository')
4112
self.step('Creating new repository')
4117
4113
converted = self.target_format.initialize(self.repo_dir,
4118
4114
self.source_repo.is_shared())
4119
4115
converted.lock_write()
4121
pb.update('Copying content')
4117
self.step('Copying content')
4122
4118
self.source_repo.copy_content_into(converted)
4124
4120
converted.unlock()
4125
pb.update('Deleting old repository content')
4121
self.step('Deleting old repository content')
4126
4122
self.repo_dir.transport.delete_tree('repository.backup')
4127
4123
ui.ui_factory.note('repository converted')
4125
def step(self, message):
4126
"""Update the pb by a step."""
4128
self.pb.update(message, self.count, self.total)
4131
4131
_unescape_map = {
4271
4271
is_resume = False
4273
4273
# locked_insert_stream performs a commit|suspend.
4274
return self._locked_insert_stream(stream, src_format,
4274
return self._locked_insert_stream(stream, src_format, is_resume)
4277
4276
self.target_repo.abort_write_group(suppress_errors=True)
4314
4313
self._extract_and_insert_inventories(
4315
4314
substream, src_serializer)
4316
4315
elif substream_type == 'inventory-deltas':
4316
ui.ui_factory.warn_cross_format_fetch(src_format,
4317
self.target_repo._format)
4317
4318
self._extract_and_insert_inventory_deltas(
4318
4319
substream, src_serializer)
4319
4320
elif substream_type == 'chk_bytes':
4325
4326
# required if the serializers are different only in terms of
4326
4327
# the inventory.
4327
4328
if src_serializer == to_serializer:
4328
self.target_repo.revisions.insert_record_stream(substream)
4329
self.target_repo.revisions.insert_record_stream(
4330
4332
self._extract_and_insert_revisions(substream,
4331
4333
src_serializer)
4439
4441
"""Create a StreamSource streaming from from_repository."""
4440
4442
self.from_repository = from_repository
4441
4443
self.to_format = to_format
4442
self._record_counter = RecordCounter()
4444
4445
def delta_on_metadata(self):
4445
4446
"""Return True if delta's are permitted on metadata streams.
added
removed
bzrlib/repository.py
