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
52
49
from bzrlib.testament import Testament
60
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.decorators import needs_read_lock, needs_write_lock
61
53
from bzrlib.inter import InterObject
62
54
from bzrlib.inventory import (
68
from bzrlib.recordcounter import RecordCounter
69
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
60
from bzrlib import registry
70
61
from bzrlib.trace import (
71
62
log_exception_quietly, note, mutter, mutter_callsite, warning)
75
66
_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
69
class CommitBuilder(object):
87
70
"""Provides an interface to build up a commit.
222
205
# an inventory delta was accumulated without creating a new
224
207
basis_id = self.basis_delta_revision
225
# We ignore the 'inventory' returned by add_inventory_by_delta
226
# because self.new_inventory is used to hint to the rest of the
227
# system what code path was taken
228
self.inv_sha1, _ = self.repository.add_inventory_by_delta(
208
self.inv_sha1 = self.repository.add_inventory_by_delta(
229
209
basis_id, self._basis_delta, self._new_revision_id,
244
224
def _gen_revision_id(self):
245
225
"""Return new revision-id."""
246
return generate_ids.gen_revision_id(self._committer, self._timestamp)
226
return generate_ids.gen_revision_id(self._config.username(),
248
229
def _generate_revision_if_needed(self):
249
230
"""Create a revision id if None was supplied.
290
271
:param tree: The tree which is being committed.
292
if len(self.parents) == 0:
293
raise errors.RootMissing()
273
# NB: if there are no parents then this method is not called, so no
274
# need to guard on parents having length.
294
275
entry = entry_factory['directory'](tree.path2id(''), '',
296
277
entry.revision = self._new_revision_id
435
416
# we don't need to commit this, because the caller already
436
417
# determined that an existing revision of this file is
437
# appropriate. If it's not being considered for committing then
418
# appropriate. If its not being considered for committing then
438
419
# it and all its parents to the root must be unaltered so
439
420
# no-change against the basis.
440
421
if ie.revision == self._new_revision_id:
756
737
# after iter_changes examines and decides it has changed,
757
738
# we will unconditionally record a new version even if some
758
739
# other process reverts it while commit is running (with
759
# the revert happening after iter_changes did its
740
# the revert happening after iter_changes did it's
762
743
entry.executable = True
871
852
# 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
855
######################################################################
895
class Repository(_RelockDebugMixin, controldir.ControlComponent):
859
class Repository(object):
896
860
"""Repository holding history for one or more branches.
898
862
The repository holds and retrieves historical information including
945
909
pointing to .bzr/repository.
948
# What class to use for a CommitBuilder. Often it's simpler to change this
912
# What class to use for a CommitBuilder. Often its simpler to change this
949
913
# in a Repository class subclass rather than to override
950
914
# get_commit_builder.
951
915
_commit_builder_class = CommitBuilder
1046
1010
" id and insertion revid (%r, %r)"
1047
1011
% (inv.revision_id, revision_id))
1048
1012
if inv.root is None:
1049
raise errors.RootMissing()
1013
raise AssertionError()
1050
1014
return self._add_inventory_checked(revision_id, inv, parents)
1052
1016
def _add_inventory_checked(self, revision_id, inv, parents):
1057
1021
:seealso: add_inventory, for the contract.
1059
inv_lines = self._serializer.write_inventory_to_lines(inv)
1023
inv_lines = self._serialise_inventory_to_lines(inv)
1060
1024
return self._inventory_add_lines(revision_id, parents,
1061
1025
inv_lines, check_content=False)
1269
1233
"""Check a single text from this repository."""
1270
1234
if kind == 'inventories':
1271
1235
rev_id = record.key[0]
1272
inv = self._deserialise_inventory(rev_id,
1236
inv = self.deserialise_inventory(rev_id,
1273
1237
record.get_bytes_as('fulltext'))
1274
1238
if last_object is not None:
1275
1239
delta = inv._make_delta(last_object)
1320
1284
:param _format: The format of the repository on disk.
1321
1285
:param a_bzrdir: The BzrDir of the repository.
1287
In the future we will have a single api for all stores for
1288
getting file texts, inventories and revisions, then
1289
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
1291
super(Repository, self).__init__()
1327
1292
self._format = _format
1328
1293
# the following are part of the public API for Repository:
1334
1299
self._reconcile_does_inventory_gc = True
1335
1300
self._reconcile_fixes_text_parents = False
1336
1301
self._reconcile_backsup_inventory = True
1302
# not right yet - should be more semantically clear ?
1304
# TODO: make sure to construct the right store classes, etc, depending
1305
# on whether escaping is required.
1306
self._warn_if_deprecated()
1337
1307
self._write_group = None
1338
1308
# Additional places to query for data.
1339
1309
self._fallback_repositories = []
1340
1310
# An InventoryEntry cache, used during deserialization
1341
1311
self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
1342
# Is it safe to return inventory entries directly from the entry cache,
1343
# rather copying them?
1344
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
1313
def __repr__(self):
1355
1314
if self._fallback_repositories:
1404
1363
data during reads, and allows a 'write_group' to be obtained. Write
1405
1364
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
1366
:param token: if this is already locked, then lock_write will fail
1414
1367
unless the token matches the existing lock.
1415
1368
:returns: a token if this instance supports tokens, otherwise None.
1418
1371
:raises MismatchedToken: if the specified token doesn't match the token
1419
1372
of the existing lock.
1420
1373
:seealso: start_write_group.
1421
:return: A RepositoryWriteLockResult.
1375
A token should be passed in if you know that you have locked the object
1376
some other way, and need to synchronise this object's state with that
1379
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1423
1381
locked = self.is_locked()
1424
token = self.control_files.lock_write(token=token)
1382
result = self.control_files.lock_write(token=token)
1426
self._warn_if_deprecated()
1427
self._note_lock('w')
1428
1384
for repo in self._fallback_repositories:
1429
1385
# Writes don't affect fallback repos
1430
1386
repo.lock_read()
1431
1387
self._refresh_data()
1432
return RepositoryWriteLockResult(self.unlock, token)
1434
1390
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
1391
locked = self.is_locked()
1441
1392
self.control_files.lock_read()
1443
self._warn_if_deprecated()
1444
self._note_lock('r')
1445
1394
for repo in self._fallback_repositories:
1446
1395
repo.lock_read()
1447
1396
self._refresh_data()
1448
return LogicalLockResult(self.unlock)
1450
1398
def get_physical_lock_status(self):
1451
1399
return self.control_files.get_physical_lock_status()
1512
1460
# now gather global repository information
1513
1461
# XXX: This is available for many repos regardless of listability.
1514
if self.user_transport.listable():
1462
if self.bzrdir.root_transport.listable():
1515
1463
# XXX: do we want to __define len__() ?
1516
1464
# Maybe the versionedfiles object should provide a different
1517
1465
# method to get the number of keys.
1527
1475
:param using: If True, list only branches using this repository.
1529
1477
if using and not self.is_shared():
1530
return self.bzrdir.list_branches()
1479
return [self.bzrdir.open_branch()]
1480
except errors.NotBranchError:
1531
1482
class Evaluator(object):
1533
1484
def __init__(self):
1542
1493
except errors.NoRepositoryPresent:
1545
return False, ([], repository)
1496
return False, (None, repository)
1546
1497
self.first_call = False
1547
value = (bzrdir.list_branches(), None)
1499
value = (bzrdir.open_branch(), None)
1500
except errors.NotBranchError:
1501
value = (None, None)
1548
1502
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)
1505
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
1506
self.bzrdir.root_transport, evaluate=Evaluator()):
1507
if branch is not None:
1508
branches.append(branch)
1555
1509
if not using and repository is not None:
1556
ret.extend(repository.find_branches())
1510
branches.extend(repository.find_branches())
1559
1513
@needs_read_lock
1560
1514
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1669
1623
return missing_keys
1671
1625
def refresh_data(self):
1672
"""Re-read any data needed to synchronise with disk.
1626
"""Re-read any data needed to to synchronise with disk.
1674
1628
This method is intended to be called after another repository instance
1675
1629
(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.
1630
repository. It may not be called during a write group, but may be
1631
called at any other time.
1633
if self.is_in_write_group():
1634
raise errors.InternalBzrError(
1635
"May not refresh_data while in a write group.")
1682
1636
self._refresh_data()
1684
1638
def resume_write_group(self, tokens):
1723
1677
"May not fetch while in a write group.")
1724
1678
# fast path same-url fetch operations
1725
1679
# TODO: lift out to somewhere common with RemoteRepository
1726
# <https://bugs.launchpad.net/bzr/+bug/401646>
1680
# <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1727
1681
if (self.has_same_location(source)
1728
1682
and fetch_spec is None
1729
1683
and self._has_same_fallbacks(source)):
1938
1891
rev = self._serializer.read_revision_from_string(text)
1939
1892
yield (revid, rev)
1895
def get_revision_xml(self, revision_id):
1896
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1897
# would have already do it.
1898
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1899
# TODO: this can't just be replaced by:
1900
# return self._serializer.write_revision_to_string(
1901
# self.get_revision(revision_id))
1902
# as cStringIO preservers the encoding unlike write_revision_to_string
1903
# or some other call down the path.
1904
rev = self.get_revision(revision_id)
1905
rev_tmp = cStringIO.StringIO()
1906
# the current serializer..
1907
self._serializer.write_revision(rev, rev_tmp)
1909
return rev_tmp.getvalue()
1941
1911
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1942
1912
"""Produce a generator of revision deltas.
2186
2156
selected_keys = set((revid,) for revid in revision_ids)
2187
2157
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),
2158
pb = ui.ui_factory.nested_progress_bar()
2160
return self._find_file_ids_from_xml_inventory_lines(
2161
w.iter_lines_added_or_present_in_keys(
2162
selected_keys, pb=pb),
2193
2167
def iter_files_bytes(self, desired_files):
2194
2168
"""Iterate through file versions.
2404
2378
"""single-document based inventory iteration."""
2405
2379
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2406
2380
for text, revision_id in inv_xmls:
2407
yield self._deserialise_inventory(revision_id, text)
2381
yield self.deserialise_inventory(revision_id, text)
2409
2383
def _iter_inventory_xmls(self, revision_ids, ordering):
2410
2384
if ordering is None:
2442
2416
next_key = None
2445
def _deserialise_inventory(self, revision_id, xml):
2419
def deserialise_inventory(self, revision_id, xml):
2446
2420
"""Transform the xml into an inventory object.
2448
2422
:param revision_id: The expected revision id of the inventory.
2449
2423
:param xml: A serialised inventory.
2451
2425
result = self._serializer.read_inventory_from_string(xml, revision_id,
2452
entry_cache=self._inventory_entry_cache,
2453
return_from_cache=self._safe_to_return_from_cache)
2426
entry_cache=self._inventory_entry_cache)
2454
2427
if result.revision_id != revision_id:
2455
2428
raise AssertionError('revision id mismatch %s != %s' % (
2456
2429
result.revision_id, revision_id))
2432
def serialise_inventory(self, inv):
2433
return self._serializer.write_inventory_to_string(inv)
2435
def _serialise_inventory_to_lines(self, inv):
2436
return self._serializer.write_inventory_to_lines(inv)
2459
2438
def get_serializer_format(self):
2460
2439
return self._serializer.format_num
2462
2441
@needs_read_lock
2463
def _get_inventory_xml(self, revision_id):
2464
"""Get serialized inventory as a string."""
2442
def get_inventory_xml(self, revision_id):
2443
"""Get inventory XML as a file object."""
2465
2444
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2467
2446
text, revision_id = texts.next()
2469
2448
raise errors.HistoryMissing(self, 'inventory', revision_id)
2452
def get_inventory_sha1(self, revision_id):
2453
"""Return the sha1 hash of the inventory entry
2455
return self.get_revision(revision_id).inventory_sha1
2472
2457
def get_rev_id_for_revno(self, revno, known_pair):
2473
2458
"""Return the revision id of a revno, given a later (revno, revid)
2474
2459
pair in the same history.
2511
2496
ancestors will be traversed.
2513
2498
graph = self.get_graph()
2514
stop_revisions = (None, _mod_revision.NULL_REVISION)
2515
return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
2499
next_id = revision_id
2501
if next_id in (None, _mod_revision.NULL_REVISION):
2504
parents = graph.get_parent_map([next_id])[next_id]
2506
raise errors.RevisionNotPresent(next_id, self)
2508
if len(parents) == 0:
2511
next_id = parents[0]
2514
def get_revision_inventory(self, revision_id):
2515
"""Return inventory of a past revision."""
2516
# TODO: Unify this with get_inventory()
2517
# bzr 0.0.6 and later imposes the constraint that the inventory_id
2518
# must be the same as its revision, so this is trivial.
2519
if revision_id is None:
2520
# This does not make sense: if there is no revision,
2521
# then it is the current tree inventory surely ?!
2522
# and thus get_root_id() is something that looks at the last
2523
# commit on the branch, and the get_root_id is an inventory check.
2524
raise NotImplementedError
2525
# return Inventory(self.get_root_id())
2527
return self.get_inventory(revision_id)
2517
2529
def is_shared(self):
2518
2530
"""Return True if this repository is flagged as a shared repository."""
2553
2565
return RevisionTree(self, Inventory(root_id=None),
2554
2566
_mod_revision.NULL_REVISION)
2556
inv = self.get_inventory(revision_id)
2568
inv = self.get_revision_inventory(revision_id)
2557
2569
return RevisionTree(self, inv, revision_id)
2559
2571
def revision_trees(self, revision_ids):
2612
2624
keys = tsort.topo_sort(parent_map)
2613
2625
return [None] + list(keys)
2615
def pack(self, hint=None, clean_obsolete_packs=False):
2627
def pack(self, hint=None):
2616
2628
"""Compress the data within the repository.
2618
2630
This operation only makes sense for some repository types. For other
2619
2631
types it should be a no-op that just returns.
2621
2633
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
2634
@needs_write_lock as this is a long running call its reasonable to
2623
2635
implicitly lock for the user.
2625
2637
:param hint: If not supplied, the whole repository is packed.
2628
2640
obtained from the result of commit_write_group(). Out of
2629
2641
date hints are simply ignored, because concurrent operations
2630
2642
can obsolete them rapidly.
2632
:param clean_obsolete_packs: Clean obsolete packs immediately after
2636
2645
def get_transaction(self):
2652
2661
for ((revision_id,), parent_keys) in \
2653
2662
self.revisions.get_parent_map(query_keys).iteritems():
2654
2663
if parent_keys:
2655
result[revision_id] = tuple([parent_revid
2656
for (parent_revid,) in parent_keys])
2664
result[revision_id] = tuple(parent_revid
2665
for (parent_revid,) in parent_keys)
2658
2667
result[revision_id] = (_mod_revision.NULL_REVISION,)
2661
2670
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
2673
def get_graph(self, other_repository=None):
2674
2674
"""Return the graph walker for this repository format"""
2675
2675
parents_provider = self._make_parents_provider()
2770
2770
result.check(callback_refs)
2773
def _warn_if_deprecated(self, branch=None):
2773
def _warn_if_deprecated(self):
2774
2774
global _deprecation_warning_done
2775
2775
if _deprecation_warning_done:
2779
conf = config.GlobalConfig()
2781
conf = branch.get_config()
2782
if conf.suppress_warning('format_deprecation'):
2784
warning("Format %s for %s is deprecated -"
2785
" please use 'bzr upgrade' to get better performance"
2786
% (self._format, self.bzrdir.transport.base))
2788
_deprecation_warning_done = True
2777
_deprecation_warning_done = True
2778
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
2779
% (self._format, self.bzrdir.transport.base))
2790
2781
def supports_rich_root(self):
2791
2782
return self._format.rich_root_data
3074
3065
pack_compresses = False
3075
3066
# Does the repository inventory storage understand references to trees?
3076
3067
supports_tree_reference = None
3077
# Is the format experimental ?
3078
experimental = False
3081
return "%s()" % self.__class__.__name__
3070
return "<%s>" % self.__class__.__name__
3083
3072
def __eq__(self, other):
3084
3073
# format objects are generally stateless
3099
3088
transport = a_bzrdir.get_repository_transport(None)
3100
format_string = transport.get_bytes("format")
3089
format_string = transport.get("format").read()
3101
3090
return format_registry.get(format_string)
3102
3091
except errors.NoSuchFile:
3103
3092
raise errors.NoRepositoryPresent(a_bzrdir)
3203
3192
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
3195
class MetaDirRepositoryFormat(RepositoryFormat):
3216
3196
"""Common base class for the new repositories using the metadir layout."""
3378
3358
'bzrlib.repofmt.groupcompress_repo',
3379
3359
'RepositoryFormat2a',
3381
format_registry.register_lazy(
3382
'Bazaar development format 8\n',
3383
'bzrlib.repofmt.groupcompress_repo',
3384
'RepositoryFormat2aSubtree',
3388
3363
class InterRepository(InterObject):
3427
3402
:param revision_id: if None all content is copied, if NULL_REVISION no
3428
3403
content is copied.
3404
:param pb: optional progress bar to use for progress reports. If not
3405
provided a default one will be created.
3432
ui.ui_factory.warn_experimental_format_fetch(self)
3433
3408
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
3409
f = RepoFetcher(to_repository=self.target,
3440
3410
from_repository=self.source,
3441
3411
last_revision=revision_id,
3442
3412
fetch_spec=fetch_spec,
3443
find_ghosts=find_ghosts)
3413
pb=pb, find_ghosts=find_ghosts)
3445
3415
def _walk_to_common_revisions(self, revision_ids):
3446
3416
"""Walk out from revision_ids in source to revisions target has.
3861
3831
pending_revisions = []
3862
3832
parent_map = self.source.get_parent_map(revision_ids)
3863
3833
self._fetch_parent_invs_for_stacking(parent_map, cache)
3864
self.source._safe_to_return_from_cache = True
3865
3834
for tree in self.source.revision_trees(revision_ids):
3866
3835
# Find a inventory delta for this revision.
3867
3836
# Find text entries that need to be copied, too.
3915
3884
pending_revisions.append(revision)
3916
3885
cache[current_revision_id] = tree
3917
3886
basis_id = current_revision_id
3918
self.source._safe_to_return_from_cache = False
3919
3887
# Copy file texts
3920
3888
from_texts = self.source.texts
3921
3889
to_texts = self.target.texts
3922
3890
if root_keys_to_create:
3923
root_stream = _mod_fetch._new_root_data_stream(
3891
from bzrlib.fetch import _new_root_data_stream
3892
root_stream = _new_root_data_stream(
3924
3893
root_keys_to_create, self._revision_id_to_root_id, parent_map,
3926
3895
to_texts.insert_record_stream(root_stream)
3985
3954
cache[basis_id] = basis_tree
3986
3955
del basis_tree # We don't want to hang on to it here
3990
3957
for offset in range(0, len(revision_ids), batch_size):
3991
3958
self.target.start_write_group()
3995
3962
batch = revision_ids[offset:offset+batch_size]
3996
3963
basis_id = self._fetch_batch(batch, basis_id, cache)
3998
self.source._safe_to_return_from_cache = False
3999
3965
self.target.abort_write_group()
4013
3979
"""See InterRepository.fetch()."""
4014
3980
if fetch_spec is not None:
4015
3981
raise AssertionError("Not implemented yet...")
4016
ui.ui_factory.warn_experimental_format_fetch(self)
4017
3982
if (not self.source.supports_rich_root()
4018
3983
and self.target.supports_rich_root()):
4019
3984
self._converting_to_rich_root = True
4020
3985
self._revision_id_to_root_id = {}
4022
3987
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
3988
revision_ids = self.target.search_missing_revision_ids(self.source,
4029
3989
revision_id, find_ghosts=find_ghosts).get_keys()
4030
3990
if not revision_ids:
4065
4025
basis_id = first_rev.parent_ids[0]
4066
4026
# only valid as a basis if the target has it
4067
4027
self.target.get_revision(basis_id)
4068
# Try to get a basis tree - if it's a ghost it will hit the
4028
# Try to get a basis tree - if its a ghost it will hit the
4069
4029
# NoSuchRevision case.
4070
4030
basis_tree = self.source.revision_tree(basis_id)
4071
4031
except (IndexError, errors.NoSuchRevision):
4099
4059
:param to_convert: The disk object to convert.
4100
4060
:param pb: a progress bar to use for progress information.
4102
pb = ui.ui_factory.nested_progress_bar()
4105
4065
# this is only useful with metadir layouts - separated repo content.
4106
4066
# trigger an assertion if not such
4107
4067
repo._format.get_format_string()
4108
4068
self.repo_dir = repo.bzrdir
4109
pb.update('Moving repository to repository.backup')
4069
self.step('Moving repository to repository.backup')
4110
4070
self.repo_dir.transport.move('repository', 'repository.backup')
4111
4071
backup_transport = self.repo_dir.transport.clone('repository.backup')
4112
4072
repo._format.check_conversion_target(self.target_format)
4113
4073
self.source_repo = repo._format.open(self.repo_dir,
4115
4075
_override_transport=backup_transport)
4116
pb.update('Creating new repository')
4076
self.step('Creating new repository')
4117
4077
converted = self.target_format.initialize(self.repo_dir,
4118
4078
self.source_repo.is_shared())
4119
4079
converted.lock_write()
4121
pb.update('Copying content')
4081
self.step('Copying content')
4122
4082
self.source_repo.copy_content_into(converted)
4124
4084
converted.unlock()
4125
pb.update('Deleting old repository content')
4085
self.step('Deleting old repository content')
4126
4086
self.repo_dir.transport.delete_tree('repository.backup')
4127
ui.ui_factory.note('repository converted')
4087
self.pb.note('repository converted')
4089
def step(self, message):
4090
"""Update the pb by a step."""
4092
self.pb.update(message, self.count, self.total)
4131
4095
_unescape_map = {
4271
4235
is_resume = False
4273
4237
# locked_insert_stream performs a commit|suspend.
4274
return self._locked_insert_stream(stream, src_format,
4238
return self._locked_insert_stream(stream, src_format, is_resume)
4277
4240
self.target_repo.abort_write_group(suppress_errors=True)
4325
4288
# required if the serializers are different only in terms of
4326
4289
# the inventory.
4327
4290
if src_serializer == to_serializer:
4328
self.target_repo.revisions.insert_record_stream(substream)
4291
self.target_repo.revisions.insert_record_stream(
4330
4294
self._extract_and_insert_revisions(substream,
4331
4295
src_serializer)
4352
4316
if versioned_file is None:
4354
# TODO: key is often going to be a StaticTuple object
4355
# I don't believe we can define a method by which
4356
# (prefix,) + StaticTuple will work, though we could
4357
# define a StaticTuple.sq_concat that would allow you to
4358
# pass in either a tuple or a StaticTuple as the second
4359
# object, so instead we could have:
4360
# StaticTuple(prefix) + key here...
4361
4318
missing_keys.update((prefix,) + key for key in
4362
4319
versioned_file.get_missing_compression_parent_keys())
4363
4320
except NotImplementedError:
4439
4396
"""Create a StreamSource streaming from from_repository."""
4440
4397
self.from_repository = from_repository
4441
4398
self.to_format = to_format
4442
self._record_counter = RecordCounter()
4444
4400
def delta_on_metadata(self):
4445
4401
"""Return True if delta's are permitted on metadata streams.
4476
4432
fetching the inventory weave.
4478
4434
if self._rich_root_upgrade():
4479
return _mod_fetch.Inter1and2Helper(
4436
return bzrlib.fetch.Inter1and2Helper(
4480
4437
self.from_repository).generate_root_texts(revs)
4625
4582
def _get_convertable_inventory_stream(self, revision_ids,
4626
4583
delta_versus_null=False):
4627
# The two formats are sufficiently different that there is no fast
4628
# path, so we need to send just inventorydeltas, which any
4629
# sufficiently modern client can insert into any repository.
4630
# The StreamSink code expects to be able to
4584
# The source is using CHKs, but the target either doesn't or it has a
4585
# different serializer. The StreamSink code expects to be able to
4631
4586
# convert on the target, so we need to put bytes-on-the-wire that can
4632
4587
# be converted. That means inventory deltas (if the remote is <1.19,
4633
4588
# RemoteStreamSink will fallback to VFS to insert the deltas).
added
removed
bzrlib/repository.py
