1
# Copyright (C) 2005-2010 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
51
50
from bzrlib.testament import Testament
59
53
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
60
54
from bzrlib.inter import InterObject
61
55
from bzrlib.inventory import (
67
from bzrlib.recordcounter import RecordCounter
68
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
61
from bzrlib.lock import _RelockDebugMixin
62
from bzrlib import registry
69
63
from bzrlib.trace import (
70
64
log_exception_quietly, note, mutter, mutter_callsite, warning)
74
68
_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
71
class CommitBuilder(object):
86
72
"""Provides an interface to build up a commit.
290
276
:param tree: The tree which is being committed.
292
if len(self.parents) == 0:
293
raise errors.RootMissing()
278
# NB: if there are no parents then this method is not called, so no
279
# need to guard on parents having length.
294
280
entry = entry_factory['directory'](tree.path2id(''), '',
296
282
entry.revision = self._new_revision_id
871
857
# 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
860
######################################################################
895
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
864
class Repository(_RelockDebugMixin):
896
865
"""Repository holding history for one or more branches.
898
867
The repository holds and retrieves historical information including
1046
1015
" id and insertion revid (%r, %r)"
1047
1016
% (inv.revision_id, revision_id))
1048
1017
if inv.root is None:
1049
raise errors.RootMissing()
1018
raise AssertionError()
1050
1019
return self._add_inventory_checked(revision_id, inv, parents)
1052
1021
def _add_inventory_checked(self, revision_id, inv, parents):
1057
1026
:seealso: add_inventory, for the contract.
1059
inv_lines = self._serializer.write_inventory_to_lines(inv)
1028
inv_lines = self._serialise_inventory_to_lines(inv)
1060
1029
return self._inventory_add_lines(revision_id, parents,
1061
1030
inv_lines, check_content=False)
1269
1238
"""Check a single text from this repository."""
1270
1239
if kind == 'inventories':
1271
1240
rev_id = record.key[0]
1272
inv = self._deserialise_inventory(rev_id,
1241
inv = self.deserialise_inventory(rev_id,
1273
1242
record.get_bytes_as('fulltext'))
1274
1243
if last_object is not None:
1275
1244
delta = inv._make_delta(last_object)
1320
1289
:param _format: The format of the repository on disk.
1321
1290
:param a_bzrdir: The BzrDir of the repository.
1292
In the future we will have a single api for all stores for
1293
getting file texts, inventories and revisions, then
1294
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
1296
super(Repository, self).__init__()
1327
1297
self._format = _format
1328
1298
# the following are part of the public API for Repository:
1334
1304
self._reconcile_does_inventory_gc = True
1335
1305
self._reconcile_fixes_text_parents = False
1336
1306
self._reconcile_backsup_inventory = True
1307
# not right yet - should be more semantically clear ?
1309
# TODO: make sure to construct the right store classes, etc, depending
1310
# on whether escaping is required.
1311
self._warn_if_deprecated()
1337
1312
self._write_group = None
1338
1313
# Additional places to query for data.
1339
1314
self._fallback_repositories = []
1343
1318
# rather copying them?
1344
1319
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
1321
def __repr__(self):
1355
1322
if self._fallback_repositories:
1356
1323
return '%s(%r, fallback_repositories=%r)' % (
1404
1371
data during reads, and allows a 'write_group' to be obtained. Write
1405
1372
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
1374
:param token: if this is already locked, then lock_write will fail
1414
1375
unless the token matches the existing lock.
1415
1376
:returns: a token if this instance supports tokens, otherwise None.
1418
1379
:raises MismatchedToken: if the specified token doesn't match the token
1419
1380
of the existing lock.
1420
1381
:seealso: start_write_group.
1421
:return: A RepositoryWriteLockResult.
1383
A token should be passed in if you know that you have locked the object
1384
some other way, and need to synchronise this object's state with that
1387
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1423
1389
locked = self.is_locked()
1424
token = self.control_files.lock_write(token=token)
1390
result = self.control_files.lock_write(token=token)
1426
self._warn_if_deprecated()
1427
1392
self._note_lock('w')
1428
1393
for repo in self._fallback_repositories:
1429
1394
# Writes don't affect fallback repos
1430
1395
repo.lock_read()
1431
1396
self._refresh_data()
1432
return RepositoryWriteLockResult(self.unlock, token)
1434
1399
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
1400
locked = self.is_locked()
1441
1401
self.control_files.lock_read()
1443
self._warn_if_deprecated()
1444
1403
self._note_lock('r')
1445
1404
for repo in self._fallback_repositories:
1446
1405
repo.lock_read()
1447
1406
self._refresh_data()
1448
return LogicalLockResult(self.unlock)
1450
1408
def get_physical_lock_status(self):
1451
1409
return self.control_files.get_physical_lock_status()
1512
1470
# now gather global repository information
1513
1471
# XXX: This is available for many repos regardless of listability.
1514
if self.user_transport.listable():
1472
if self.bzrdir.root_transport.listable():
1515
1473
# XXX: do we want to __define len__() ?
1516
1474
# Maybe the versionedfiles object should provide a different
1517
1475
# method to get the number of keys.
1527
1485
:param using: If True, list only branches using this repository.
1529
1487
if using and not self.is_shared():
1530
return self.bzrdir.list_branches()
1489
return [self.bzrdir.open_branch()]
1490
except errors.NotBranchError:
1531
1492
class Evaluator(object):
1533
1494
def __init__(self):
1542
1503
except errors.NoRepositoryPresent:
1545
return False, ([], repository)
1506
return False, (None, repository)
1546
1507
self.first_call = False
1547
value = (bzrdir.list_branches(), None)
1509
value = (bzrdir.open_branch(), None)
1510
except errors.NotBranchError:
1511
value = (None, None)
1548
1512
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)
1515
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
1516
self.bzrdir.root_transport, evaluate=Evaluator()):
1517
if branch is not None:
1518
branches.append(branch)
1555
1519
if not using and repository is not None:
1556
ret.extend(repository.find_branches())
1520
branches.extend(repository.find_branches())
1559
1523
@needs_read_lock
1560
1524
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1669
1633
return missing_keys
1671
1635
def refresh_data(self):
1672
"""Re-read any data needed to synchronise with disk.
1636
"""Re-read any data needed to to synchronise with disk.
1674
1638
This method is intended to be called after another repository instance
1675
1639
(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.
1640
repository. It may not be called during a write group, but may be
1641
called at any other time.
1643
if self.is_in_write_group():
1644
raise errors.InternalBzrError(
1645
"May not refresh_data while in a write group.")
1682
1646
self._refresh_data()
1684
1648
def resume_write_group(self, tokens):
1723
1687
"May not fetch while in a write group.")
1724
1688
# fast path same-url fetch operations
1725
1689
# TODO: lift out to somewhere common with RemoteRepository
1726
# <https://bugs.launchpad.net/bzr/+bug/401646>
1690
# <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1727
1691
if (self.has_same_location(source)
1728
1692
and fetch_spec is None
1729
1693
and self._has_same_fallbacks(source)):
1938
1902
rev = self._serializer.read_revision_from_string(text)
1939
1903
yield (revid, rev)
1906
def get_revision_xml(self, revision_id):
1907
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1908
# would have already do it.
1909
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1910
# TODO: this can't just be replaced by:
1911
# return self._serializer.write_revision_to_string(
1912
# self.get_revision(revision_id))
1913
# as cStringIO preservers the encoding unlike write_revision_to_string
1914
# or some other call down the path.
1915
rev = self.get_revision(revision_id)
1916
rev_tmp = cStringIO.StringIO()
1917
# the current serializer..
1918
self._serializer.write_revision(rev, rev_tmp)
1920
return rev_tmp.getvalue()
1941
1922
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1942
1923
"""Produce a generator of revision deltas.
2186
2167
selected_keys = set((revid,) for revid in revision_ids)
2187
2168
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),
2169
pb = ui.ui_factory.nested_progress_bar()
2171
return self._find_file_ids_from_xml_inventory_lines(
2172
w.iter_lines_added_or_present_in_keys(
2173
selected_keys, pb=pb),
2193
2178
def iter_files_bytes(self, desired_files):
2194
2179
"""Iterate through file versions.
2404
2389
"""single-document based inventory iteration."""
2405
2390
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2406
2391
for text, revision_id in inv_xmls:
2407
yield self._deserialise_inventory(revision_id, text)
2392
yield self.deserialise_inventory(revision_id, text)
2409
2394
def _iter_inventory_xmls(self, revision_ids, ordering):
2410
2395
if ordering is None:
2442
2427
next_key = None
2445
def _deserialise_inventory(self, revision_id, xml):
2430
def deserialise_inventory(self, revision_id, xml):
2446
2431
"""Transform the xml into an inventory object.
2448
2433
:param revision_id: The expected revision id of the inventory.
2456
2441
result.revision_id, revision_id))
2444
def serialise_inventory(self, inv):
2445
return self._serializer.write_inventory_to_string(inv)
2447
def _serialise_inventory_to_lines(self, inv):
2448
return self._serializer.write_inventory_to_lines(inv)
2459
2450
def get_serializer_format(self):
2460
2451
return self._serializer.format_num
2462
2453
@needs_read_lock
2463
def _get_inventory_xml(self, revision_id):
2464
"""Get serialized inventory as a string."""
2454
def get_inventory_xml(self, revision_id):
2455
"""Get inventory XML as a file object."""
2465
2456
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2467
2458
text, revision_id = texts.next()
2469
2460
raise errors.HistoryMissing(self, 'inventory', revision_id)
2464
def get_inventory_sha1(self, revision_id):
2465
"""Return the sha1 hash of the inventory entry
2467
return self.get_revision(revision_id).inventory_sha1
2472
2469
def get_rev_id_for_revno(self, revno, known_pair):
2473
2470
"""Return the revision id of a revno, given a later (revno, revid)
2474
2471
pair in the same history.
2526
2523
next_id = parents[0]
2526
def get_revision_inventory(self, revision_id):
2527
"""Return inventory of a past revision."""
2528
# TODO: Unify this with get_inventory()
2529
# bzr 0.0.6 and later imposes the constraint that the inventory_id
2530
# must be the same as its revision, so this is trivial.
2531
if revision_id is None:
2532
# This does not make sense: if there is no revision,
2533
# then it is the current tree inventory surely ?!
2534
# and thus get_root_id() is something that looks at the last
2535
# commit on the branch, and the get_root_id is an inventory check.
2536
raise NotImplementedError
2537
# return Inventory(self.get_root_id())
2539
return self.get_inventory(revision_id)
2528
2541
def is_shared(self):
2529
2542
"""Return True if this repository is flagged as a shared repository."""
2530
2543
raise NotImplementedError(self.is_shared)
2564
2577
return RevisionTree(self, Inventory(root_id=None),
2565
2578
_mod_revision.NULL_REVISION)
2567
inv = self.get_inventory(revision_id)
2580
inv = self.get_revision_inventory(revision_id)
2568
2581
return RevisionTree(self, inv, revision_id)
2570
2583
def revision_trees(self, revision_ids):
2623
2636
keys = tsort.topo_sort(parent_map)
2624
2637
return [None] + list(keys)
2626
def pack(self, hint=None, clean_obsolete_packs=False):
2639
def pack(self, hint=None):
2627
2640
"""Compress the data within the repository.
2629
2642
This operation only makes sense for some repository types. For other
2639
2652
obtained from the result of commit_write_group(). Out of
2640
2653
date hints are simply ignored, because concurrent operations
2641
2654
can obsolete them rapidly.
2643
:param clean_obsolete_packs: Clean obsolete packs immediately after
2647
2657
def get_transaction(self):
2672
2682
def _make_parents_provider(self):
2676
def get_known_graph_ancestry(self, revision_ids):
2677
"""Return the known graph for a set of revision ids and their ancestors.
2679
st = static_tuple.StaticTuple
2680
revision_keys = [st(r_id).intern() for r_id in revision_ids]
2681
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2682
return graph.GraphThunkIdsToKeys(known_graph)
2684
2685
def get_graph(self, other_repository=None):
2685
2686
"""Return the graph walker for this repository format"""
2686
2687
parents_provider = self._make_parents_provider()
2781
2782
result.check(callback_refs)
2784
def _warn_if_deprecated(self, branch=None):
2785
def _warn_if_deprecated(self):
2785
2786
global _deprecation_warning_done
2786
2787
if _deprecation_warning_done:
2790
conf = config.GlobalConfig()
2792
conf = branch.get_config()
2793
if conf.suppress_warning('format_deprecation'):
2795
warning("Format %s for %s is deprecated -"
2796
" please use 'bzr upgrade' to get better performance"
2797
% (self._format, self.bzrdir.transport.base))
2799
_deprecation_warning_done = True
2789
_deprecation_warning_done = True
2790
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
2791
% (self._format, self.bzrdir.transport.base))
2801
2793
def supports_rich_root(self):
2802
2794
return self._format.rich_root_data
3085
3077
pack_compresses = False
3086
3078
# Does the repository inventory storage understand references to trees?
3087
3079
supports_tree_reference = None
3088
# Is the format experimental ?
3089
experimental = False
3092
return "%s()" % self.__class__.__name__
3082
return "<%s>" % self.__class__.__name__
3094
3084
def __eq__(self, other):
3095
3085
# format objects are generally stateless
3214
3204
raise NotImplementedError(self.open)
3216
def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3217
from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3218
hooks = BzrDir.hooks['post_repo_init']
3221
params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3226
3207
class MetaDirRepositoryFormat(RepositoryFormat):
3227
3208
"""Common base class for the new repositories using the metadir layout."""
3433
3414
:param revision_id: if None all content is copied, if NULL_REVISION no
3434
3415
content is copied.
3416
:param pb: optional progress bar to use for progress reports. If not
3417
provided a default one will be created.
3438
ui.ui_factory.warn_experimental_format_fetch(self)
3439
from bzrlib.fetch import RepoFetcher
3440
# See <https://launchpad.net/bugs/456077> asking for a warning here
3441
if self.source._format.network_name() != self.target._format.network_name():
3442
ui.ui_factory.show_user_warning('cross_format_fetch',
3443
from_format=self.source._format,
3444
to_format=self.target._format)
3445
f = RepoFetcher(to_repository=self.target,
3420
f = _mod_fetch.RepoFetcher(to_repository=self.target,
3446
3421
from_repository=self.source,
3447
3422
last_revision=revision_id,
3448
3423
fetch_spec=fetch_spec,
3449
find_ghosts=find_ghosts)
3424
pb=pb, find_ghosts=find_ghosts)
3451
3426
def _walk_to_common_revisions(self, revision_ids):
3452
3427
"""Walk out from revision_ids in source to revisions target has.
4026
4001
"""See InterRepository.fetch()."""
4027
4002
if fetch_spec is not None:
4028
4003
raise AssertionError("Not implemented yet...")
4029
ui.ui_factory.warn_experimental_format_fetch(self)
4030
4004
if (not self.source.supports_rich_root()
4031
4005
and self.target.supports_rich_root()):
4032
4006
self._converting_to_rich_root = True
4033
4007
self._revision_id_to_root_id = {}
4035
4009
self._converting_to_rich_root = False
4036
# See <https://launchpad.net/bugs/456077> asking for a warning here
4037
if self.source._format.network_name() != self.target._format.network_name():
4038
ui.ui_factory.show_user_warning('cross_format_fetch',
4039
from_format=self.source._format,
4040
to_format=self.target._format)
4041
4010
revision_ids = self.target.search_missing_revision_ids(self.source,
4042
4011
revision_id, find_ghosts=find_ghosts).get_keys()
4043
4012
if not revision_ids:
4112
4081
:param to_convert: The disk object to convert.
4113
4082
:param pb: a progress bar to use for progress information.
4115
pb = ui.ui_factory.nested_progress_bar()
4118
4087
# this is only useful with metadir layouts - separated repo content.
4119
4088
# trigger an assertion if not such
4120
4089
repo._format.get_format_string()
4121
4090
self.repo_dir = repo.bzrdir
4122
pb.update('Moving repository to repository.backup')
4091
self.step('Moving repository to repository.backup')
4123
4092
self.repo_dir.transport.move('repository', 'repository.backup')
4124
4093
backup_transport = self.repo_dir.transport.clone('repository.backup')
4125
4094
repo._format.check_conversion_target(self.target_format)
4126
4095
self.source_repo = repo._format.open(self.repo_dir,
4128
4097
_override_transport=backup_transport)
4129
pb.update('Creating new repository')
4098
self.step('Creating new repository')
4130
4099
converted = self.target_format.initialize(self.repo_dir,
4131
4100
self.source_repo.is_shared())
4132
4101
converted.lock_write()
4134
pb.update('Copying content')
4103
self.step('Copying content')
4135
4104
self.source_repo.copy_content_into(converted)
4137
4106
converted.unlock()
4138
pb.update('Deleting old repository content')
4107
self.step('Deleting old repository content')
4139
4108
self.repo_dir.transport.delete_tree('repository.backup')
4140
4109
ui.ui_factory.note('repository converted')
4111
def step(self, message):
4112
"""Update the pb by a step."""
4114
self.pb.update(message, self.count, self.total)
4144
4117
_unescape_map = {
4284
4257
is_resume = False
4286
4259
# locked_insert_stream performs a commit|suspend.
4287
return self._locked_insert_stream(stream, src_format,
4260
return self._locked_insert_stream(stream, src_format, is_resume)
4290
4262
self.target_repo.abort_write_group(suppress_errors=True)
4338
4310
# required if the serializers are different only in terms of
4339
4311
# the inventory.
4340
4312
if src_serializer == to_serializer:
4341
self.target_repo.revisions.insert_record_stream(substream)
4313
self.target_repo.revisions.insert_record_stream(
4343
4316
self._extract_and_insert_revisions(substream,
4344
4317
src_serializer)
4452
4425
"""Create a StreamSource streaming from from_repository."""
4453
4426
self.from_repository = from_repository
4454
4427
self.to_format = to_format
4455
self._record_counter = RecordCounter()
4457
4429
def delta_on_metadata(self):
4458
4430
"""Return True if delta's are permitted on metadata streams.
4638
4610
def _get_convertable_inventory_stream(self, revision_ids,
4639
4611
delta_versus_null=False):
4640
# The two formats are sufficiently different that there is no fast
4641
# path, so we need to send just inventorydeltas, which any
4642
# sufficiently modern client can insert into any repository.
4643
# The StreamSink code expects to be able to
4612
# The source is using CHKs, but the target either doesn't or it has a
4613
# different serializer. The StreamSink code expects to be able to
4644
4614
# convert on the target, so we need to put bytes-on-the-wire that can
4645
4615
# be converted. That means inventory deltas (if the remote is <1.19,
4646
4616
# RemoteStreamSink will fallback to VFS to insert the deltas).
added
removed
bzrlib/repository.py
