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
59
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.decorators import needs_read_lock, needs_write_lock
60
53
from bzrlib.inter import InterObject
61
54
from bzrlib.inventory import (
67
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
60
from bzrlib import registry
68
61
from bzrlib.trace import (
69
62
log_exception_quietly, note, mutter, mutter_callsite, warning)
73
66
_deprecation_warning_done = False
76
class IsInWriteGroupError(errors.InternalBzrError):
78
_fmt = "May not refresh_data of repo %(repo)s while in a write group."
80
def __init__(self, repo):
81
errors.InternalBzrError.__init__(self, repo=repo)
84
69
class CommitBuilder(object):
85
70
"""Provides an interface to build up a commit.
220
205
# an inventory delta was accumulated without creating a new
222
207
basis_id = self.basis_delta_revision
223
# We ignore the 'inventory' returned by add_inventory_by_delta
224
# because self.new_inventory is used to hint to the rest of the
225
# system what code path was taken
226
self.inv_sha1, _ = self.repository.add_inventory_by_delta(
208
self.inv_sha1 = self.repository.add_inventory_by_delta(
227
209
basis_id, self._basis_delta, self._new_revision_id,
483
465
if content_summary[2] is None:
484
466
raise ValueError("Files must not have executable = None")
486
# We can't trust a check of the file length because of content
488
if (# if the exec bit has changed we have to store:
468
if (# if the file length changed we have to store:
469
parent_entry.text_size != content_summary[1] or
470
# if the exec bit has changed we have to store:
489
471
parent_entry.executable != content_summary[2]):
491
473
elif parent_entry.text_sha1 == content_summary[3]:
558
540
ie.revision = parent_entry.revision
559
541
return self._get_delta(ie, basis_inv, path), False, None
560
542
ie.reference_revision = content_summary[3]
561
if ie.reference_revision is None:
562
raise AssertionError("invalid content_summary for nested tree: %r"
563
% (content_summary,))
564
543
self._add_text_to_weave(ie.file_id, '', heads, None)
566
545
raise NotImplementedError('unknown kind')
829
808
self.new_inventory = None
830
809
if len(inv_delta):
831
# This should perhaps be guarded by a check that the basis we
832
# commit against is the basis for the commit and if not do a delta
834
810
self._any_changes = True
835
811
if not seen_root:
836
812
# housekeeping root entry changes do not affect no-change commits.
870
846
# 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
849
######################################################################
894
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
853
class Repository(object):
895
854
"""Repository holding history for one or more branches.
897
856
The repository holds and retrieves historical information including
1056
1015
:seealso: add_inventory, for the contract.
1058
inv_lines = self._serializer.write_inventory_to_lines(inv)
1017
inv_lines = self._serialise_inventory_to_lines(inv)
1059
1018
return self._inventory_add_lines(revision_id, parents,
1060
1019
inv_lines, check_content=False)
1257
1216
for record in getattr(self, kind).check(keys=keys[kind]):
1258
1217
if record.storage_kind == 'absent':
1259
1218
checker._report_items.append(
1260
'Missing %s {%s}' % (kind, record.key,))
1219
'Missing inventory {%s}' % (record.key,))
1262
1221
last_object = self._check_record(kind, record,
1263
1222
checker, last_object, current_keys[(kind,) + record.key])
1268
1227
"""Check a single text from this repository."""
1269
1228
if kind == 'inventories':
1270
1229
rev_id = record.key[0]
1271
inv = self._deserialise_inventory(rev_id,
1230
inv = self.deserialise_inventory(rev_id,
1272
1231
record.get_bytes_as('fulltext'))
1273
1232
if last_object is not None:
1274
1233
delta = inv._make_delta(last_object)
1319
1278
:param _format: The format of the repository on disk.
1320
1279
:param a_bzrdir: The BzrDir of the repository.
1281
In the future we will have a single api for all stores for
1282
getting file texts, inventories and revisions, then
1283
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
1285
super(Repository, self).__init__()
1326
1286
self._format = _format
1327
1287
# the following are part of the public API for Repository:
1333
1293
self._reconcile_does_inventory_gc = True
1334
1294
self._reconcile_fixes_text_parents = False
1335
1295
self._reconcile_backsup_inventory = True
1296
# not right yet - should be more semantically clear ?
1298
# TODO: make sure to construct the right store classes, etc, depending
1299
# on whether escaping is required.
1300
self._warn_if_deprecated()
1336
1301
self._write_group = None
1337
1302
# Additional places to query for data.
1338
1303
self._fallback_repositories = []
1339
1304
# An InventoryEntry cache, used during deserialization
1340
1305
self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
1341
# Is it safe to return inventory entries directly from the entry cache,
1342
# rather copying them?
1343
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
1307
def __repr__(self):
1354
1308
if self._fallback_repositories:
1403
1357
data during reads, and allows a 'write_group' to be obtained. Write
1404
1358
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
1360
:param token: if this is already locked, then lock_write will fail
1413
1361
unless the token matches the existing lock.
1414
1362
:returns: a token if this instance supports tokens, otherwise None.
1417
1365
:raises MismatchedToken: if the specified token doesn't match the token
1418
1366
of the existing lock.
1419
1367
:seealso: start_write_group.
1420
:return: A RepositoryWriteLockResult.
1369
A token should be passed in if you know that you have locked the object
1370
some other way, and need to synchronise this object's state with that
1373
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
1422
1375
locked = self.is_locked()
1423
token = self.control_files.lock_write(token=token)
1376
result = self.control_files.lock_write(token=token)
1425
self._warn_if_deprecated()
1426
self._note_lock('w')
1427
1378
for repo in self._fallback_repositories:
1428
1379
# Writes don't affect fallback repos
1429
1380
repo.lock_read()
1430
1381
self._refresh_data()
1431
return RepositoryWriteLockResult(self.unlock, token)
1433
1384
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
1385
locked = self.is_locked()
1440
1386
self.control_files.lock_read()
1442
self._warn_if_deprecated()
1443
self._note_lock('r')
1444
1388
for repo in self._fallback_repositories:
1445
1389
repo.lock_read()
1446
1390
self._refresh_data()
1447
return LogicalLockResult(self.unlock)
1449
1392
def get_physical_lock_status(self):
1450
1393
return self.control_files.get_physical_lock_status()
1511
1454
# now gather global repository information
1512
1455
# XXX: This is available for many repos regardless of listability.
1513
if self.user_transport.listable():
1456
if self.bzrdir.root_transport.listable():
1514
1457
# XXX: do we want to __define len__() ?
1515
1458
# Maybe the versionedfiles object should provide a different
1516
1459
# method to get the number of keys.
1526
1469
:param using: If True, list only branches using this repository.
1528
1471
if using and not self.is_shared():
1529
return self.bzrdir.list_branches()
1473
return [self.bzrdir.open_branch()]
1474
except errors.NotBranchError:
1530
1476
class Evaluator(object):
1532
1478
def __init__(self):
1541
1487
except errors.NoRepositoryPresent:
1544
return False, ([], repository)
1490
return False, (None, repository)
1545
1491
self.first_call = False
1546
value = (bzrdir.list_branches(), None)
1493
value = (bzrdir.open_branch(), None)
1494
except errors.NotBranchError:
1495
value = (None, None)
1547
1496
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)
1499
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
1500
self.bzrdir.root_transport, evaluate=Evaluator()):
1501
if branch is not None:
1502
branches.append(branch)
1554
1503
if not using and repository is not None:
1555
ret.extend(repository.find_branches())
1504
branches.extend(repository.find_branches())
1558
1507
@needs_read_lock
1559
1508
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1649
1598
# but at the moment we're only checking for texts referenced by
1650
1599
# inventories at the graph's edge.
1651
1600
key_deps = self.revisions._index._key_dependencies
1652
key_deps.satisfy_refs_for_keys(present_inventories)
1601
key_deps.add_keys(present_inventories)
1653
1602
referrers = frozenset(r[0] for r in key_deps.get_referrers())
1654
1603
file_ids = self.fileids_altered_by_revision_ids(referrers)
1655
1604
missing_texts = set()
1668
1617
return missing_keys
1670
1619
def refresh_data(self):
1671
"""Re-read any data needed to synchronise with disk.
1620
"""Re-read any data needed to to synchronise with disk.
1673
1622
This method is intended to be called after another repository instance
1674
1623
(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.
1624
repository. It may not be called during a write group, but may be
1625
called at any other time.
1627
if self.is_in_write_group():
1628
raise errors.InternalBzrError(
1629
"May not refresh_data while in a write group.")
1681
1630
self._refresh_data()
1683
1632
def resume_write_group(self, tokens):
1937
1885
rev = self._serializer.read_revision_from_string(text)
1938
1886
yield (revid, rev)
1889
def get_revision_xml(self, revision_id):
1890
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1891
# would have already do it.
1892
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
1893
# TODO: this can't just be replaced by:
1894
# return self._serializer.write_revision_to_string(
1895
# self.get_revision(revision_id))
1896
# as cStringIO preservers the encoding unlike write_revision_to_string
1897
# or some other call down the path.
1898
rev = self.get_revision(revision_id)
1899
rev_tmp = cStringIO.StringIO()
1900
# the current serializer..
1901
self._serializer.write_revision(rev, rev_tmp)
1903
return rev_tmp.getvalue()
1940
1905
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1941
1906
"""Produce a generator of revision deltas.
2185
2150
selected_keys = set((revid,) for revid in revision_ids)
2186
2151
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),
2152
pb = ui.ui_factory.nested_progress_bar()
2154
return self._find_file_ids_from_xml_inventory_lines(
2155
w.iter_lines_added_or_present_in_keys(
2156
selected_keys, pb=pb),
2192
2161
def iter_files_bytes(self, desired_files):
2193
2162
"""Iterate through file versions.
2354
2323
num_file_ids = len(file_ids)
2355
2324
for file_id, altered_versions in file_ids.iteritems():
2356
2325
if pb is not None:
2357
pb.update("Fetch texts", count, num_file_ids)
2326
pb.update("fetch texts", count, num_file_ids)
2359
2328
yield ("file", file_id, altered_versions)
2403
2372
"""single-document based inventory iteration."""
2404
2373
inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2405
2374
for text, revision_id in inv_xmls:
2406
yield self._deserialise_inventory(revision_id, text)
2375
yield self.deserialise_inventory(revision_id, text)
2408
2377
def _iter_inventory_xmls(self, revision_ids, ordering):
2409
2378
if ordering is None:
2441
2410
next_key = None
2444
def _deserialise_inventory(self, revision_id, xml):
2413
def deserialise_inventory(self, revision_id, xml):
2445
2414
"""Transform the xml into an inventory object.
2447
2416
:param revision_id: The expected revision id of the inventory.
2448
2417
:param xml: A serialised inventory.
2450
2419
result = self._serializer.read_inventory_from_string(xml, revision_id,
2451
entry_cache=self._inventory_entry_cache,
2452
return_from_cache=self._safe_to_return_from_cache)
2420
entry_cache=self._inventory_entry_cache)
2453
2421
if result.revision_id != revision_id:
2454
2422
raise AssertionError('revision id mismatch %s != %s' % (
2455
2423
result.revision_id, revision_id))
2426
def serialise_inventory(self, inv):
2427
return self._serializer.write_inventory_to_string(inv)
2429
def _serialise_inventory_to_lines(self, inv):
2430
return self._serializer.write_inventory_to_lines(inv)
2458
2432
def get_serializer_format(self):
2459
2433
return self._serializer.format_num
2461
2435
@needs_read_lock
2462
def _get_inventory_xml(self, revision_id):
2463
"""Get serialized inventory as a string."""
2436
def get_inventory_xml(self, revision_id):
2437
"""Get inventory XML as a file object."""
2464
2438
texts = self._iter_inventory_xmls([revision_id], 'unordered')
2466
2440
text, revision_id = texts.next()
2468
2442
raise errors.HistoryMissing(self, 'inventory', revision_id)
2446
def get_inventory_sha1(self, revision_id):
2447
"""Return the sha1 hash of the inventory entry
2449
return self.get_revision(revision_id).inventory_sha1
2471
2451
def get_rev_id_for_revno(self, revno, known_pair):
2472
2452
"""Return the revision id of a revno, given a later (revno, revid)
2473
2453
pair in the same history.
2525
2505
next_id = parents[0]
2508
def get_revision_inventory(self, revision_id):
2509
"""Return inventory of a past revision."""
2510
# TODO: Unify this with get_inventory()
2511
# bzr 0.0.6 and later imposes the constraint that the inventory_id
2512
# must be the same as its revision, so this is trivial.
2513
if revision_id is None:
2514
# This does not make sense: if there is no revision,
2515
# then it is the current tree inventory surely ?!
2516
# and thus get_root_id() is something that looks at the last
2517
# commit on the branch, and the get_root_id is an inventory check.
2518
raise NotImplementedError
2519
# return Inventory(self.get_root_id())
2521
return self.get_inventory(revision_id)
2527
2523
def is_shared(self):
2528
2524
"""Return True if this repository is flagged as a shared repository."""
2529
2525
raise NotImplementedError(self.is_shared)
2563
2559
return RevisionTree(self, Inventory(root_id=None),
2564
2560
_mod_revision.NULL_REVISION)
2566
inv = self.get_inventory(revision_id)
2562
inv = self.get_revision_inventory(revision_id)
2567
2563
return RevisionTree(self, inv, revision_id)
2569
2565
def revision_trees(self, revision_ids):
2622
2618
keys = tsort.topo_sort(parent_map)
2623
2619
return [None] + list(keys)
2625
def pack(self, hint=None, clean_obsolete_packs=False):
2621
def pack(self, hint=None):
2626
2622
"""Compress the data within the repository.
2628
2624
This operation only makes sense for some repository types. For other
2638
2634
obtained from the result of commit_write_group(). Out of
2639
2635
date hints are simply ignored, because concurrent operations
2640
2636
can obsolete them rapidly.
2642
:param clean_obsolete_packs: Clean obsolete packs immediately after
2646
2639
def get_transaction(self):
2662
2655
for ((revision_id,), parent_keys) in \
2663
2656
self.revisions.get_parent_map(query_keys).iteritems():
2664
2657
if parent_keys:
2665
result[revision_id] = tuple([parent_revid
2666
for (parent_revid,) in parent_keys])
2658
result[revision_id] = tuple(parent_revid
2659
for (parent_revid,) in parent_keys)
2668
2661
result[revision_id] = (_mod_revision.NULL_REVISION,)
2671
2664
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
2667
def get_graph(self, other_repository=None):
2684
2668
"""Return the graph walker for this repository format"""
2685
2669
parents_provider = self._make_parents_provider()
2780
2764
result.check(callback_refs)
2783
def _warn_if_deprecated(self, branch=None):
2767
def _warn_if_deprecated(self):
2784
2768
global _deprecation_warning_done
2785
2769
if _deprecation_warning_done:
2789
conf = config.GlobalConfig()
2791
conf = branch.get_config()
2792
if conf.suppress_warning('format_deprecation'):
2794
warning("Format %s for %s is deprecated -"
2795
" please use 'bzr upgrade' to get better performance"
2796
% (self._format, self.bzrdir.transport.base))
2798
_deprecation_warning_done = True
2771
_deprecation_warning_done = True
2772
warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
2773
% (self._format, self.bzrdir.transport.base))
2800
2775
def supports_rich_root(self):
2801
2776
return self._format.rich_root_data
3084
3059
pack_compresses = False
3085
3060
# Does the repository inventory storage understand references to trees?
3086
3061
supports_tree_reference = None
3087
# Is the format experimental ?
3088
experimental = False
3091
return "%s()" % self.__class__.__name__
3064
return "<%s>" % self.__class__.__name__
3093
3066
def __eq__(self, other):
3094
3067
# format objects are generally stateless
3109
3082
transport = a_bzrdir.get_repository_transport(None)
3110
format_string = transport.get_bytes("format")
3083
format_string = transport.get("format").read()
3111
3084
return format_registry.get(format_string)
3112
3085
except errors.NoSuchFile:
3113
3086
raise errors.NoRepositoryPresent(a_bzrdir)
3213
3186
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
3189
class MetaDirRepositoryFormat(RepositoryFormat):
3226
3190
"""Common base class for the new repositories using the metadir layout."""
3432
3396
:param revision_id: if None all content is copied, if NULL_REVISION no
3433
3397
content is copied.
3398
:param pb: optional progress bar to use for progress reports. If not
3399
provided a default one will be created.
3437
ui.ui_factory.warn_experimental_format_fetch(self)
3438
3402
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
3403
f = RepoFetcher(to_repository=self.target,
3445
3404
from_repository=self.source,
3446
3405
last_revision=revision_id,
3447
3406
fetch_spec=fetch_spec,
3448
find_ghosts=find_ghosts)
3407
pb=pb, find_ghosts=find_ghosts)
3450
3409
def _walk_to_common_revisions(self, revision_ids):
3451
3410
"""Walk out from revision_ids in source to revisions target has.
3620
3579
self.target.texts.insert_record_stream(
3621
3580
self.source.texts.get_record_stream(
3622
3581
self.source.texts.keys(), 'topological', False))
3623
pb.update('Copying inventory', 0, 1)
3582
pb.update('copying inventory', 0, 1)
3624
3583
self.target.inventories.insert_record_stream(
3625
3584
self.source.inventories.get_record_stream(
3626
3585
self.source.inventories.keys(), 'topological', False))
3847
3806
basis_id, delta, current_revision_id, parents_parents)
3848
3807
cache[current_revision_id] = parent_tree
3850
def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
3809
def _fetch_batch(self, revision_ids, basis_id, cache):
3851
3810
"""Fetch across a few revisions.
3853
3812
:param revision_ids: The revisions to copy
3854
3813
:param basis_id: The revision_id of a tree that must be in cache, used
3855
3814
as a basis for delta when no other base is available
3856
3815
:param cache: A cache of RevisionTrees that we can use.
3857
:param a_graph: A Graph object to determine the heads() of the
3858
rich-root data stream.
3859
3816
:return: The revision_id of the last converted tree. The RevisionTree
3860
3817
for it will be in cache
3868
3825
pending_revisions = []
3869
3826
parent_map = self.source.get_parent_map(revision_ids)
3870
3827
self._fetch_parent_invs_for_stacking(parent_map, cache)
3871
self.source._safe_to_return_from_cache = True
3872
3828
for tree in self.source.revision_trees(revision_ids):
3873
3829
# Find a inventory delta for this revision.
3874
3830
# Find text entries that need to be copied, too.
3882
3838
possible_trees.append((basis_id, cache[basis_id]))
3883
3839
basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3884
3840
possible_trees)
3885
revision = self.source.get_revision(current_revision_id)
3886
pending_deltas.append((basis_id, delta,
3887
current_revision_id, revision.parent_ids))
3888
3841
if self._converting_to_rich_root:
3889
3842
self._revision_id_to_root_id[current_revision_id] = \
3890
3843
tree.get_root_id()
3919
3872
if entry.revision == file_revision:
3920
3873
texts_possibly_new_in_tree.remove(file_key)
3921
3874
text_keys.update(texts_possibly_new_in_tree)
3875
revision = self.source.get_revision(current_revision_id)
3876
pending_deltas.append((basis_id, delta,
3877
current_revision_id, revision.parent_ids))
3922
3878
pending_revisions.append(revision)
3923
3879
cache[current_revision_id] = tree
3924
3880
basis_id = current_revision_id
3925
self.source._safe_to_return_from_cache = False
3926
3881
# Copy file texts
3927
3882
from_texts = self.source.texts
3928
3883
to_texts = self.target.texts
3929
3884
if root_keys_to_create:
3930
root_stream = _mod_fetch._new_root_data_stream(
3885
from bzrlib.fetch import _new_root_data_stream
3886
root_stream = _new_root_data_stream(
3931
3887
root_keys_to_create, self._revision_id_to_root_id, parent_map,
3932
self.source, graph=a_graph)
3933
3889
to_texts.insert_record_stream(root_stream)
3934
3890
to_texts.insert_record_stream(from_texts.get_record_stream(
3935
3891
text_keys, self.target._format._fetch_order,
3992
3948
cache[basis_id] = basis_tree
3993
3949
del basis_tree # We don't want to hang on to it here
3995
if self._converting_to_rich_root and len(revision_ids) > 100:
3996
a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
4001
3951
for offset in range(0, len(revision_ids), batch_size):
4002
3952
self.target.start_write_group()
4004
3954
pb.update('Transferring revisions', offset,
4005
3955
len(revision_ids))
4006
3956
batch = revision_ids[offset:offset+batch_size]
4007
basis_id = self._fetch_batch(batch, basis_id, cache,
3957
basis_id = self._fetch_batch(batch, basis_id, cache)
4010
self.source._safe_to_return_from_cache = False
4011
3959
self.target.abort_write_group()
4025
3973
"""See InterRepository.fetch()."""
4026
3974
if fetch_spec is not None:
4027
3975
raise AssertionError("Not implemented yet...")
4028
ui.ui_factory.warn_experimental_format_fetch(self)
4029
3976
if (not self.source.supports_rich_root()
4030
3977
and self.target.supports_rich_root()):
4031
3978
self._converting_to_rich_root = True
4032
3979
self._revision_id_to_root_id = {}
4034
3981
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
3982
revision_ids = self.target.search_missing_revision_ids(self.source,
4041
3983
revision_id, find_ghosts=find_ghosts).get_keys()
4042
3984
if not revision_ids:
4111
4053
:param to_convert: The disk object to convert.
4112
4054
:param pb: a progress bar to use for progress information.
4114
pb = ui.ui_factory.nested_progress_bar()
4117
4059
# this is only useful with metadir layouts - separated repo content.
4118
4060
# trigger an assertion if not such
4119
4061
repo._format.get_format_string()
4120
4062
self.repo_dir = repo.bzrdir
4121
pb.update('Moving repository to repository.backup')
4063
self.step('Moving repository to repository.backup')
4122
4064
self.repo_dir.transport.move('repository', 'repository.backup')
4123
4065
backup_transport = self.repo_dir.transport.clone('repository.backup')
4124
4066
repo._format.check_conversion_target(self.target_format)
4125
4067
self.source_repo = repo._format.open(self.repo_dir,
4127
4069
_override_transport=backup_transport)
4128
pb.update('Creating new repository')
4070
self.step('Creating new repository')
4129
4071
converted = self.target_format.initialize(self.repo_dir,
4130
4072
self.source_repo.is_shared())
4131
4073
converted.lock_write()
4133
pb.update('Copying content')
4075
self.step('Copying content into repository.')
4134
4076
self.source_repo.copy_content_into(converted)
4136
4078
converted.unlock()
4137
pb.update('Deleting old repository content')
4079
self.step('Deleting old repository content.')
4138
4080
self.repo_dir.transport.delete_tree('repository.backup')
4139
ui.ui_factory.note('repository converted')
4081
self.pb.note('repository converted')
4083
def step(self, message):
4084
"""Update the pb by a step."""
4086
self.pb.update(message, self.count, self.total)
4143
4089
_unescape_map = {
4364
4310
if versioned_file is None:
4366
# TODO: key is often going to be a StaticTuple object
4367
# I don't believe we can define a method by which
4368
# (prefix,) + StaticTuple will work, though we could
4369
# define a StaticTuple.sq_concat that would allow you to
4370
# pass in either a tuple or a StaticTuple as the second
4371
# object, so instead we could have:
4372
# StaticTuple(prefix) + key here...
4373
4312
missing_keys.update((prefix,) + key for key in
4374
4313
versioned_file.get_missing_compression_parent_keys())
4375
4314
except NotImplementedError:
4487
4426
fetching the inventory weave.
4489
4428
if self._rich_root_upgrade():
4490
return _mod_fetch.Inter1and2Helper(
4430
return bzrlib.fetch.Inter1and2Helper(
4491
4431
self.from_repository).generate_root_texts(revs)
4636
4576
def _get_convertable_inventory_stream(self, revision_ids,
4637
4577
delta_versus_null=False):
4638
# The two formats are sufficiently different that there is no fast
4639
# path, so we need to send just inventorydeltas, which any
4640
# sufficiently modern client can insert into any repository.
4641
# The StreamSink code expects to be able to
4578
# The source is using CHKs, but the target either doesn't or it has a
4579
# different serializer. The StreamSink code expects to be able to
4642
4580
# convert on the target, so we need to put bytes-on-the-wire that can
4643
4581
# be converted. That means inventory deltas (if the remote is <1.19,
4644
4582
# RemoteStreamSink will fallback to VFS to insert the deltas).
added
removed
bzrlib/repository.py
