1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
1
# Copyright (C) 2005-2010 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
49
52
from bzrlib.testament import Testament
52
60
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
53
from bzrlib.lock import _RelockDebugMixin
54
61
from bzrlib.inter import InterObject
55
62
from bzrlib.inventory import (
61
from bzrlib import registry
68
from bzrlib.recordcounter import RecordCounter
69
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
62
70
from bzrlib.trace import (
63
71
log_exception_quietly, note, mutter, mutter_callsite, warning)
67
75
_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)
70
86
class CommitBuilder(object):
71
87
"""Provides an interface to build up a commit.
206
222
# an inventory delta was accumulated without creating a new
208
224
basis_id = self.basis_delta_revision
209
self.inv_sha1 = self.repository.add_inventory_by_delta(
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(
210
229
basis_id, self._basis_delta, self._new_revision_id,
225
244
def _gen_revision_id(self):
226
245
"""Return new revision-id."""
227
return generate_ids.gen_revision_id(self._config.username(),
246
return generate_ids.gen_revision_id(self._committer, self._timestamp)
230
248
def _generate_revision_if_needed(self):
231
249
"""Create a revision id if None was supplied.
272
290
:param tree: The tree which is being committed.
274
# NB: if there are no parents then this method is not called, so no
275
# need to guard on parents having length.
292
if len(self.parents) == 0:
293
raise errors.RootMissing()
276
294
entry = entry_factory['directory'](tree.path2id(''), '',
278
296
entry.revision = self._new_revision_id
853
871
# 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,
856
891
######################################################################
860
class Repository(_RelockDebugMixin):
895
class Repository(_RelockDebugMixin, controldir.ControlComponent):
861
896
"""Repository holding history for one or more branches.
863
898
The repository holds and retrieves historical information including
1011
1046
" id and insertion revid (%r, %r)"
1012
1047
% (inv.revision_id, revision_id))
1013
1048
if inv.root is None:
1014
raise AssertionError()
1049
raise errors.RootMissing()
1015
1050
return self._add_inventory_checked(revision_id, inv, parents)
1017
1052
def _add_inventory_checked(self, revision_id, inv, parents):
1022
1057
:seealso: add_inventory, for the contract.
1024
inv_lines = self._serialise_inventory_to_lines(inv)
1059
inv_lines = self._serializer.write_inventory_to_lines(inv)
1025
1060
return self._inventory_add_lines(revision_id, parents,
1026
1061
inv_lines, check_content=False)
1234
1269
"""Check a single text from this repository."""
1235
1270
if kind == 'inventories':
1236
1271
rev_id = record.key[0]
1237
inv = self.deserialise_inventory(rev_id,
1272
inv = self._deserialise_inventory(rev_id,
1238
1273
record.get_bytes_as('fulltext'))
1239
1274
if last_object is not None:
1240
1275
delta = inv._make_delta(last_object)
1285
1320
:param _format: The format of the repository on disk.
1286
1321
:param a_bzrdir: The BzrDir of the repository.
1288
In the future we will have a single api for all stores for
1289
getting file texts, inventories and revisions, then
1290
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.
1292
1326
super(Repository, self).__init__()
1293
1327
self._format = _format
1294
1328
# the following are part of the public API for Repository:
1300
1334
self._reconcile_does_inventory_gc = True
1301
1335
self._reconcile_fixes_text_parents = False
1302
1336
self._reconcile_backsup_inventory = True
1303
# not right yet - should be more semantically clear ?
1305
# TODO: make sure to construct the right store classes, etc, depending
1306
# on whether escaping is required.
1307
self._warn_if_deprecated()
1308
1337
self._write_group = None
1309
1338
# Additional places to query for data.
1310
1339
self._fallback_repositories = []
1311
1340
# An InventoryEntry cache, used during deserialization
1312
1341
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
1314
1354
def __repr__(self):
1315
1355
if self._fallback_repositories:
1364
1404
data during reads, and allows a 'write_group' to be obtained. Write
1365
1405
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
1367
1413
:param token: if this is already locked, then lock_write will fail
1368
1414
unless the token matches the existing lock.
1369
1415
:returns: a token if this instance supports tokens, otherwise None.
1372
1418
:raises MismatchedToken: if the specified token doesn't match the token
1373
1419
of the existing lock.
1374
1420
:seealso: start_write_group.
1376
A token should be passed in if you know that you have locked the object
1377
some other way, and need to synchronise this object's state with that
1380
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1421
:return: A RepositoryWriteLockResult.
1382
1423
locked = self.is_locked()
1383
result = self.control_files.lock_write(token=token)
1424
token = self.control_files.lock_write(token=token)
1426
self._warn_if_deprecated()
1385
1427
self._note_lock('w')
1386
1428
for repo in self._fallback_repositories:
1387
1429
# Writes don't affect fallback repos
1388
1430
repo.lock_read()
1389
1431
self._refresh_data()
1432
return RepositoryWriteLockResult(self.unlock, token)
1392
1434
def lock_read(self):
1435
"""Lock the repository for read operations.
1437
:return: An object with an unlock method which will release the lock
1393
1440
locked = self.is_locked()
1394
1441
self.control_files.lock_read()
1443
self._warn_if_deprecated()
1396
1444
self._note_lock('r')
1397
1445
for repo in self._fallback_repositories:
1398
1446
repo.lock_read()
1399
1447
self._refresh_data()
1448
return LogicalLockResult(self.unlock)
1401
1450
def get_physical_lock_status(self):
1402
1451
return self.control_files.get_physical_lock_status()
1463
1512
# now gather global repository information
1464
1513
# XXX: This is available for many repos regardless of listability.
1465
if self.bzrdir.root_transport.listable():
1514
if self.user_transport.listable():
1466
1515
# XXX: do we want to __define len__() ?
1467
1516
# Maybe the versionedfiles object should provide a different
1468
1517
# method to get the number of keys.
1478
1527
:param using: If True, list only branches using this repository.
1480
1529
if using and not self.is_shared():
1482
return [self.bzrdir.open_branch()]
1483
except errors.NotBranchError:
1530
return self.bzrdir.list_branches()
1485
1531
class Evaluator(object):
1487
1533
def __init__(self):
1496
1542
except errors.NoRepositoryPresent:
1499
return False, (None, repository)
1545
return False, ([], repository)
1500
1546
self.first_call = False
1502
value = (bzrdir.open_branch(), None)
1503
except errors.NotBranchError:
1504
value = (None, None)
1547
value = (bzrdir.list_branches(), None)
1505
1548
return True, value
1508
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
1509
self.bzrdir.root_transport, evaluate=Evaluator()):
1510
if branch is not None:
1511
branches.append(branch)
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)
1512
1555
if not using and repository is not None:
1513
branches.extend(repository.find_branches())
1556
ret.extend(repository.find_branches())
1516
1559
@needs_read_lock
1517
1560
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1626
1669
return missing_keys
1628
1671
def refresh_data(self):
1629
"""Re-read any data needed to to synchronise with disk.
1672
"""Re-read any data needed to synchronise with disk.
1631
1674
This method is intended to be called after another repository instance
1632
1675
(such as one used by a smart server) has inserted data into the
1633
repository. It may not be called during a write group, but may be
1634
called at any other time.
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.
1636
if self.is_in_write_group():
1637
raise errors.InternalBzrError(
1638
"May not refresh_data while in a write group.")
1639
1682
self._refresh_data()
1641
1684
def resume_write_group(self, tokens):
1680
1723
"May not fetch while in a write group.")
1681
1724
# fast path same-url fetch operations
1682
1725
# TODO: lift out to somewhere common with RemoteRepository
1683
# <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1726
# <https://bugs.launchpad.net/bzr/+bug/401646>
1684
1727
if (self.has_same_location(source)
1685
1728
and fetch_spec is None
1686
1729
and self._has_same_fallbacks(source)):
1895
1938
rev = self._serializer.read_revision_from_string(text)
1896
1939
yield (revid, rev)
1899
def get_revision_xml(self, revision_id):
1900
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1901
# would have already do it.
1902
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1903
# TODO: this can't just be replaced by:
1904
# return self._serializer.write_revision_to_string(
1905
# self.get_revision(revision_id))
1906
# as cStringIO preservers the encoding unlike write_revision_to_string
1907
# or some other call down the path.
1908
rev = self.get_revision(revision_id)
1909
rev_tmp = cStringIO.StringIO()
1910
# the current serializer..
1911
self._serializer.write_revision(rev, rev_tmp)
1913
return rev_tmp.getvalue()
1915
1941
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1916
1942
"""Produce a generator of revision deltas.
2160
2186
selected_keys = set((revid,) for revid in revision_ids)
2161
2187
w = _inv_weave or self.inventories
2162
pb = ui.ui_factory.nested_progress_bar()
2164
return self._find_file_ids_from_xml_inventory_lines(
2165
w.iter_lines_added_or_present_in_keys(
2166
selected_keys, pb=pb),
2188
return self._find_file_ids_from_xml_inventory_lines(
2189
w.iter_lines_added_or_present_in_keys(
2190
selected_keys, pb=None),
2171
2193
def iter_files_bytes(self, desired_files):
2172
2194
"""Iterate through file versions.
2382
2404
"""single-document based inventory iteration."""
2383
2405
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2384
2406
for text, revision_id in inv_xmls:
2385
yield self.deserialise_inventory(revision_id, text)
2407
yield self._deserialise_inventory(revision_id, text)
2387
2409
def _iter_inventory_xmls(self, revision_ids, ordering):
2388
2410
if ordering is None:
2420
2442
next_key = None
2423
def deserialise_inventory(self, revision_id, xml):
2445
def _deserialise_inventory(self, revision_id, xml):
2424
2446
"""Transform the xml into an inventory object.
2426
2448
:param revision_id: The expected revision id of the inventory.
2427
2449
:param xml: A serialised inventory.
2429
2451
result = self._serializer.read_inventory_from_string(xml, revision_id,
2430
entry_cache=self._inventory_entry_cache)
2452
entry_cache=self._inventory_entry_cache,
2453
return_from_cache=self._safe_to_return_from_cache)
2431
2454
if result.revision_id != revision_id:
2432
2455
raise AssertionError('revision id mismatch %s != %s' % (
2433
2456
result.revision_id, revision_id))
2436
def serialise_inventory(self, inv):
2437
return self._serializer.write_inventory_to_string(inv)
2439
def _serialise_inventory_to_lines(self, inv):
2440
return self._serializer.write_inventory_to_lines(inv)
2442
2459
def get_serializer_format(self):
2443
2460
return self._serializer.format_num
2445
2462
@needs_read_lock
2446
def get_inventory_xml(self, revision_id):
2447
"""Get inventory XML as a file object."""
2463
def _get_inventory_xml(self, revision_id):
2464
"""Get serialized inventory as a string."""
2448
2465
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2450
2467
text, revision_id = texts.next()
2452
2469
raise errors.HistoryMissing(self, 'inventory', revision_id)
2456
def get_inventory_sha1(self, revision_id):
2457
"""Return the sha1 hash of the inventory entry
2459
return self.get_revision(revision_id).inventory_sha1
2461
2472
def get_rev_id_for_revno(self, revno, known_pair):
2462
2473
"""Return the revision id of a revno, given a later (revno, revid)
2463
2474
pair in the same history.
2515
2526
next_id = parents[0]
2518
def get_revision_inventory(self, revision_id):
2519
"""Return inventory of a past revision."""
2520
# TODO: Unify this with get_inventory()
2521
# bzr 0.0.6 and later imposes the constraint that the inventory_id
2522
# must be the same as its revision, so this is trivial.
2523
if revision_id is None:
2524
# This does not make sense: if there is no revision,
2525
# then it is the current tree inventory surely ?!
2526
# and thus get_root_id() is something that looks at the last
2527
# commit on the branch, and the get_root_id is an inventory check.
2528
raise NotImplementedError
2529
# return Inventory(self.get_root_id())
2531
return self.get_inventory(revision_id)
2533
2528
def is_shared(self):
2534
2529
"""Return True if this repository is flagged as a shared repository."""
2535
2530
raise NotImplementedError(self.is_shared)
2569
2564
return RevisionTree(self, Inventory(root_id=None),
2570
2565
_mod_revision.NULL_REVISION)
2572
inv = self.get_revision_inventory(revision_id)
2567
inv = self.get_inventory(revision_id)
2573
2568
return RevisionTree(self, inv, revision_id)
2575
2570
def revision_trees(self, revision_ids):
2628
2623
keys = tsort.topo_sort(parent_map)
2629
2624
return [None] + list(keys)
2631
def pack(self, hint=None):
2626
def pack(self, hint=None, clean_obsolete_packs=False):
2632
2627
"""Compress the data within the repository.
2634
2629
This operation only makes sense for some repository types. For other
2644
2639
obtained from the result of commit_write_group(). Out of
2645
2640
date hints are simply ignored, because concurrent operations
2646
2641
can obsolete them rapidly.
2643
:param clean_obsolete_packs: Clean obsolete packs immediately after
2649
2647
def get_transaction(self):
2665
2663
for ((revision_id,), parent_keys) in \
2666
2664
self.revisions.get_parent_map(query_keys).iteritems():
2667
2665
if parent_keys:
2668
result[revision_id] = tuple(parent_revid
2669
for (parent_revid,) in parent_keys)
2666
result[revision_id] = tuple([parent_revid
2667
for (parent_revid,) in parent_keys])
2671
2669
result[revision_id] = (_mod_revision.NULL_REVISION,)
2674
2672
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)
2677
2684
def get_graph(self, other_repository=None):
2678
2685
"""Return the graph walker for this repository format"""
2679
2686
parents_provider = self._make_parents_provider()
2774
2781
result.check(callback_refs)
2777
def _warn_if_deprecated(self):
2784
def _warn_if_deprecated(self, branch=None):
2778
2785
global _deprecation_warning_done
2779
2786
if _deprecation_warning_done:
2781
_deprecation_warning_done = True
2782
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
2783
% (self._format, self.bzrdir.transport.base))
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
2785
2801
def supports_rich_root(self):
2786
2802
return self._format.rich_root_data
3069
3085
pack_compresses = False
3070
3086
# Does the repository inventory storage understand references to trees?
3071
3087
supports_tree_reference = None
3088
# Is the format experimental ?
3089
experimental = False
3074
return "<%s>" % self.__class__.__name__
3092
return "%s()" % self.__class__.__name__
3076
3094
def __eq__(self, other):
3077
3095
# format objects are generally stateless
3092
3110
transport = a_bzrdir.get_repository_transport(None)
3093
format_string = transport.get("format").read()
3111
format_string = transport.get_bytes("format")
3094
3112
return format_registry.get(format_string)
3095
3113
except errors.NoSuchFile:
3096
3114
raise errors.NoRepositoryPresent(a_bzrdir)
3196
3214
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)
3199
3226
class MetaDirRepositoryFormat(RepositoryFormat):
3200
3227
"""Common base class for the new repositories using the metadir layout."""
3406
3433
:param revision_id: if None all content is copied, if NULL_REVISION no
3407
3434
content is copied.
3408
:param pb: optional progress bar to use for progress reports. If not
3409
provided a default one will be created.
3438
ui.ui_factory.warn_experimental_format_fetch(self)
3412
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)
3413
3445
f = RepoFetcher(to_repository=self.target,
3414
3446
from_repository=self.source,
3415
3447
last_revision=revision_id,
3416
3448
fetch_spec=fetch_spec,
3417
pb=pb, find_ghosts=find_ghosts)
3449
find_ghosts=find_ghosts)
3419
3451
def _walk_to_common_revisions(self, revision_ids):
3420
3452
"""Walk out from revision_ids in source to revisions target has.
3816
3848
basis_id, delta, current_revision_id, parents_parents)
3817
3849
cache[current_revision_id] = parent_tree
3819
def _fetch_batch(self, revision_ids, basis_id, cache):
3851
def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
3820
3852
"""Fetch across a few revisions.
3822
3854
:param revision_ids: The revisions to copy
3823
3855
:param basis_id: The revision_id of a tree that must be in cache, used
3824
3856
as a basis for delta when no other base is available
3825
3857
:param cache: A cache of RevisionTrees that we can use.
3858
:param a_graph: A Graph object to determine the heads() of the
3859
rich-root data stream.
3826
3860
:return: The revision_id of the last converted tree. The RevisionTree
3827
3861
for it will be in cache
3835
3869
pending_revisions = []
3836
3870
parent_map = self.source.get_parent_map(revision_ids)
3837
3871
self._fetch_parent_invs_for_stacking(parent_map, cache)
3872
self.source._safe_to_return_from_cache = True
3838
3873
for tree in self.source.revision_trees(revision_ids):
3839
3874
# Find a inventory delta for this revision.
3840
3875
# Find text entries that need to be copied, too.
3888
3923
pending_revisions.append(revision)
3889
3924
cache[current_revision_id] = tree
3890
3925
basis_id = current_revision_id
3926
self.source._safe_to_return_from_cache = False
3891
3927
# Copy file texts
3892
3928
from_texts = self.source.texts
3893
3929
to_texts = self.target.texts
3894
3930
if root_keys_to_create:
3895
from bzrlib.fetch import _new_root_data_stream
3896
root_stream = _new_root_data_stream(
3931
root_stream = _mod_fetch._new_root_data_stream(
3897
3932
root_keys_to_create, self._revision_id_to_root_id, parent_map,
3933
self.source, graph=a_graph)
3899
3934
to_texts.insert_record_stream(root_stream)
3900
3935
to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3936
text_keys, self.target._format._fetch_order,
3958
3993
cache[basis_id] = basis_tree
3959
3994
del basis_tree # We don't want to hang on to it here
3996
if self._converting_to_rich_root and len(revision_ids) > 100:
3997
a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3961
4002
for offset in range(0, len(revision_ids), batch_size):
3962
4003
self.target.start_write_group()
3964
4005
pb.update('Transferring revisions', offset,
3965
4006
len(revision_ids))
3966
4007
batch = revision_ids[offset:offset+batch_size]
3967
basis_id = self._fetch_batch(batch, basis_id, cache)
4008
basis_id = self._fetch_batch(batch, basis_id, cache,
4011
self.source._safe_to_return_from_cache = False
3969
4012
self.target.abort_write_group()
3983
4026
"""See InterRepository.fetch()."""
3984
4027
if fetch_spec is not None:
3985
4028
raise AssertionError("Not implemented yet...")
4029
ui.ui_factory.warn_experimental_format_fetch(self)
3986
4030
if (not self.source.supports_rich_root()
3987
4031
and self.target.supports_rich_root()):
3988
4032
self._converting_to_rich_root = True
3989
4033
self._revision_id_to_root_id = {}
3991
4035
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)
3992
4041
revision_ids = self.target.search_missing_revision_ids(self.source,
3993
4042
revision_id, find_ghosts=find_ghosts).get_keys()
3994
4043
if not revision_ids:
4063
4112
:param to_convert: The disk object to convert.
4064
4113
:param pb: a progress bar to use for progress information.
4115
pb = ui.ui_factory.nested_progress_bar()
4069
4118
# this is only useful with metadir layouts - separated repo content.
4070
4119
# trigger an assertion if not such
4071
4120
repo._format.get_format_string()
4072
4121
self.repo_dir = repo.bzrdir
4073
self.step('Moving repository to repository.backup')
4122
pb.update('Moving repository to repository.backup')
4074
4123
self.repo_dir.transport.move('repository', 'repository.backup')
4075
4124
backup_transport = self.repo_dir.transport.clone('repository.backup')
4076
4125
repo._format.check_conversion_target(self.target_format)
4077
4126
self.source_repo = repo._format.open(self.repo_dir,
4079
4128
_override_transport=backup_transport)
4080
self.step('Creating new repository')
4129
pb.update('Creating new repository')
4081
4130
converted = self.target_format.initialize(self.repo_dir,
4082
4131
self.source_repo.is_shared())
4083
4132
converted.lock_write()
4085
self.step('Copying content')
4134
pb.update('Copying content')
4086
4135
self.source_repo.copy_content_into(converted)
4088
4137
converted.unlock()
4089
self.step('Deleting old repository content')
4138
pb.update('Deleting old repository content')
4090
4139
self.repo_dir.transport.delete_tree('repository.backup')
4091
4140
ui.ui_factory.note('repository converted')
4093
def step(self, message):
4094
"""Update the pb by a step."""
4096
self.pb.update(message, self.count, self.total)
4099
4144
_unescape_map = {
4239
4284
is_resume = False
4241
4286
# locked_insert_stream performs a commit|suspend.
4242
return self._locked_insert_stream(stream, src_format, is_resume)
4287
return self._locked_insert_stream(stream, src_format,
4244
4290
self.target_repo.abort_write_group(suppress_errors=True)
4292
4338
# required if the serializers are different only in terms of
4293
4339
# the inventory.
4294
4340
if src_serializer == to_serializer:
4295
self.target_repo.revisions.insert_record_stream(
4341
self.target_repo.revisions.insert_record_stream(substream)
4298
4343
self._extract_and_insert_revisions(substream,
4299
4344
src_serializer)
4407
4452
"""Create a StreamSource streaming from from_repository."""
4408
4453
self.from_repository = from_repository
4409
4454
self.to_format = to_format
4455
self._record_counter = RecordCounter()
4411
4457
def delta_on_metadata(self):
4412
4458
"""Return True if delta's are permitted on metadata streams.
4443
4489
fetching the inventory weave.
4445
4491
if self._rich_root_upgrade():
4447
return bzrlib.fetch.Inter1and2Helper(
4492
return _mod_fetch.Inter1and2Helper(
4448
4493
self.from_repository).generate_root_texts(revs)
4593
4638
def _get_convertable_inventory_stream(self, revision_ids,
4594
4639
delta_versus_null=False):
4595
# The source is using CHKs, but the target either doesn't or it has a
4596
# different serializer. The StreamSink code expects to be able to
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
4597
4644
# convert on the target, so we need to put bytes-on-the-wire that can
4598
4645
# be converted. That means inventory deltas (if the remote is <1.19,
4599
4646
# RemoteStreamSink will fallback to VFS to insert the deltas).
added
removed
bzrlib/repository.py
