51
52
from bzrlib.testament import Testament
59
55
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
60
56
from bzrlib.inter import InterObject
61
57
from bzrlib.inventory import (
67
from bzrlib.recordcounter import RecordCounter
68
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
63
from bzrlib.lock import _RelockDebugMixin
64
from bzrlib import registry
69
65
from bzrlib.trace import (
70
66
log_exception_quietly, note, mutter, mutter_callsite, warning)
74
70
_deprecation_warning_done = False
77
class IsInWriteGroupError(errors.InternalBzrError):
79
_fmt = "May not refresh_data of repo %(repo)s while in a write group."
81
def __init__(self, repo):
82
errors.InternalBzrError.__init__(self, repo=repo)
85
73
class CommitBuilder(object):
86
74
"""Provides an interface to build up a commit.
243
231
def _gen_revision_id(self):
244
232
"""Return new revision-id."""
245
return generate_ids.gen_revision_id(self._committer, self._timestamp)
233
return generate_ids.gen_revision_id(self._config.username(),
247
236
def _generate_revision_if_needed(self):
248
237
"""Create a revision id if None was supplied.
289
278
:param tree: The tree which is being committed.
291
if len(self.parents) == 0:
292
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.
293
282
entry = entry_factory['directory'](tree.path2id(''), '',
295
284
entry.revision = self._new_revision_id
870
859
# versioned roots do not change unless the tree found a change.
873
class RepositoryWriteLockResult(LogicalLockResult):
874
"""The result of write locking a repository.
876
:ivar repository_token: The token obtained from the underlying lock, or
878
:ivar unlock: A callable which will unlock the lock.
881
def __init__(self, unlock, repository_token):
882
LogicalLockResult.__init__(self, unlock)
883
self.repository_token = repository_token
886
return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
890
862
######################################################################
894
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
866
class Repository(_RelockDebugMixin):
895
867
"""Repository holding history for one or more branches.
897
869
The repository holds and retrieves historical information including
1045
1017
" id and insertion revid (%r, %r)"
1046
1018
% (inv.revision_id, revision_id))
1047
1019
if inv.root is None:
1048
raise errors.RootMissing()
1020
raise AssertionError()
1049
1021
return self._add_inventory_checked(revision_id, inv, parents)
1051
1023
def _add_inventory_checked(self, revision_id, inv, parents):
1056
1028
:seealso: add_inventory, for the contract.
1058
inv_lines = self._serializer.write_inventory_to_lines(inv)
1030
inv_lines = self._serialise_inventory_to_lines(inv)
1059
1031
return self._inventory_add_lines(revision_id, parents,
1060
1032
inv_lines, check_content=False)
1268
1240
"""Check a single text from this repository."""
1269
1241
if kind == 'inventories':
1270
1242
rev_id = record.key[0]
1271
inv = self._deserialise_inventory(rev_id,
1243
inv = self.deserialise_inventory(rev_id,
1272
1244
record.get_bytes_as('fulltext'))
1273
1245
if last_object is not None:
1274
1246
delta = inv._make_delta(last_object)
1319
1291
:param _format: The format of the repository on disk.
1320
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.
1322
# In the future we will have a single api for all stores for
1323
# getting file texts, inventories and revisions, then
1324
# this construct will accept instances of those things.
1325
1298
super(Repository, self).__init__()
1326
1299
self._format = _format
1327
1300
# the following are part of the public API for Repository:
1342
1315
# rather copying them?
1343
1316
self._safe_to_return_from_cache = False
1346
def user_transport(self):
1347
return self.bzrdir.user_transport
1350
def control_transport(self):
1351
return self._transport
1353
1318
def __repr__(self):
1354
1319
if self._fallback_repositories:
1355
1320
return '%s(%r, fallback_repositories=%r)' % (
1403
1368
data during reads, and allows a 'write_group' to be obtained. Write
1404
1369
groups must be used for actual data insertion.
1406
A token should be passed in if you know that you have locked the object
1407
some other way, and need to synchronise this object's state with that
1410
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1412
1371
:param token: if this is already locked, then lock_write will fail
1413
1372
unless the token matches the existing lock.
1414
1373
:returns: a token if this instance supports tokens, otherwise None.
1417
1376
:raises MismatchedToken: if the specified token doesn't match the token
1418
1377
of the existing lock.
1419
1378
:seealso: start_write_group.
1420
: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
1422
1386
locked = self.is_locked()
1423
token = self.control_files.lock_write(token=token)
1387
result = self.control_files.lock_write(token=token)
1425
1389
self._warn_if_deprecated()
1426
1390
self._note_lock('w')
1428
1392
# Writes don't affect fallback repos
1429
1393
repo.lock_read()
1430
1394
self._refresh_data()
1431
return RepositoryWriteLockResult(self.unlock, token)
1433
1397
def lock_read(self):
1434
"""Lock the repository for read operations.
1436
:return: An object with an unlock method which will release the lock
1439
1398
locked = self.is_locked()
1440
1399
self.control_files.lock_read()
1511
1469
# now gather global repository information
1512
1470
# XXX: This is available for many repos regardless of listability.
1513
if self.user_transport.listable():
1471
if self.bzrdir.root_transport.listable():
1514
1472
# XXX: do we want to __define len__() ?
1515
1473
# Maybe the versionedfiles object should provide a different
1516
1474
# method to get the number of keys.
1526
1484
:param using: If True, list only branches using this repository.
1528
1486
if using and not self.is_shared():
1529
return self.bzrdir.list_branches()
1488
return [self.bzrdir.open_branch()]
1489
except errors.NotBranchError:
1530
1491
class Evaluator(object):
1532
1493
def __init__(self):
1541
1502
except errors.NoRepositoryPresent:
1544
return False, ([], repository)
1505
return False, (None, repository)
1545
1506
self.first_call = False
1546
value = (bzrdir.list_branches(), None)
1508
value = (bzrdir.open_branch(), None)
1509
except errors.NotBranchError:
1510
value = (None, None)
1547
1511
return True, value
1550
for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1551
self.user_transport, evaluate=Evaluator()):
1552
if branches is not None:
1553
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)
1554
1518
if not using and repository is not None:
1555
ret.extend(repository.find_branches())
1519
branches.extend(repository.find_branches())
1558
1522
@needs_read_lock
1559
1523
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1668
1632
return missing_keys
1670
1634
def refresh_data(self):
1671
"""Re-read any data needed to synchronise with disk.
1635
"""Re-read any data needed to to synchronise with disk.
1673
1637
This method is intended to be called after another repository instance
1674
1638
(such as one used by a smart server) has inserted data into the
1675
repository. On all repositories this will work outside of write groups.
1676
Some repository formats (pack and newer for bzrlib native formats)
1677
support refresh_data inside write groups. If called inside a write
1678
group on a repository that does not support refreshing in a write group
1679
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.")
1681
1645
self._refresh_data()
1683
1647
def resume_write_group(self, tokens):
1722
1686
"May not fetch while in a write group.")
1723
1687
# fast path same-url fetch operations
1724
1688
# TODO: lift out to somewhere common with RemoteRepository
1725
# <https://bugs.launchpad.net/bzr/+bug/401646>
1689
# <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1726
1690
if (self.has_same_location(source)
1727
1691
and fetch_spec is None
1728
1692
and self._has_same_fallbacks(source)):
1937
1901
rev = self._serializer.read_revision_from_string(text)
1938
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()
1940
1921
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1941
1922
"""Produce a generator of revision deltas.
2185
2166
selected_keys = set((revid,) for revid in revision_ids)
2186
2167
w = _inv_weave or self.inventories
2187
return self._find_file_ids_from_xml_inventory_lines(
2188
w.iter_lines_added_or_present_in_keys(
2189
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),
2192
2177
def iter_files_bytes(self, desired_files):
2193
2178
"""Iterate through file versions.
2403
2388
"""single-document based inventory iteration."""
2404
2389
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2405
2390
for text, revision_id in inv_xmls:
2406
yield self._deserialise_inventory(revision_id, text)
2391
yield self.deserialise_inventory(revision_id, text)
2408
2393
def _iter_inventory_xmls(self, revision_ids, ordering):
2409
2394
if ordering is None:
2441
2426
next_key = None
2444
def _deserialise_inventory(self, revision_id, xml):
2429
def deserialise_inventory(self, revision_id, xml):
2445
2430
"""Transform the xml into an inventory object.
2447
2432
:param revision_id: The expected revision id of the inventory.
2455
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)
2458
2449
def get_serializer_format(self):
2459
2450
return self._serializer.format_num
2461
2452
@needs_read_lock
2462
def _get_inventory_xml(self, revision_id):
2463
"""Get serialized inventory as a string."""
2453
def get_inventory_xml(self, revision_id):
2454
"""Get inventory XML as a file object."""
2464
2455
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2466
2457
text, revision_id = texts.next()
2468
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
2471
2468
def get_rev_id_for_revno(self, revno, known_pair):
2472
2469
"""Return the revision id of a revno, given a later (revno, revid)
2473
2470
pair in the same history.
2525
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)
2527
2540
def is_shared(self):
2528
2541
"""Return True if this repository is flagged as a shared repository."""
2529
2542
raise NotImplementedError(self.is_shared)
2563
2576
return RevisionTree(self, Inventory(root_id=None),
2564
2577
_mod_revision.NULL_REVISION)
2566
inv = self.get_inventory(revision_id)
2579
inv = self.get_revision_inventory(revision_id)
2567
2580
return RevisionTree(self, inv, revision_id)
2569
2582
def revision_trees(self, revision_ids):
2622
2635
keys = tsort.topo_sort(parent_map)
2623
2636
return [None] + list(keys)
2625
def pack(self, hint=None, clean_obsolete_packs=False):
2638
def pack(self, hint=None):
2626
2639
"""Compress the data within the repository.
2628
2641
This operation only makes sense for some repository types. For other
2638
2651
obtained from the result of commit_write_group(). Out of
2639
2652
date hints are simply ignored, because concurrent operations
2640
2653
can obsolete them rapidly.
2642
:param clean_obsolete_packs: Clean obsolete packs immediately after
2646
2656
def get_transaction(self):
2671
2681
def _make_parents_provider(self):
2675
def get_known_graph_ancestry(self, revision_ids):
2676
"""Return the known graph for a set of revision ids and their ancestors.
2678
st = static_tuple.StaticTuple
2679
revision_keys = [st(r_id).intern() for r_id in revision_ids]
2680
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2681
return graph.GraphThunkIdsToKeys(known_graph)
2683
2684
def get_graph(self, other_repository=None):
2684
2685
"""Return the graph walker for this repository format"""
2685
2686
parents_provider = self._make_parents_provider()
3084
3085
pack_compresses = False
3085
3086
# Does the repository inventory storage understand references to trees?
3086
3087
supports_tree_reference = None
3087
# Is the format experimental ?
3088
experimental = False
3091
return "%s()" % self.__class__.__name__
3090
return "<%s>" % self.__class__.__name__
3093
3092
def __eq__(self, other):
3094
3093
# format objects are generally stateless
3213
3212
raise NotImplementedError(self.open)
3215
def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3216
from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3217
hooks = BzrDir.hooks['post_repo_init']
3220
params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3225
3215
class MetaDirRepositoryFormat(RepositoryFormat):
3226
3216
"""Common base class for the new repositories using the metadir layout."""
3432
3422
:param revision_id: if None all content is copied, if NULL_REVISION no
3433
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.
3437
ui.ui_factory.warn_experimental_format_fetch(self)
3438
from bzrlib.fetch import RepoFetcher
3439
# See <https://launchpad.net/bugs/456077> asking for a warning here
3440
if self.source._format.network_name() != self.target._format.network_name():
3441
ui.ui_factory.show_user_warning('cross_format_fetch',
3442
from_format=self.source._format,
3443
to_format=self.target._format)
3444
f = RepoFetcher(to_repository=self.target,
3428
f = _mod_fetch.RepoFetcher(to_repository=self.target,
3445
3429
from_repository=self.source,
3446
3430
last_revision=revision_id,
3447
3431
fetch_spec=fetch_spec,
3448
find_ghosts=find_ghosts)
3432
pb=pb, find_ghosts=find_ghosts)
3450
3434
def _walk_to_common_revisions(self, revision_ids):
3451
3435
"""Walk out from revision_ids in source to revisions target has.
4025
4009
"""See InterRepository.fetch()."""
4026
4010
if fetch_spec is not None:
4027
4011
raise AssertionError("Not implemented yet...")
4028
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)
4029
4018
if (not self.source.supports_rich_root()
4030
4019
and self.target.supports_rich_root()):
4031
4020
self._converting_to_rich_root = True
4032
4021
self._revision_id_to_root_id = {}
4034
4023
self._converting_to_rich_root = False
4035
# See <https://launchpad.net/bugs/456077> asking for a warning here
4036
if self.source._format.network_name() != self.target._format.network_name():
4037
ui.ui_factory.show_user_warning('cross_format_fetch',
4038
from_format=self.source._format,
4039
to_format=self.target._format)
4040
4024
revision_ids = self.target.search_missing_revision_ids(self.source,
4041
4025
revision_id, find_ghosts=find_ghosts).get_keys()
4042
4026
if not revision_ids:
4111
4095
:param to_convert: The disk object to convert.
4112
4096
:param pb: a progress bar to use for progress information.
4114
pb = ui.ui_factory.nested_progress_bar()
4117
4101
# this is only useful with metadir layouts - separated repo content.
4118
4102
# trigger an assertion if not such
4119
4103
repo._format.get_format_string()
4120
4104
self.repo_dir = repo.bzrdir
4121
pb.update('Moving repository to repository.backup')
4105
self.step('Moving repository to repository.backup')
4122
4106
self.repo_dir.transport.move('repository', 'repository.backup')
4123
4107
backup_transport = self.repo_dir.transport.clone('repository.backup')
4124
4108
repo._format.check_conversion_target(self.target_format)
4125
4109
self.source_repo = repo._format.open(self.repo_dir,
4127
4111
_override_transport=backup_transport)
4128
pb.update('Creating new repository')
4112
self.step('Creating new repository')
4129
4113
converted = self.target_format.initialize(self.repo_dir,
4130
4114
self.source_repo.is_shared())
4131
4115
converted.lock_write()
4133
pb.update('Copying content')
4117
self.step('Copying content')
4134
4118
self.source_repo.copy_content_into(converted)
4136
4120
converted.unlock()
4137
pb.update('Deleting old repository content')
4121
self.step('Deleting old repository content')
4138
4122
self.repo_dir.transport.delete_tree('repository.backup')
4139
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)
4143
4131
_unescape_map = {
4283
4271
is_resume = False
4285
4273
# locked_insert_stream performs a commit|suspend.
4286
return self._locked_insert_stream(stream, src_format,
4274
return self._locked_insert_stream(stream, src_format, is_resume)
4289
4276
self.target_repo.abort_write_group(suppress_errors=True)
4326
4313
self._extract_and_insert_inventories(
4327
4314
substream, src_serializer)
4328
4315
elif substream_type == 'inventory-deltas':
4316
ui.ui_factory.warn_cross_format_fetch(src_format,
4317
self.target_repo._format)
4329
4318
self._extract_and_insert_inventory_deltas(
4330
4319
substream, src_serializer)
4331
4320
elif substream_type == 'chk_bytes':
4337
4326
# required if the serializers are different only in terms of
4338
4327
# the inventory.
4339
4328
if src_serializer == to_serializer:
4340
self.target_repo.revisions.insert_record_stream(substream)
4329
self.target_repo.revisions.insert_record_stream(
4342
4332
self._extract_and_insert_revisions(substream,
4343
4333
src_serializer)
4451
4441
"""Create a StreamSource streaming from from_repository."""
4452
4442
self.from_repository = from_repository
4453
4443
self.to_format = to_format
4454
self._record_counter = RecordCounter()
4456
4445
def delta_on_metadata(self):
4457
4446
"""Return True if delta's are permitted on metadata streams.
added
removed
bzrlib/repository.py
