« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 2241.1.4
- compare with another revision
- compare with revision 6617
- download diff
- download tarball
- view history from revision 2241.1.4
- Committer: Martin Pool
- Date: 2007-02-06 06:27:24 UTC
- mto: This revision was merged to the branch mainline in revision 2283.
- Revision ID: mbp@sourcefrog.net-20070206062724-a5uo1u27jxsal2t0
Moved old weave-based repository formats into bzrlib.repofmt.weaverepo.
Change help for --format to just say 'see help formats'
RepositoryFormat.register_metadir gains an optional parameter for the
module name containing the repository format, and lazily loads from there.
Disable test_interrepository_get_returns_correct_optimiser, because it
seems too brittle.
Remove InterWeaveRepo, these should now just be upgraded.
Change help for --format to just say 'see help formats'
RepositoryFormat.register_metadir gains an optional parameter for the
module name containing the repository format, and lazily loads from there.
Disable test_interrepository_get_returns_correct_optimiser, because it
seems too brittle.
Remove InterWeaveRepo, these should now just be upgraded.
- files added:
- bzrlib/repofmt/__init__.py
- files modified:
- bzrlib/branch.py
added
removed
bzrlib/repository.py
304
304
305
305
Currently no check is made that the format of this repository and
306
306
the bzrdir format are compatible. FIXME RBC 20060201.
307
308
:return: The newly created destination repository.
307
309
"""
308
310
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
309
311
# use target default format.
310
result = a_bzrdir.create_repository()
311
# FIXME RBC 20060209 split out the repository type to avoid this check ?
312
elif isinstance(a_bzrdir._format,
313
(bzrdir.BzrDirFormat4,
314
bzrdir.BzrDirFormat5,
315
bzrdir.BzrDirFormat6)):
316
result = a_bzrdir.open_repository()
312
dest_repo = a_bzrdir.create_repository()
317
313
else:
318
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
319
self.copy_content_into(result, revision_id, basis)
320
return result
314
# Most control formats need the repository to be specifically
315
# created, but on some old all-in-one formats it's not needed
316
try:
317
dest_repo = self._format.initialize(a_bzrdir, shared=self.is_shared())
318
except errors.UninitializableFormat:
319
dest_repo = a_bzrdir.open_repository()
320
self.copy_content_into(dest_repo, revision_id, basis)
321
return dest_repo
321
322
322
323
@needs_read_lock
323
324
def has_revision(self, revision_id):
779
780
raise errors.NonAsciiRevisionId(method, self)
780
781
781
782
782
class AllInOneRepository(Repository):
783
"""Legacy support - the repository behaviour for all-in-one branches."""
784
785
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
786
# we reuse one control files instance.
787
dir_mode = a_bzrdir._control_files._dir_mode
788
file_mode = a_bzrdir._control_files._file_mode
789
790
def get_store(name, compressed=True, prefixed=False):
791
# FIXME: This approach of assuming stores are all entirely compressed
792
# or entirely uncompressed is tidy, but breaks upgrade from
793
# some existing branches where there's a mixture; we probably
794
# still want the option to look for both.
795
relpath = a_bzrdir._control_files._escape(name)
796
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
797
prefixed=prefixed, compressed=compressed,
798
dir_mode=dir_mode,
799
file_mode=file_mode)
800
#if self._transport.should_cache():
801
# cache_path = os.path.join(self.cache_root, name)
802
# os.mkdir(cache_path)
803
# store = bzrlib.store.CachedStore(store, cache_path)
804
return store
805
806
# not broken out yet because the controlweaves|inventory_store
807
# and text_store | weave_store bits are still different.
808
if isinstance(_format, RepositoryFormat4):
809
# cannot remove these - there is still no consistent api
810
# which allows access to this old info.
811
self.inventory_store = get_store('inventory-store')
812
text_store = get_store('text-store')
813
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
814
815
def get_commit_builder(self, branch, parents, config, timestamp=None,
816
timezone=None, committer=None, revprops=None,
817
revision_id=None):
818
self._check_ascii_revisionid(revision_id, self.get_commit_builder)
819
return Repository.get_commit_builder(self, branch, parents, config,
820
timestamp, timezone, committer, revprops, revision_id)
821
822
@needs_read_lock
823
def is_shared(self):
824
"""AllInOne repositories cannot be shared."""
825
return False
826
827
@needs_write_lock
828
def set_make_working_trees(self, new_value):
829
"""Set the policy flag for making working trees when creating branches.
830
831
This only applies to branches that use this repository.
832
833
The default is 'True'.
834
:param new_value: True to restore the default, False to disable making
835
working trees.
836
"""
837
raise NotImplementedError(self.set_make_working_trees)
838
839
def make_working_trees(self):
840
"""Returns the policy for making working trees on new branches."""
841
return True
842
843
844
783
def install_revision(repository, rev, revision_tree):
845
784
"""Install all revision data into a repository."""
846
785
present_parents = []
930
869
return not self.control_files._transport.has('no-working-trees')
931
870
932
871
933
class WeaveMetaDirRepository(MetaDirRepository):
934
"""A subclass of MetaDirRepository to set weave specific policy."""
935
936
def get_commit_builder(self, branch, parents, config, timestamp=None,
937
timezone=None, committer=None, revprops=None,
938
revision_id=None):
939
self._check_ascii_revisionid(revision_id, self.get_commit_builder)
940
return MetaDirRepository.get_commit_builder(self, branch, parents,
941
config, timestamp, timezone, committer, revprops, revision_id)
942
943
944
872
class KnitRepository(MetaDirRepository):
945
873
"""Knit format repository."""
946
874
1306
1234
raise NotImplementedError(self.open)
1307
1235
1308
1236
1309
class PreSplitOutRepositoryFormat(RepositoryFormat):
1310
"""Base class for the pre split out repository formats."""
1311
1312
rich_root_data = False
1313
1314
def initialize(self, a_bzrdir, shared=False, _internal=False):
1315
"""Create a weave repository.
1316
1317
TODO: when creating split out bzr branch formats, move this to a common
1318
base for Format5, Format6. or something like that.
1319
"""
1320
if shared:
1321
raise errors.IncompatibleFormat(self, a_bzrdir._format)
1322
1323
if not _internal:
1324
# always initialized when the bzrdir is.
1325
return self.open(a_bzrdir, _found=True)
1326
1327
# Create an empty weave
1328
sio = StringIO()
1329
weavefile.write_weave_v5(weave.Weave(), sio)
1330
empty_weave = sio.getvalue()
1331
1332
mutter('creating repository in %s.', a_bzrdir.transport.base)
1333
dirs = ['revision-store', 'weaves']
1334
files = [('inventory.weave', StringIO(empty_weave)),
1335
]
1336
1337
# FIXME: RBC 20060125 don't peek under the covers
1338
# NB: no need to escape relative paths that are url safe.
1339
control_files = lockable_files.LockableFiles(a_bzrdir.transport,
1340
'branch-lock', lockable_files.TransportLock)
1341
control_files.create_lock()
1342
control_files.lock_write()
1343
control_files._transport.mkdir_multi(dirs,
1344
mode=control_files._dir_mode)
1345
try:
1346
for file, content in files:
1347
control_files.put(file, content)
1348
finally:
1349
control_files.unlock()
1350
return self.open(a_bzrdir, _found=True)
1351
1352
def _get_control_store(self, repo_transport, control_files):
1353
"""Return the control store for this repository."""
1354
return self._get_versioned_file_store('',
1355
repo_transport,
1356
control_files,
1357
prefixed=False)
1358
1359
def _get_text_store(self, transport, control_files):
1360
"""Get a store for file texts for this format."""
1361
raise NotImplementedError(self._get_text_store)
1362
1363
def open(self, a_bzrdir, _found=False):
1364
"""See RepositoryFormat.open()."""
1365
if not _found:
1366
# we are being called directly and must probe.
1367
raise NotImplementedError
1368
1369
repo_transport = a_bzrdir.get_repository_transport(None)
1370
control_files = a_bzrdir._control_files
1371
text_store = self._get_text_store(repo_transport, control_files)
1372
control_store = self._get_control_store(repo_transport, control_files)
1373
_revision_store = self._get_revision_store(repo_transport, control_files)
1374
return AllInOneRepository(_format=self,
1375
a_bzrdir=a_bzrdir,
1376
_revision_store=_revision_store,
1377
control_store=control_store,
1378
text_store=text_store)
1379
1380
def check_conversion_target(self, target_format):
1381
pass
1382
1383
1384
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1385
"""Bzr repository format 4.
1386
1387
This repository format has:
1388
- flat stores
1389
- TextStores for texts, inventories,revisions.
1390
1391
This format is deprecated: it indexes texts using a text id which is
1392
removed in format 5; initialization and write support for this format
1393
has been removed.
1394
"""
1395
1396
def __init__(self):
1397
super(RepositoryFormat4, self).__init__()
1398
self._matchingbzrdir = bzrdir.BzrDirFormat4()
1399
1400
def get_format_description(self):
1401
"""See RepositoryFormat.get_format_description()."""
1402
return "Repository format 4"
1403
1404
def initialize(self, url, shared=False, _internal=False):
1405
"""Format 4 branches cannot be created."""
1406
raise errors.UninitializableFormat(self)
1407
1408
def is_supported(self):
1409
"""Format 4 is not supported.
1410
1411
It is not supported because the model changed from 4 to 5 and the
1412
conversion logic is expensive - so doing it on the fly was not
1413
feasible.
1414
"""
1415
return False
1416
1417
def _get_control_store(self, repo_transport, control_files):
1418
"""Format 4 repositories have no formal control store at this point.
1419
1420
This will cause any control-file-needing apis to fail - this is desired.
1421
"""
1422
return None
1423
1424
def _get_revision_store(self, repo_transport, control_files):
1425
"""See RepositoryFormat._get_revision_store()."""
1426
from bzrlib.xml4 import serializer_v4
1427
return self._get_text_rev_store(repo_transport,
1428
control_files,
1429
'revision-store',
1430
serializer=serializer_v4)
1431
1432
def _get_text_store(self, transport, control_files):
1433
"""See RepositoryFormat._get_text_store()."""
1434
1435
1436
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1437
"""Bzr control format 5.
1438
1439
This repository format has:
1440
- weaves for file texts and inventory
1441
- flat stores
1442
- TextStores for revisions and signatures.
1443
"""
1444
1445
def __init__(self):
1446
super(RepositoryFormat5, self).__init__()
1447
self._matchingbzrdir = bzrdir.BzrDirFormat5()
1448
1449
def get_format_description(self):
1450
"""See RepositoryFormat.get_format_description()."""
1451
return "Weave repository format 5"
1452
1453
def _get_revision_store(self, repo_transport, control_files):
1454
"""See RepositoryFormat._get_revision_store()."""
1455
"""Return the revision store object for this a_bzrdir."""
1456
return self._get_text_rev_store(repo_transport,
1457
control_files,
1458
'revision-store',
1459
compressed=False)
1460
1461
def _get_text_store(self, transport, control_files):
1462
"""See RepositoryFormat._get_text_store()."""
1463
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1464
1465
1466
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1467
"""Bzr control format 6.
1468
1469
This repository format has:
1470
- weaves for file texts and inventory
1471
- hash subdirectory based stores.
1472
- TextStores for revisions and signatures.
1473
"""
1474
1475
def __init__(self):
1476
super(RepositoryFormat6, self).__init__()
1477
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1478
1479
def get_format_description(self):
1480
"""See RepositoryFormat.get_format_description()."""
1481
return "Weave repository format 6"
1482
1483
def _get_revision_store(self, repo_transport, control_files):
1484
"""See RepositoryFormat._get_revision_store()."""
1485
return self._get_text_rev_store(repo_transport,
1486
control_files,
1487
'revision-store',
1488
compressed=False,
1489
prefixed=True)
1490
1491
def _get_text_store(self, transport, control_files):
1492
"""See RepositoryFormat._get_text_store()."""
1493
return self._get_versioned_file_store('weaves', transport, control_files)
1494
1495
1496
1237
class MetaDirRepositoryFormat(RepositoryFormat):
1497
1238
"""Common base class for the new repositories using the metadir layout."""
1498
1239
1529
1270
control_files.unlock()
1530
1271
1531
1272
1532
class RepositoryFormat7(MetaDirRepositoryFormat):
1533
"""Bzr repository 7.
1534
1535
This repository format has:
1536
- weaves for file texts and inventory
1537
- hash subdirectory based stores.
1538
- TextStores for revisions and signatures.
1539
- a format marker of its own
1540
- an optional 'shared-storage' flag
1541
- an optional 'no-working-trees' flag
1542
"""
1543
1544
def _get_control_store(self, repo_transport, control_files):
1545
"""Return the control store for this repository."""
1546
return self._get_versioned_file_store('',
1547
repo_transport,
1548
control_files,
1549
prefixed=False)
1550
1551
def get_format_string(self):
1552
"""See RepositoryFormat.get_format_string()."""
1553
return "Bazaar-NG Repository format 7"
1554
1555
def get_format_description(self):
1556
"""See RepositoryFormat.get_format_description()."""
1557
return "Weave repository format 7"
1558
1559
def check_conversion_target(self, target_format):
1560
pass
1561
1562
def _get_revision_store(self, repo_transport, control_files):
1563
"""See RepositoryFormat._get_revision_store()."""
1564
return self._get_text_rev_store(repo_transport,
1565
control_files,
1566
'revision-store',
1567
compressed=False,
1568
prefixed=True,
1569
)
1570
1571
def _get_text_store(self, transport, control_files):
1572
"""See RepositoryFormat._get_text_store()."""
1573
return self._get_versioned_file_store('weaves',
1574
transport,
1575
control_files)
1576
1577
def initialize(self, a_bzrdir, shared=False):
1578
"""Create a weave repository.
1579
1580
:param shared: If true the repository will be initialized as a shared
1581
repository.
1582
"""
1583
# Create an empty weave
1584
sio = StringIO()
1585
weavefile.write_weave_v5(weave.Weave(), sio)
1586
empty_weave = sio.getvalue()
1587
1588
mutter('creating repository in %s.', a_bzrdir.transport.base)
1589
dirs = ['revision-store', 'weaves']
1590
files = [('inventory.weave', StringIO(empty_weave)),
1591
]
1592
utf8_files = [('format', self.get_format_string())]
1593
1594
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1595
return self.open(a_bzrdir=a_bzrdir, _found=True)
1596
1597
def open(self, a_bzrdir, _found=False, _override_transport=None):
1598
"""See RepositoryFormat.open().
1599
1600
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1601
repository at a slightly different url
1602
than normal. I.e. during 'upgrade'.
1603
"""
1604
if not _found:
1605
format = RepositoryFormat.find_format(a_bzrdir)
1606
assert format.__class__ == self.__class__
1607
if _override_transport is not None:
1608
repo_transport = _override_transport
1609
else:
1610
repo_transport = a_bzrdir.get_repository_transport(None)
1611
control_files = lockable_files.LockableFiles(repo_transport,
1612
'lock', lockdir.LockDir)
1613
text_store = self._get_text_store(repo_transport, control_files)
1614
control_store = self._get_control_store(repo_transport, control_files)
1615
_revision_store = self._get_revision_store(repo_transport, control_files)
1616
return WeaveMetaDirRepository(_format=self,
1617
a_bzrdir=a_bzrdir,
1618
control_files=control_files,
1619
_revision_store=_revision_store,
1620
control_store=control_store,
1621
text_store=text_store)
1622
1623
1624
1273
class RepositoryFormatKnit(MetaDirRepositoryFormat):
1625
1274
"""Bzr repository knit format (generalized).
1626
1275
1815
1464
text_store=text_store)
1816
1465
1817
1466
1818
1819
1467
# formats which have no format string are not discoverable
1820
# and not independently creatable, so are not registered.
1821
RepositoryFormat.register_format(RepositoryFormat7())
1468
# and not independently creatable, so are not registered. They're
1469
# all in bzrlib.repofmt.weaverepo now.
1470
format_registry.register_lazy(
1471
'Bazaar-NG Repository format 7',
1472
'bzrlib.repofmt.weaverepo',
1473
'RepositoryFormat7_instance'
1474
)
1822
1475
# KEEP in sync with bzrdir.format_registry default, which controls the overall
1823
1476
# default control directory format
1824
1477
_default_format = RepositoryFormatKnit1()
1825
1478
RepositoryFormat.register_format(_default_format)
1826
1479
RepositoryFormat.register_format(RepositoryFormatKnit2())
1827
1480
RepositoryFormat._set_default_format(_default_format)
1828
_legacy_formats = [RepositoryFormat4(),
1829
RepositoryFormat5(),
1830
RepositoryFormat6()]
1831
1481
1832
1482
1833
1483
class InterRepository(InterObject):
1893
1543
Data format and model must match for this to work.
1894
1544
"""
1895
1545
1896
_matching_repo_format = RepositoryFormat4()
1546
_matching_repo_format = _default_format
1897
1547
"""Repository format for testing with."""
1898
1548
1899
1549
@staticmethod
1945
1595
return f.count_copied, f.failed_revisions
1946
1596
1947
1597
1948
class InterWeaveRepo(InterSameDataRepository):
1949
"""Optimised code paths between Weave based repositories."""
1950
1951
_matching_repo_format = RepositoryFormat7()
1952
"""Repository format for testing with."""
1953
1954
@staticmethod
1955
def is_compatible(source, target):
1956
"""Be compatible with known Weave formats.
1957
1958
We don't test for the stores being of specific types because that
1959
could lead to confusing results, and there is no need to be
1960
overly general.
1961
"""
1962
try:
1963
return (isinstance(source._format, (RepositoryFormat5,
1964
RepositoryFormat6,
1965
RepositoryFormat7)) and
1966
isinstance(target._format, (RepositoryFormat5,
1967
RepositoryFormat6,
1968
RepositoryFormat7)))
1969
except AttributeError:
1970
return False
1971
1972
@needs_write_lock
1973
def copy_content(self, revision_id=None, basis=None):
1974
"""See InterRepository.copy_content()."""
1975
# weave specific optimised path:
1976
if basis is not None:
1977
# copy the basis in, then fetch remaining data.
1978
basis.copy_content_into(self.target, revision_id)
1979
# the basis copy_content_into could miss-set this.
1980
try:
1981
self.target.set_make_working_trees(self.source.make_working_trees())
1982
except NotImplementedError:
1983
pass
1984
self.target.fetch(self.source, revision_id=revision_id)
1985
else:
1986
try:
1987
self.target.set_make_working_trees(self.source.make_working_trees())
1988
except NotImplementedError:
1989
pass
1990
# FIXME do not peek!
1991
if self.source.control_files._transport.listable():
1992
pb = ui.ui_factory.nested_progress_bar()
1993
try:
1994
self.target.weave_store.copy_all_ids(
1995
self.source.weave_store,
1996
pb=pb,
1997
from_transaction=self.source.get_transaction(),
1998
to_transaction=self.target.get_transaction())
1999
pb.update('copying inventory', 0, 1)
2000
self.target.control_weaves.copy_multi(
2001
self.source.control_weaves, ['inventory'],
2002
from_transaction=self.source.get_transaction(),
2003
to_transaction=self.target.get_transaction())
2004
self.target._revision_store.text_store.copy_all_ids(
2005
self.source._revision_store.text_store,
2006
pb=pb)
2007
finally:
2008
pb.finished()
2009
else:
2010
self.target.fetch(self.source, revision_id=revision_id)
2011
2012
@needs_write_lock
2013
def fetch(self, revision_id=None, pb=None):
2014
"""See InterRepository.fetch()."""
2015
from bzrlib.fetch import GenericRepoFetcher
2016
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2017
self.source, self.source._format, self.target, self.target._format)
2018
f = GenericRepoFetcher(to_repository=self.target,
2019
from_repository=self.source,
2020
last_revision=revision_id,
2021
pb=pb)
2022
return f.count_copied, f.failed_revisions
2023
2024
@needs_read_lock
2025
def missing_revision_ids(self, revision_id=None):
2026
"""See InterRepository.missing_revision_ids()."""
2027
# we want all revisions to satisfy revision_id in source.
2028
# but we don't want to stat every file here and there.
2029
# we want then, all revisions other needs to satisfy revision_id
2030
# checked, but not those that we have locally.
2031
# so the first thing is to get a subset of the revisions to
2032
# satisfy revision_id in source, and then eliminate those that
2033
# we do already have.
2034
# this is slow on high latency connection to self, but as as this
2035
# disk format scales terribly for push anyway due to rewriting
2036
# inventory.weave, this is considered acceptable.
2037
# - RBC 20060209
2038
if revision_id is not None:
2039
source_ids = self.source.get_ancestry(revision_id)
2040
assert source_ids[0] is None
2041
source_ids.pop(0)
2042
else:
2043
source_ids = self.source._all_possible_ids()
2044
source_ids_set = set(source_ids)
2045
# source_ids is the worst possible case we may need to pull.
2046
# now we want to filter source_ids against what we actually
2047
# have in target, but don't try to check for existence where we know
2048
# we do not have a revision as that would be pointless.
2049
target_ids = set(self.target._all_possible_ids())
2050
possibly_present_revisions = target_ids.intersection(source_ids_set)
2051
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2052
required_revisions = source_ids_set.difference(actually_present_revisions)
2053
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
2054
if revision_id is not None:
2055
# we used get_ancestry to determine source_ids then we are assured all
2056
# revisions referenced are present as they are installed in topological order.
2057
# and the tip revision was validated by get_ancestry.
2058
return required_topo_revisions
2059
else:
2060
# if we just grabbed the possibly available ids, then
2061
# we only have an estimate of whats available and need to validate
2062
# that against the revision records.
2063
return self.source._eliminate_revisions_not_present(required_topo_revisions)
2064
2065
2066
1598
class InterKnitRepo(InterSameDataRepository):
2067
1599
"""Optimised code paths between Knit based repositories."""
2068
1600
2204
1736
2205
1737
2206
1738
InterRepository.register_optimiser(InterSameDataRepository)
2207
InterRepository.register_optimiser(InterWeaveRepo)
2208
1739
InterRepository.register_optimiser(InterKnitRepo)
2209
1740
InterRepository.register_optimiser(InterModel1and2)
2210
1741
InterRepository.register_optimiser(InterKnit1and2)
2273
1804
@staticmethod
2274
1805
def default_test_list():
2275
1806
"""Generate the default list of interrepo permutations to test."""
1807
from bzrlib.repofmt import weaverepo
2276
1808
result = []
2277
1809
# test the default InterRepository between format 6 and the current
2278
1810
# default format.
2289
1821
))
2290
1822
# if there are specific combinations we want to use, we can add them
2291
1823
# here.
2292
result.append((InterModel1and2, RepositoryFormat5(),
1824
result.append((InterModel1and2,
1825
weaverepo.RepositoryFormat5(),
2293
1826
RepositoryFormatKnit2()))
2294
1827
result.append((InterKnit1and2, RepositoryFormatKnit1(),
2295
1828
RepositoryFormatKnit2()))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1