1
# Copyright (C) 2007-2010 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2007, 2008 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
55
54
revision as _mod_revision,
58
from bzrlib.decorators import needs_write_lock, only_raises
57
from bzrlib.decorators import needs_write_lock
59
58
from bzrlib.btree_index import (
226
224
return self.index_name('text', name)
228
226
def _replace_index_with_readonly(self, index_type):
229
unlimited_cache = False
230
if index_type == 'chk':
231
unlimited_cache = True
232
227
setattr(self, index_type + '_index',
233
228
self.index_class(self.index_transport,
234
229
self.index_name(index_type, self.name),
235
self.index_sizes[self.index_offset(index_type)],
236
unlimited_cache=unlimited_cache))
230
self.index_sizes[self.index_offset(index_type)]))
239
233
class ExistingPack(Pack):
456
448
self.signature_index.key_count() or
457
449
(self.chk_index is not None and self.chk_index.key_count()))
459
def finish_content(self):
460
if self.name is not None:
464
self._write_data('', flush=True)
465
self.name = self._hash.hexdigest()
467
451
def finish(self, suspend=False):
468
452
"""Finish the new pack.
587
574
flush_func=flush_func)
588
575
self.add_callback = None
577
def replace_indices(self, index_to_pack, indices):
578
"""Replace the current mappings with fresh ones.
580
This should probably not be used eventually, rather incremental add and
581
removal of indices. It has been added during refactoring of existing
584
:param index_to_pack: A mapping from index objects to
585
(transport, name) tuples for the pack file data.
586
:param indices: A list of indices.
588
# refresh the revision pack map dict without replacing the instance.
589
self.index_to_pack.clear()
590
self.index_to_pack.update(index_to_pack)
591
# XXX: API break - clearly a 'replace' method would be good?
592
self.combined_index._indices[:] = indices
593
# the current add nodes callback for the current writable index if
595
self.add_callback = None
590
597
def add_index(self, index, pack):
591
598
"""Add index to the aggregate, which is an index for Pack pack.
599
606
# expose it to the index map
600
607
self.index_to_pack[index] = pack.access_tuple()
601
608
# put it at the front of the linear index list
602
self.combined_index.insert_index(0, index, pack.name)
609
self.combined_index.insert_index(0, index)
604
611
def add_writable_index(self, index, pack):
605
612
"""Add an index which is able to have data added to it.
625
632
self.data_access.set_writer(None, None, (None, None))
626
633
self.index_to_pack.clear()
627
634
del self.combined_index._indices[:]
628
del self.combined_index._index_names[:]
629
635
self.add_callback = None
631
def remove_index(self, index):
637
def remove_index(self, index, pack):
632
638
"""Remove index from the indices used to answer queries.
634
640
:param index: An index from the pack parameter.
641
:param pack: A Pack instance.
636
643
del self.index_to_pack[index]
637
pos = self.combined_index._indices.index(index)
638
del self.combined_index._indices[pos]
639
del self.combined_index._index_names[pos]
644
self.combined_index._indices.remove(index)
640
645
if (self.add_callback is not None and
641
646
getattr(index, 'add_nodes', None) == self.add_callback):
642
647
self.add_callback = None
1100
1105
iterator is a tuple with:
1101
1106
index, readv_vector, node_vector. readv_vector is a list ready to
1102
1107
hand to the transport readv method, and node_vector is a list of
1103
(key, eol_flag, references) for the node retrieved by the
1108
(key, eol_flag, references) for the the node retrieved by the
1104
1109
matching readv_vector.
1106
1111
# group by pack so we do one readv per pack
1398
1403
self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1399
1404
self.text_index = AggregateIndex(self.reload_pack_names, flush)
1400
1405
self.signature_index = AggregateIndex(self.reload_pack_names, flush)
1401
all_indices = [self.revision_index, self.inventory_index,
1402
self.text_index, self.signature_index]
1403
1406
if use_chk_index:
1404
1407
self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1405
all_indices.append(self.chk_index)
1407
1409
# used to determine if we're using a chk_index elsewhere.
1408
1410
self.chk_index = None
1409
# Tell all the CombinedGraphIndex objects about each other, so they can
1410
# share hints about which pack names to search first.
1411
all_combined = [agg_idx.combined_index for agg_idx in all_indices]
1412
for combined_idx in all_combined:
1413
combined_idx.set_sibling_indices(
1414
set(all_combined).difference([combined_idx]))
1415
1411
# resumed packs
1416
1412
self._resumed_packs = []
1419
return '%s(%r)' % (self.__class__.__name__, self.repo)
1421
1414
def add_pack_to_memory(self, pack):
1422
1415
"""Make a Pack object available to the repository to satisfy queries.
1537
1530
self._remove_pack_from_memory(pack)
1538
1531
# record the newly available packs and stop advertising the old
1540
to_be_obsoleted = []
1541
for _, packs in pack_operations:
1542
to_be_obsoleted.extend(packs)
1543
result = self._save_pack_names(clear_obsolete_packs=True,
1544
obsolete_packs=to_be_obsoleted)
1533
result = self._save_pack_names(clear_obsolete_packs=True)
1534
# Move the old packs out of the way now they are no longer referenced.
1535
for revision_count, packs in pack_operations:
1536
self._obsolete_packs(packs)
1547
1539
def _flush_new_pack(self):
1560
1552
"""Is the collection already packed?"""
1561
1553
return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1563
def pack(self, hint=None, clean_obsolete_packs=False):
1555
def pack(self, hint=None):
1564
1556
"""Pack the pack collection totally."""
1565
1557
self.ensure_loaded()
1566
1558
total_packs = len(self._names)
1575
1567
# determine which packs need changing
1576
1568
pack_operations = [[0, []]]
1577
1569
for pack in self.all_packs():
1578
if hint is None or pack.name in hint:
1579
# Either no hint was provided (so we are packing everything),
1580
# or this pack was included in the hint.
1570
if not hint or pack.name in hint:
1581
1571
pack_operations[-1][0] += pack.get_revision_count()
1582
1572
pack_operations[-1][1].append(pack)
1583
1573
self._execute_pack_operations(pack_operations, OptimisingPacker)
1585
if clean_obsolete_packs:
1586
self._clear_obsolete_packs()
1588
1575
def plan_autopack_combinations(self, existing_packs, pack_distribution):
1589
1576
"""Plan a pack operation.
1678
1665
txt_index = self._make_index(name, '.tix')
1679
1666
sig_index = self._make_index(name, '.six')
1680
1667
if self.chk_index is not None:
1681
chk_index = self._make_index(name, '.cix', unlimited_cache=True)
1668
chk_index = self._make_index(name, '.cix')
1683
1670
chk_index = None
1684
1671
result = ExistingPack(self._pack_transport, name, rev_index,
1703
1690
txt_index = self._make_index(name, '.tix', resume=True)
1704
1691
sig_index = self._make_index(name, '.six', resume=True)
1705
1692
if self.chk_index is not None:
1706
chk_index = self._make_index(name, '.cix', resume=True,
1707
unlimited_cache=True)
1693
chk_index = self._make_index(name, '.cix', resume=True)
1709
1695
chk_index = None
1710
1696
result = self.resumed_pack_factory(name, rev_index, inv_index,
1740
1726
return self._index_class(self.transport, 'pack-names', None
1741
1727
).iter_all_entries()
1743
def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
1729
def _make_index(self, name, suffix, resume=False):
1744
1730
size_offset = self._suffix_offsets[suffix]
1745
1731
index_name = name + suffix
1750
1736
transport = self._index_transport
1751
1737
index_size = self._names[name][size_offset]
1752
return self._index_class(transport, index_name, index_size,
1753
unlimited_cache=unlimited_cache)
1738
return self._index_class(transport, index_name, index_size)
1755
1740
def _max_pack_count(self, total_revisions):
1756
1741
"""Return the maximum number of packs to use for total revisions.
1784
1769
:param return: None.
1786
1771
for pack in packs:
1788
pack.pack_transport.rename(pack.file_name(),
1789
'../obsolete_packs/' + pack.file_name())
1790
except (errors.PathError, errors.TransportError), e:
1791
# TODO: Should these be warnings or mutters?
1792
mutter("couldn't rename obsolete pack, skipping it:\n%s"
1772
pack.pack_transport.rename(pack.file_name(),
1773
'../obsolete_packs/' + pack.file_name())
1794
1774
# TODO: Probably needs to know all possible indices for this pack
1795
1775
# - or maybe list the directory and move all indices matching this
1796
1776
# name whether we recognize it or not?
1798
1778
if self.chk_index is not None:
1799
1779
suffixes.append('.cix')
1800
1780
for suffix in suffixes:
1802
self._index_transport.rename(pack.name + suffix,
1803
'../obsolete_packs/' + pack.name + suffix)
1804
except (errors.PathError, errors.TransportError), e:
1805
mutter("couldn't rename obsolete index, skipping it:\n%s"
1781
self._index_transport.rename(pack.name + suffix,
1782
'../obsolete_packs/' + pack.name + suffix)
1808
1784
def pack_distribution(self, total_revisions):
1809
1785
"""Generate a list of the number of revisions to put in each pack.
1835
1811
self._remove_pack_indices(pack)
1836
1812
self.packs.remove(pack)
1838
def _remove_pack_indices(self, pack, ignore_missing=False):
1839
"""Remove the indices for pack from the aggregated indices.
1841
:param ignore_missing: Suppress KeyErrors from calling remove_index.
1843
for index_type in Pack.index_definitions.keys():
1844
attr_name = index_type + '_index'
1845
aggregate_index = getattr(self, attr_name)
1846
if aggregate_index is not None:
1847
pack_index = getattr(pack, attr_name)
1849
aggregate_index.remove_index(pack_index)
1814
def _remove_pack_indices(self, pack):
1815
"""Remove the indices for pack from the aggregated indices."""
1816
self.revision_index.remove_index(pack.revision_index, pack)
1817
self.inventory_index.remove_index(pack.inventory_index, pack)
1818
self.text_index.remove_index(pack.text_index, pack)
1819
self.signature_index.remove_index(pack.signature_index, pack)
1820
if self.chk_index is not None:
1821
self.chk_index.remove_index(pack.chk_index, pack)
1855
1823
def reset(self):
1856
1824
"""Clear all cached data."""
1889
1857
disk_nodes = set()
1890
1858
for index, key, value in self._iter_disk_pack_index():
1891
1859
disk_nodes.add((key, value))
1892
orig_disk_nodes = set(disk_nodes)
1894
1861
# do a two-way diff against our original content
1895
1862
current_nodes = set()
1908
1875
disk_nodes.difference_update(deleted_nodes)
1909
1876
disk_nodes.update(new_nodes)
1911
return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
1878
return disk_nodes, deleted_nodes, new_nodes
1913
1880
def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1914
1881
"""Given the correct set of pack files, update our saved info.
1954
1921
added.append(name)
1955
1922
return removed, added, modified
1957
def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):
1924
def _save_pack_names(self, clear_obsolete_packs=False):
1958
1925
"""Save the list of packs.
1960
1927
This will take out the mutex around the pack names list for the
1965
1932
:param clear_obsolete_packs: If True, clear out the contents of the
1966
1933
obsolete_packs directory.
1967
:param obsolete_packs: Packs that are obsolete once the new pack-names
1968
file has been written.
1969
1934
:return: A list of the names saved that were not previously on disk.
1971
already_obsolete = []
1972
1936
self.lock_names()
1974
1938
builder = self._index_builder_class()
1975
(disk_nodes, deleted_nodes, new_nodes,
1976
orig_disk_nodes) = self._diff_pack_names()
1939
disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1977
1940
# TODO: handle same-name, index-size-changes here -
1978
1941
# e.g. use the value from disk, not ours, *unless* we're the one
1981
1944
builder.add_node(key, value)
1982
1945
self.transport.put_file('pack-names', builder.finish(),
1983
1946
mode=self.repo.bzrdir._get_file_mode())
1947
# move the baseline forward
1984
1948
self._packs_at_load = disk_nodes
1985
1949
if clear_obsolete_packs:
1988
to_preserve = set([o.name for o in obsolete_packs])
1989
already_obsolete = self._clear_obsolete_packs(to_preserve)
1950
self._clear_obsolete_packs()
1991
1952
self._unlock_names()
1992
1953
# synchronise the memory packs list with what we just wrote:
1993
1954
self._syncronize_pack_names_from_disk_nodes(disk_nodes)
1995
# TODO: We could add one more condition here. "if o.name not in
1996
# orig_disk_nodes and o != the new_pack we haven't written to
1997
# disk yet. However, the new pack object is not easily
1998
# accessible here (it would have to be passed through the
1999
# autopacking code, etc.)
2000
obsolete_packs = [o for o in obsolete_packs
2001
if o.name not in already_obsolete]
2002
self._obsolete_packs(obsolete_packs)
2003
1955
return [new_node[0][0] for new_node in new_nodes]
2005
1957
def reload_pack_names(self):
2022
1974
# out the new value.
2023
(disk_nodes, deleted_nodes, new_nodes,
2024
orig_disk_nodes) = self._diff_pack_names()
2025
# _packs_at_load is meant to be the explicit list of names in
2026
# 'pack-names' at then start. As such, it should not contain any
2027
# pending names that haven't been written out yet.
2028
self._packs_at_load = orig_disk_nodes
1975
disk_nodes, _, _ = self._diff_pack_names()
1976
self._packs_at_load = disk_nodes
2029
1977
(removed, added,
2030
1978
modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2031
1979
if removed or added or modified:
2041
1989
raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2043
def _clear_obsolete_packs(self, preserve=None):
1991
def _clear_obsolete_packs(self):
2044
1992
"""Delete everything from the obsolete-packs directory.
2046
:return: A list of pack identifiers (the filename without '.pack') that
2047
were found in obsolete_packs.
2050
1994
obsolete_pack_transport = self.transport.clone('obsolete_packs')
2051
if preserve is None:
2053
1995
for filename in obsolete_pack_transport.list_dir('.'):
2054
name, ext = osutils.splitext(filename)
2057
if name in preserve:
2060
1997
obsolete_pack_transport.delete(filename)
2061
1998
except (errors.PathError, errors.TransportError), e:
2062
warning("couldn't delete obsolete pack, skipping it:\n%s"
1999
warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2066
2001
def _start_write_group(self):
2067
2002
# Do not permit preparation for writing if we're not in a 'write lock'.
2094
2029
# FIXME: just drop the transient index.
2095
2030
# forget what names there are
2096
2031
if self._new_pack is not None:
2097
operation = cleanup.OperationWithCleanups(self._new_pack.abort)
2098
operation.add_cleanup(setattr, self, '_new_pack', None)
2099
# If we aborted while in the middle of finishing the write
2100
# group, _remove_pack_indices could fail because the indexes are
2101
# already gone. But they're not there we shouldn't fail in this
2102
# case, so we pass ignore_missing=True.
2103
operation.add_cleanup(self._remove_pack_indices, self._new_pack,
2104
ignore_missing=True)
2105
operation.run_simple()
2033
self._new_pack.abort()
2035
# XXX: If we aborted while in the middle of finishing the write
2036
# group, _remove_pack_indices can fail because the indexes are
2037
# already gone. If they're not there we shouldn't fail in this
2038
# case. -- mbp 20081113
2039
self._remove_pack_indices(self._new_pack)
2040
self._new_pack = None
2106
2041
for resumed_pack in self._resumed_packs:
2107
operation = cleanup.OperationWithCleanups(resumed_pack.abort)
2108
# See comment in previous finally block.
2109
operation.add_cleanup(self._remove_pack_indices, resumed_pack,
2110
ignore_missing=True)
2111
operation.run_simple()
2043
resumed_pack.abort()
2045
# See comment in previous finally block.
2047
self._remove_pack_indices(resumed_pack)
2112
2050
del self._resumed_packs[:]
2114
2052
def _remove_resumed_pack_indices(self):
2116
2054
self._remove_pack_indices(resumed_pack)
2117
2055
del self._resumed_packs[:]
2119
def _check_new_inventories(self):
2120
"""Detect missing inventories in this write group.
2122
:returns: list of strs, summarising any problems found. If the list is
2123
empty no problems were found.
2125
# The base implementation does no checks. GCRepositoryPackCollection
2129
2057
def _commit_write_group(self):
2130
2058
all_missing = set()
2131
2059
for prefix, versioned_file in (
2140
2068
raise errors.BzrCheckError(
2141
2069
"Repository %s has missing compression parent(s) %r "
2142
2070
% (self.repo, sorted(all_missing)))
2143
problems = self._check_new_inventories()
2145
problems_summary = '\n'.join(problems)
2146
raise errors.BzrCheckError(
2147
"Cannot add revision(s) to repository: " + problems_summary)
2148
2071
self._remove_pack_indices(self._new_pack)
2149
any_new_content = False
2072
should_autopack = False
2150
2073
if self._new_pack.data_inserted():
2151
2074
# get all the data to disk and read to use
2152
2075
self._new_pack.finish()
2153
2076
self.allocate(self._new_pack)
2154
2077
self._new_pack = None
2155
any_new_content = True
2078
should_autopack = True
2157
2080
self._new_pack.abort()
2158
2081
self._new_pack = None
2163
2086
self._remove_pack_from_memory(resumed_pack)
2164
2087
resumed_pack.finish()
2165
2088
self.allocate(resumed_pack)
2166
any_new_content = True
2089
should_autopack = True
2167
2090
del self._resumed_packs[:]
2169
result = self.autopack()
2092
if not self.autopack():
2171
2093
# when autopack takes no steps, the names list is still
2173
2095
return self._save_pack_names()
2177
2097
def _suspend_write_group(self):
2178
2098
tokens = [pack.name for pack in self._resumed_packs]
2280
2200
self._reconcile_fixes_text_parents = True
2281
2201
self._reconcile_backsup_inventory = False
2283
def _warn_if_deprecated(self, branch=None):
2203
def _warn_if_deprecated(self):
2284
2204
# This class isn't deprecated, but one sub-format is
2285
2205
if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2286
super(KnitPackRepository, self)._warn_if_deprecated(branch)
2206
from bzrlib import repository
2207
if repository._deprecation_warning_done:
2209
repository._deprecation_warning_done = True
2210
warning("Format %s for %s is deprecated - please use"
2211
" 'bzr upgrade --1.6.1-rich-root'"
2212
% (self._format, self.bzrdir.transport.base))
2288
2214
def _abort_write_group(self):
2289
self.revisions._index._key_dependencies.clear()
2215
self.revisions._index._key_dependencies.refs.clear()
2290
2216
self._pack_collection._abort_write_group()
2292
2218
def _get_source(self, to_format):
2306
2232
self._pack_collection._start_write_group()
2308
2234
def _commit_write_group(self):
2309
hint = self._pack_collection._commit_write_group()
2310
self.revisions._index._key_dependencies.clear()
2235
self.revisions._index._key_dependencies.refs.clear()
2236
return self._pack_collection._commit_write_group()
2313
2238
def suspend_write_group(self):
2314
2239
# XXX check self._write_group is self.get_transaction()?
2315
2240
tokens = self._pack_collection._suspend_write_group()
2316
self.revisions._index._key_dependencies.clear()
2241
self.revisions._index._key_dependencies.refs.clear()
2317
2242
self._write_group = None
2347
2272
if self._write_lock_count == 1:
2348
2273
self._transaction = transactions.WriteTransaction()
2350
if 'relock' in debug.debug_flags and self._prev_lock == 'w':
2351
note('%r was write locked again', self)
2352
self._prev_lock = 'w'
2353
2275
for repo in self._fallback_repositories:
2354
2276
# Writes don't affect fallback repos
2355
2277
repo.lock_read()
2363
2285
self.control_files.lock_read()
2365
if 'relock' in debug.debug_flags and self._prev_lock == 'r':
2366
note('%r was read locked again', self)
2367
self._prev_lock = 'r'
2368
2287
for repo in self._fallback_repositories:
2369
2288
repo.lock_read()
2370
2289
self._refresh_data()
2378
2297
raise NotImplementedError(self.dont_leave_lock_in_place)
2380
2299
@needs_write_lock
2381
def pack(self, hint=None, clean_obsolete_packs=False):
2300
def pack(self, hint=None):
2382
2301
"""Compress the data within the repository.
2384
2303
This will pack all the data to a single pack. In future it may
2385
2304
recompress deltas or do other such expensive operations.
2387
self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
2306
self._pack_collection.pack(hint=hint)
2389
2308
@needs_write_lock
2390
2309
def reconcile(self, other=None, thorough=False):
2398
2317
packer = ReconcilePacker(collection, packs, extension, revs)
2399
2318
return packer.pack(pb)
2401
@only_raises(errors.LockNotHeld, errors.LockBroken)
2402
2320
def unlock(self):
2403
2321
if self._write_lock_count == 1 and self._write_group is not None:
2404
2322
self.abort_write_group()
2546
2464
utf8_files = [('format', self.get_format_string())]
2548
2466
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
2549
repository = self.open(a_bzrdir=a_bzrdir, _found=True)
2550
self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
2467
return self.open(a_bzrdir=a_bzrdir, _found=True)
2553
2469
def open(self, a_bzrdir, _found=False, _override_transport=None):
2554
2470
"""See RepositoryFormat.open().
2603
2519
"""See RepositoryFormat.get_format_description()."""
2604
2520
return "Packs containing knits without subtree support"
2522
def check_conversion_target(self, target_format):
2607
2526
class RepositoryFormatKnitPack3(RepositoryFormatPack):
2608
2527
"""A subtrees parameterized Pack repository.
2636
2554
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2556
def check_conversion_target(self, target_format):
2557
if not target_format.rich_root_data:
2558
raise errors.BadConversionTarget(
2559
'Does not support rich root data.', target_format)
2560
if not getattr(target_format, 'supports_tree_reference', False):
2561
raise errors.BadConversionTarget(
2562
'Does not support nested trees', target_format)
2638
2564
def get_format_string(self):
2639
2565
"""See RepositoryFormat.get_format_string()."""
2640
2566
return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2674
2600
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2602
def check_conversion_target(self, target_format):
2603
if not target_format.rich_root_data:
2604
raise errors.BadConversionTarget(
2605
'Does not support rich root data.', target_format)
2676
2607
def get_format_string(self):
2677
2608
"""See RepositoryFormat.get_format_string()."""
2678
2609
return ("Bazaar pack repository format 1 with rich root"
2719
2650
"""See RepositoryFormat.get_format_description()."""
2720
2651
return "Packs 5 (adds stacking support, requires bzr 1.6)"
2653
def check_conversion_target(self, target_format):
2723
2657
class RepositoryFormatKnitPack5RichRoot(RepositoryFormatPack):
2724
2658
"""A repository with rich roots and stacking.
2752
2686
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2688
def check_conversion_target(self, target_format):
2689
if not target_format.rich_root_data:
2690
raise errors.BadConversionTarget(
2691
'Does not support rich root data.', target_format)
2754
2693
def get_format_string(self):
2755
2694
"""See RepositoryFormat.get_format_string()."""
2756
2695
return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n"
2798
2737
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2739
def check_conversion_target(self, target_format):
2740
if not target_format.rich_root_data:
2741
raise errors.BadConversionTarget(
2742
'Does not support rich root data.', target_format)
2800
2744
def get_format_string(self):
2801
2745
"""See RepositoryFormat.get_format_string()."""
2802
2746
return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n"
2840
2784
"""See RepositoryFormat.get_format_description()."""
2841
2785
return "Packs 6 (uses btree indexes, requires bzr 1.9)"
2787
def check_conversion_target(self, target_format):
2844
2791
class RepositoryFormatKnitPack6RichRoot(RepositoryFormatPack):
2845
2792
"""A repository with rich roots, no subtrees, stacking and btree indexes.
2870
2817
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2819
def check_conversion_target(self, target_format):
2820
if not target_format.rich_root_data:
2821
raise errors.BadConversionTarget(
2822
'Does not support rich root data.', target_format)
2872
2824
def get_format_string(self):
2873
2825
"""See RepositoryFormat.get_format_string()."""
2874
2826
return "Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n"
2891
2843
repository_class = KnitPackRepository
2892
2844
_commit_builder_class = PackRootCommitBuilder
2893
2845
rich_root_data = True
2895
2846
supports_tree_reference = True
2896
2847
supports_external_lookups = True
2897
2848
# What index classes to use
2912
2863
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2865
def check_conversion_target(self, target_format):
2866
if not target_format.rich_root_data:
2867
raise errors.BadConversionTarget(
2868
'Does not support rich root data.', target_format)
2869
if not getattr(target_format, 'supports_tree_reference', False):
2870
raise errors.BadConversionTarget(
2871
'Does not support nested trees', target_format)
2914
2873
def get_format_string(self):
2915
2874
"""See RepositoryFormat.get_format_string()."""
2916
2875
return ("Bazaar development format 2 with subtree support "
added
removed
bzrlib/repofmt/pack_repo.py
