228
229
return self.index_name('text', name)
230
231
def _replace_index_with_readonly(self, index_type):
231
unlimited_cache = False
232
if index_type == 'chk':
233
unlimited_cache = True
234
232
setattr(self, index_type + '_index',
235
233
self.index_class(self.index_transport,
236
234
self.index_name(index_type, self.name),
237
self.index_sizes[self.index_offset(index_type)],
238
unlimited_cache=unlimited_cache))
235
self.index_sizes[self.index_offset(index_type)]))
241
238
class ExistingPack(Pack):
589
579
flush_func=flush_func)
590
580
self.add_callback = None
582
def replace_indices(self, index_to_pack, indices):
583
"""Replace the current mappings with fresh ones.
585
This should probably not be used eventually, rather incremental add and
586
removal of indices. It has been added during refactoring of existing
589
:param index_to_pack: A mapping from index objects to
590
(transport, name) tuples for the pack file data.
591
:param indices: A list of indices.
593
# refresh the revision pack map dict without replacing the instance.
594
self.index_to_pack.clear()
595
self.index_to_pack.update(index_to_pack)
596
# XXX: API break - clearly a 'replace' method would be good?
597
self.combined_index._indices[:] = indices
598
# the current add nodes callback for the current writable index if
600
self.add_callback = None
592
602
def add_index(self, index, pack):
593
603
"""Add index to the aggregate, which is an index for Pack pack.
601
611
# expose it to the index map
602
612
self.index_to_pack[index] = pack.access_tuple()
603
613
# put it at the front of the linear index list
604
self.combined_index.insert_index(0, index, pack.name)
614
self.combined_index.insert_index(0, index)
606
616
def add_writable_index(self, index, pack):
607
617
"""Add an index which is able to have data added to it.
627
637
self.data_access.set_writer(None, None, (None, None))
628
638
self.index_to_pack.clear()
629
639
del self.combined_index._indices[:]
630
del self.combined_index._index_names[:]
631
640
self.add_callback = None
633
def remove_index(self, index):
642
def remove_index(self, index, pack):
634
643
"""Remove index from the indices used to answer queries.
636
645
:param index: An index from the pack parameter.
646
:param pack: A Pack instance.
638
648
del self.index_to_pack[index]
639
pos = self.combined_index._indices.index(index)
640
del self.combined_index._indices[pos]
641
del self.combined_index._index_names[pos]
649
self.combined_index._indices.remove(index)
642
650
if (self.add_callback is not None and
643
651
getattr(index, 'add_nodes', None) == self.add_callback):
644
652
self.add_callback = None
1102
1110
iterator is a tuple with:
1103
1111
index, readv_vector, node_vector. readv_vector is a list ready to
1104
1112
hand to the transport readv method, and node_vector is a list of
1105
(key, eol_flag, references) for the node retrieved by the
1113
(key, eol_flag, references) for the the node retrieved by the
1106
1114
matching readv_vector.
1108
1116
# group by pack so we do one readv per pack
1400
1408
self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1401
1409
self.text_index = AggregateIndex(self.reload_pack_names, flush)
1402
1410
self.signature_index = AggregateIndex(self.reload_pack_names, flush)
1403
all_indices = [self.revision_index, self.inventory_index,
1404
self.text_index, self.signature_index]
1405
1411
if use_chk_index:
1406
1412
self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1407
all_indices.append(self.chk_index)
1409
1414
# used to determine if we're using a chk_index elsewhere.
1410
1415
self.chk_index = None
1411
# Tell all the CombinedGraphIndex objects about each other, so they can
1412
# share hints about which pack names to search first.
1413
all_combined = [agg_idx.combined_index for agg_idx in all_indices]
1414
for combined_idx in all_combined:
1415
combined_idx.set_sibling_indices(
1416
set(all_combined).difference([combined_idx]))
1417
1416
# resumed packs
1418
1417
self._resumed_packs = []
1421
return '%s(%r)' % (self.__class__.__name__, self.repo)
1423
1419
def add_pack_to_memory(self, pack):
1424
1420
"""Make a Pack object available to the repository to satisfy queries.
1539
1535
self._remove_pack_from_memory(pack)
1540
1536
# record the newly available packs and stop advertising the old
1542
to_be_obsoleted = []
1543
for _, packs in pack_operations:
1544
to_be_obsoleted.extend(packs)
1545
result = self._save_pack_names(clear_obsolete_packs=True,
1546
obsolete_packs=to_be_obsoleted)
1538
result = self._save_pack_names(clear_obsolete_packs=True)
1539
# Move the old packs out of the way now they are no longer referenced.
1540
for revision_count, packs in pack_operations:
1541
self._obsolete_packs(packs)
1549
1544
def _flush_new_pack(self):
1577
1572
# determine which packs need changing
1578
1573
pack_operations = [[0, []]]
1579
1574
for pack in self.all_packs():
1580
if hint is None or pack.name in hint:
1581
# Either no hint was provided (so we are packing everything),
1582
# or this pack was included in the hint.
1575
if not hint or pack.name in hint:
1583
1576
pack_operations[-1][0] += pack.get_revision_count()
1584
1577
pack_operations[-1][1].append(pack)
1585
1578
self._execute_pack_operations(pack_operations, OptimisingPacker)
1587
if clean_obsolete_packs:
1588
self._clear_obsolete_packs()
1590
1580
def plan_autopack_combinations(self, existing_packs, pack_distribution):
1591
1581
"""Plan a pack operation.
1680
1670
txt_index = self._make_index(name, '.tix')
1681
1671
sig_index = self._make_index(name, '.six')
1682
1672
if self.chk_index is not None:
1683
chk_index = self._make_index(name, '.cix', unlimited_cache=True)
1673
chk_index = self._make_index(name, '.cix')
1685
1675
chk_index = None
1686
1676
result = ExistingPack(self._pack_transport, name, rev_index,
1705
1695
txt_index = self._make_index(name, '.tix', resume=True)
1706
1696
sig_index = self._make_index(name, '.six', resume=True)
1707
1697
if self.chk_index is not None:
1708
chk_index = self._make_index(name, '.cix', resume=True,
1709
unlimited_cache=True)
1698
chk_index = self._make_index(name, '.cix', resume=True)
1711
1700
chk_index = None
1712
1701
result = self.resumed_pack_factory(name, rev_index, inv_index,
1742
1731
return self._index_class(self.transport, 'pack-names', None
1743
1732
).iter_all_entries()
1745
def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
1734
def _make_index(self, name, suffix, resume=False):
1746
1735
size_offset = self._suffix_offsets[suffix]
1747
1736
index_name = name + suffix
1752
1741
transport = self._index_transport
1753
1742
index_size = self._names[name][size_offset]
1754
return self._index_class(transport, index_name, index_size,
1755
unlimited_cache=unlimited_cache)
1743
return self._index_class(transport, index_name, index_size)
1757
1745
def _max_pack_count(self, total_revisions):
1758
1746
"""Return the maximum number of packs to use for total revisions.
1786
1774
:param return: None.
1788
1776
for pack in packs:
1790
pack.pack_transport.rename(pack.file_name(),
1791
'../obsolete_packs/' + pack.file_name())
1792
except (errors.PathError, errors.TransportError), e:
1793
# TODO: Should these be warnings or mutters?
1794
mutter("couldn't rename obsolete pack, skipping it:\n%s"
1777
pack.pack_transport.rename(pack.file_name(),
1778
'../obsolete_packs/' + pack.file_name())
1796
1779
# TODO: Probably needs to know all possible indices for this pack
1797
1780
# - or maybe list the directory and move all indices matching this
1798
1781
# name whether we recognize it or not?
1800
1783
if self.chk_index is not None:
1801
1784
suffixes.append('.cix')
1802
1785
for suffix in suffixes:
1804
self._index_transport.rename(pack.name + suffix,
1805
'../obsolete_packs/' + pack.name + suffix)
1806
except (errors.PathError, errors.TransportError), e:
1807
mutter("couldn't rename obsolete index, skipping it:\n%s"
1786
self._index_transport.rename(pack.name + suffix,
1787
'../obsolete_packs/' + pack.name + suffix)
1810
1789
def pack_distribution(self, total_revisions):
1811
1790
"""Generate a list of the number of revisions to put in each pack.
1837
1816
self._remove_pack_indices(pack)
1838
1817
self.packs.remove(pack)
1840
def _remove_pack_indices(self, pack, ignore_missing=False):
1841
"""Remove the indices for pack from the aggregated indices.
1843
:param ignore_missing: Suppress KeyErrors from calling remove_index.
1845
for index_type in Pack.index_definitions.keys():
1846
attr_name = index_type + '_index'
1847
aggregate_index = getattr(self, attr_name)
1848
if aggregate_index is not None:
1849
pack_index = getattr(pack, attr_name)
1851
aggregate_index.remove_index(pack_index)
1819
def _remove_pack_indices(self, pack):
1820
"""Remove the indices for pack from the aggregated indices."""
1821
self.revision_index.remove_index(pack.revision_index, pack)
1822
self.inventory_index.remove_index(pack.inventory_index, pack)
1823
self.text_index.remove_index(pack.text_index, pack)
1824
self.signature_index.remove_index(pack.signature_index, pack)
1825
if self.chk_index is not None:
1826
self.chk_index.remove_index(pack.chk_index, pack)
1857
1828
def reset(self):
1858
1829
"""Clear all cached data."""
1910
1880
disk_nodes.difference_update(deleted_nodes)
1911
1881
disk_nodes.update(new_nodes)
1913
return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
1883
return disk_nodes, deleted_nodes, new_nodes
1915
1885
def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1916
1886
"""Given the correct set of pack files, update our saved info.
1967
1937
:param clear_obsolete_packs: If True, clear out the contents of the
1968
1938
obsolete_packs directory.
1969
:param obsolete_packs: Packs that are obsolete once the new pack-names
1970
file has been written.
1971
1939
:return: A list of the names saved that were not previously on disk.
1973
already_obsolete = []
1974
1941
self.lock_names()
1976
1943
builder = self._index_builder_class()
1977
(disk_nodes, deleted_nodes, new_nodes,
1978
orig_disk_nodes) = self._diff_pack_names()
1944
disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1979
1945
# TODO: handle same-name, index-size-changes here -
1980
1946
# e.g. use the value from disk, not ours, *unless* we're the one
1983
1949
builder.add_node(key, value)
1984
1950
self.transport.put_file('pack-names', builder.finish(),
1985
1951
mode=self.repo.bzrdir._get_file_mode())
1952
# move the baseline forward
1986
1953
self._packs_at_load = disk_nodes
1987
1954
if clear_obsolete_packs:
1990
to_preserve = set([o.name for o in obsolete_packs])
1991
already_obsolete = self._clear_obsolete_packs(to_preserve)
1955
self._clear_obsolete_packs()
1993
1957
self._unlock_names()
1994
1958
# synchronise the memory packs list with what we just wrote:
1995
1959
self._syncronize_pack_names_from_disk_nodes(disk_nodes)
1997
# TODO: We could add one more condition here. "if o.name not in
1998
# orig_disk_nodes and o != the new_pack we haven't written to
1999
# disk yet. However, the new pack object is not easily
2000
# accessible here (it would have to be passed through the
2001
# autopacking code, etc.)
2002
obsolete_packs = [o for o in obsolete_packs
2003
if o.name not in already_obsolete]
2004
self._obsolete_packs(obsolete_packs)
2005
1960
return [new_node[0][0] for new_node in new_nodes]
2007
1962
def reload_pack_names(self):
2024
1979
# out the new value.
2025
(disk_nodes, deleted_nodes, new_nodes,
2026
orig_disk_nodes) = self._diff_pack_names()
2027
# _packs_at_load is meant to be the explicit list of names in
2028
# 'pack-names' at then start. As such, it should not contain any
2029
# pending names that haven't been written out yet.
2030
self._packs_at_load = orig_disk_nodes
1980
disk_nodes, _, _ = self._diff_pack_names()
1981
self._packs_at_load = disk_nodes
2031
1982
(removed, added,
2032
1983
modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2033
1984
if removed or added or modified:
2043
1994
raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2045
def _clear_obsolete_packs(self, preserve=None):
1996
def _clear_obsolete_packs(self):
2046
1997
"""Delete everything from the obsolete-packs directory.
2048
:return: A list of pack identifiers (the filename without '.pack') that
2049
were found in obsolete_packs.
2052
1999
obsolete_pack_transport = self.transport.clone('obsolete_packs')
2053
if preserve is None:
2055
2000
for filename in obsolete_pack_transport.list_dir('.'):
2056
name, ext = osutils.splitext(filename)
2059
if name in preserve:
2062
2002
obsolete_pack_transport.delete(filename)
2063
2003
except (errors.PathError, errors.TransportError), e:
2064
warning("couldn't delete obsolete pack, skipping it:\n%s"
2004
warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2068
2006
def _start_write_group(self):
2069
2007
# Do not permit preparation for writing if we're not in a 'write lock'.
2096
2034
# FIXME: just drop the transient index.
2097
2035
# forget what names there are
2098
2036
if self._new_pack is not None:
2099
operation = cleanup.OperationWithCleanups(self._new_pack.abort)
2100
operation.add_cleanup(setattr, self, '_new_pack', None)
2101
# If we aborted while in the middle of finishing the write
2102
# group, _remove_pack_indices could fail because the indexes are
2103
# already gone. But they're not there we shouldn't fail in this
2104
# case, so we pass ignore_missing=True.
2105
operation.add_cleanup(self._remove_pack_indices, self._new_pack,
2106
ignore_missing=True)
2107
operation.run_simple()
2038
self._new_pack.abort()
2040
# XXX: If we aborted while in the middle of finishing the write
2041
# group, _remove_pack_indices can fail because the indexes are
2042
# already gone. If they're not there we shouldn't fail in this
2043
# case. -- mbp 20081113
2044
self._remove_pack_indices(self._new_pack)
2045
self._new_pack = None
2108
2046
for resumed_pack in self._resumed_packs:
2109
operation = cleanup.OperationWithCleanups(resumed_pack.abort)
2110
# See comment in previous finally block.
2111
operation.add_cleanup(self._remove_pack_indices, resumed_pack,
2112
ignore_missing=True)
2113
operation.run_simple()
2048
resumed_pack.abort()
2050
# See comment in previous finally block.
2052
self._remove_pack_indices(resumed_pack)
2114
2055
del self._resumed_packs[:]
2116
2057
def _remove_resumed_pack_indices(self):
2118
2059
self._remove_pack_indices(resumed_pack)
2119
2060
del self._resumed_packs[:]
2121
def _check_new_inventories(self):
2122
"""Detect missing inventories in this write group.
2124
:returns: list of strs, summarising any problems found. If the list is
2125
empty no problems were found.
2127
# The base implementation does no checks. GCRepositoryPackCollection
2131
2062
def _commit_write_group(self):
2132
2063
all_missing = set()
2133
2064
for prefix, versioned_file in (
2142
2073
raise errors.BzrCheckError(
2143
2074
"Repository %s has missing compression parent(s) %r "
2144
2075
% (self.repo, sorted(all_missing)))
2145
problems = self._check_new_inventories()
2147
problems_summary = '\n'.join(problems)
2148
raise errors.BzrCheckError(
2149
"Cannot add revision(s) to repository: " + problems_summary)
2150
2076
self._remove_pack_indices(self._new_pack)
2151
any_new_content = False
2077
should_autopack = False
2152
2078
if self._new_pack.data_inserted():
2153
2079
# get all the data to disk and read to use
2154
2080
self._new_pack.finish()
2155
2081
self.allocate(self._new_pack)
2156
2082
self._new_pack = None
2157
any_new_content = True
2083
should_autopack = True
2159
2085
self._new_pack.abort()
2160
2086
self._new_pack = None
2282
2205
self._reconcile_fixes_text_parents = True
2283
2206
self._reconcile_backsup_inventory = False
2285
def _warn_if_deprecated(self, branch=None):
2208
def _warn_if_deprecated(self):
2286
2209
# This class isn't deprecated, but one sub-format is
2287
2210
if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2288
super(KnitPackRepository, self)._warn_if_deprecated(branch)
2211
from bzrlib import repository
2212
if repository._deprecation_warning_done:
2214
repository._deprecation_warning_done = True
2215
warning("Format %s for %s is deprecated - please use"
2216
" 'bzr upgrade --1.6.1-rich-root'"
2217
% (self._format, self.bzrdir.transport.base))
2290
2219
def _abort_write_group(self):
2291
self.revisions._index._key_dependencies.clear()
2220
self.revisions._index._key_dependencies.refs.clear()
2292
2221
self._pack_collection._abort_write_group()
2223
def _find_inconsistent_revision_parents(self):
2224
"""Find revisions with incorrectly cached parents.
2226
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
2227
parents-in-revision).
2229
if not self.is_locked():
2230
raise errors.ObjectNotLocked(self)
2231
pb = ui.ui_factory.nested_progress_bar()
2234
revision_nodes = self._pack_collection.revision_index \
2235
.combined_index.iter_all_entries()
2236
index_positions = []
2237
# Get the cached index values for all revisions, and also the
2238
# location in each index of the revision text so we can perform
2240
for index, key, value, refs in revision_nodes:
2241
node = (index, key, value, refs)
2242
index_memo = self.revisions._index._node_to_position(node)
2243
if index_memo[0] != index:
2244
raise AssertionError('%r != %r' % (index_memo[0], index))
2245
index_positions.append((index_memo, key[0],
2246
tuple(parent[0] for parent in refs[0])))
2247
pb.update("Reading revision index", 0, 0)
2248
index_positions.sort()
2250
pb.update("Checking cached revision graph", 0,
2251
len(index_positions))
2252
for offset in xrange(0, len(index_positions), 1000):
2253
pb.update("Checking cached revision graph", offset)
2254
to_query = index_positions[offset:offset + batch_size]
2257
rev_ids = [item[1] for item in to_query]
2258
revs = self.get_revisions(rev_ids)
2259
for revision, item in zip(revs, to_query):
2260
index_parents = item[2]
2261
rev_parents = tuple(revision.parent_ids)
2262
if index_parents != rev_parents:
2263
result.append((revision.revision_id, index_parents,
2294
2269
def _get_source(self, to_format):
2295
2270
if to_format.network_name() == self._format.network_name():
2296
2271
return KnitPackStreamSource(self, to_format)
2308
2283
self._pack_collection._start_write_group()
2310
2285
def _commit_write_group(self):
2311
hint = self._pack_collection._commit_write_group()
2312
self.revisions._index._key_dependencies.clear()
2286
self.revisions._index._key_dependencies.refs.clear()
2287
return self._pack_collection._commit_write_group()
2315
2289
def suspend_write_group(self):
2316
2290
# XXX check self._write_group is self.get_transaction()?
2317
2291
tokens = self._pack_collection._suspend_write_group()
2318
self.revisions._index._key_dependencies.clear()
2292
self.revisions._index._key_dependencies.refs.clear()
2319
2293
self._write_group = None
2353
2323
if self._write_lock_count == 1:
2354
2324
self._transaction = transactions.WriteTransaction()
2356
if 'relock' in debug.debug_flags and self._prev_lock == 'w':
2357
note('%r was write locked again', self)
2358
self._prev_lock = 'w'
2359
2326
for repo in self._fallback_repositories:
2360
2327
# Writes don't affect fallback repos
2361
2328
repo.lock_read()
2362
2329
self._refresh_data()
2363
return RepositoryWriteLockResult(self.unlock, None)
2365
2331
def lock_read(self):
2366
"""Lock the repository for reads.
2368
:return: A bzrlib.lock.LogicalLockResult.
2370
2332
locked = self.is_locked()
2371
2333
if self._write_lock_count:
2372
2334
self._write_lock_count += 1
2374
2336
self.control_files.lock_read()
2376
if 'relock' in debug.debug_flags and self._prev_lock == 'r':
2377
note('%r was read locked again', self)
2378
self._prev_lock = 'r'
2379
2338
for repo in self._fallback_repositories:
2380
2339
repo.lock_read()
2381
2340
self._refresh_data()
2382
return LogicalLockResult(self.unlock)
2384
2342
def leave_lock_in_place(self):
2385
2343
# not supported - raise an error
2390
2348
raise NotImplementedError(self.dont_leave_lock_in_place)
2392
2350
@needs_write_lock
2393
def pack(self, hint=None, clean_obsolete_packs=False):
2351
def pack(self, hint=None):
2394
2352
"""Compress the data within the repository.
2396
2354
This will pack all the data to a single pack. In future it may
2397
2355
recompress deltas or do other such expensive operations.
2399
self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
2357
self._pack_collection.pack(hint=hint)
2401
2359
@needs_write_lock
2402
2360
def reconcile(self, other=None, thorough=False):
2558
2515
utf8_files = [('format', self.get_format_string())]
2560
2517
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
2561
repository = self.open(a_bzrdir=a_bzrdir, _found=True)
2562
self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
2518
return self.open(a_bzrdir=a_bzrdir, _found=True)
2565
2520
def open(self, a_bzrdir, _found=False, _override_transport=None):
2566
2521
"""See RepositoryFormat.open().
2648
2605
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2607
def check_conversion_target(self, target_format):
2608
if not target_format.rich_root_data:
2609
raise errors.BadConversionTarget(
2610
'Does not support rich root data.', target_format)
2611
if not getattr(target_format, 'supports_tree_reference', False):
2612
raise errors.BadConversionTarget(
2613
'Does not support nested trees', target_format)
2650
2615
def get_format_string(self):
2651
2616
"""See RepositoryFormat.get_format_string()."""
2652
2617
return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2686
2651
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2653
def check_conversion_target(self, target_format):
2654
if not target_format.rich_root_data:
2655
raise errors.BadConversionTarget(
2656
'Does not support rich root data.', target_format)
2688
2658
def get_format_string(self):
2689
2659
"""See RepositoryFormat.get_format_string()."""
2690
2660
return ("Bazaar pack repository format 1 with rich root"
2764
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)
2766
2744
def get_format_string(self):
2767
2745
"""See RepositoryFormat.get_format_string()."""
2768
2746
return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n"
2810
2788
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2790
def check_conversion_target(self, target_format):
2791
if not target_format.rich_root_data:
2792
raise errors.BadConversionTarget(
2793
'Does not support rich root data.', target_format)
2812
2795
def get_format_string(self):
2813
2796
"""See RepositoryFormat.get_format_string()."""
2814
2797
return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n"
2882
2868
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2870
def check_conversion_target(self, target_format):
2871
if not target_format.rich_root_data:
2872
raise errors.BadConversionTarget(
2873
'Does not support rich root data.', target_format)
2884
2875
def get_format_string(self):
2885
2876
"""See RepositoryFormat.get_format_string()."""
2886
2877
return "Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n"
2924
2914
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2916
def check_conversion_target(self, target_format):
2917
if not target_format.rich_root_data:
2918
raise errors.BadConversionTarget(
2919
'Does not support rich root data.', target_format)
2920
if not getattr(target_format, 'supports_tree_reference', False):
2921
raise errors.BadConversionTarget(
2922
'Does not support nested trees', target_format)
2926
2924
def get_format_string(self):
2927
2925
"""See RepositoryFormat.get_format_string()."""
2928
2926
return ("Bazaar development format 2 with subtree support "
added
removed
bzrlib/repofmt/pack_repo.py
