226
228
return self.index_name('text', name)
228
230
def _replace_index_with_readonly(self, index_type):
229
unlimited_cache = False
230
if index_type == 'chk':
231
unlimited_cache = True
232
231
setattr(self, index_type + '_index',
233
232
self.index_class(self.index_transport,
234
233
self.index_name(index_type, self.name),
235
self.index_sizes[self.index_offset(index_type)],
236
unlimited_cache=unlimited_cache))
234
self.index_sizes[self.index_offset(index_type)]))
239
237
class ExistingPack(Pack):
271
269
def __init__(self, name, revision_index, inventory_index, text_index,
272
270
signature_index, upload_transport, pack_transport, index_transport,
273
pack_collection, chk_index=None):
274
272
"""Create a ResumedPack object."""
275
273
ExistingPack.__init__(self, pack_transport, name, revision_index,
276
inventory_index, text_index, signature_index,
274
inventory_index, text_index, signature_index)
278
275
self.upload_transport = upload_transport
279
276
self.index_transport = index_transport
280
277
self.index_sizes = [None, None, None, None]
307
301
self.upload_transport.delete(self.file_name())
308
302
indices = [self.revision_index, self.inventory_index, self.text_index,
309
303
self.signature_index]
310
if self.chk_index is not None:
311
indices.append(self.chk_index)
312
304
for index in indices:
313
305
index._transport.delete(index._name)
315
307
def finish(self):
316
308
self._check_references()
317
index_types = ['revision', 'inventory', 'text', 'signature']
318
if self.chk_index is not None:
319
index_types.append('chk')
320
for index_type in index_types:
309
new_name = '../packs/' + self.file_name()
310
self.upload_transport.rename(self.file_name(), new_name)
311
for index_type in ['revision', 'inventory', 'text', 'signature']:
321
312
old_name = self.index_name(index_type, self.name)
322
313
new_name = '../indices/' + old_name
323
314
self.upload_transport.rename(old_name, new_name)
324
315
self._replace_index_with_readonly(index_type)
325
new_name = '../packs/' + self.file_name()
326
self.upload_transport.rename(self.file_name(), new_name)
327
316
self._state = 'finished'
329
318
def _get_external_refs(self, index):
330
"""Return compression parents for this index that are not present.
332
This returns any compression parents that are referenced by this index,
333
which are not contained *in* this index. They may be present elsewhere.
335
319
return index.external_references(1)
587
564
flush_func=flush_func)
588
565
self.add_callback = None
567
def replace_indices(self, index_to_pack, indices):
568
"""Replace the current mappings with fresh ones.
570
This should probably not be used eventually, rather incremental add and
571
removal of indices. It has been added during refactoring of existing
574
:param index_to_pack: A mapping from index objects to
575
(transport, name) tuples for the pack file data.
576
:param indices: A list of indices.
578
# refresh the revision pack map dict without replacing the instance.
579
self.index_to_pack.clear()
580
self.index_to_pack.update(index_to_pack)
581
# XXX: API break - clearly a 'replace' method would be good?
582
self.combined_index._indices[:] = indices
583
# the current add nodes callback for the current writable index if
585
self.add_callback = None
590
587
def add_index(self, index, pack):
591
588
"""Add index to the aggregate, which is an index for Pack pack.
625
622
self.data_access.set_writer(None, None, (None, None))
626
623
self.index_to_pack.clear()
627
624
del self.combined_index._indices[:]
628
del self.combined_index._index_names[:]
629
625
self.add_callback = None
631
def remove_index(self, index):
627
def remove_index(self, index, pack):
632
628
"""Remove index from the indices used to answer queries.
634
630
:param index: An index from the pack parameter.
631
:param pack: A Pack instance.
636
633
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]
634
self.combined_index._indices.remove(index)
640
635
if (self.add_callback is not None and
641
636
getattr(index, 'add_nodes', None) == self.add_callback):
642
637
self.add_callback = None
1398
1392
self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1399
1393
self.text_index = AggregateIndex(self.reload_pack_names, flush)
1400
1394
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
1395
if use_chk_index:
1404
1396
self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1405
all_indices.append(self.chk_index)
1407
1398
# used to determine if we're using a chk_index elsewhere.
1408
1399
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
1400
# resumed packs
1416
1401
self._resumed_packs = []
1419
return '%s(%r)' % (self.__class__.__name__, self.repo)
1421
1403
def add_pack_to_memory(self, pack):
1422
1404
"""Make a Pack object available to the repository to satisfy queries.
1504
1486
'containing %d revisions. Packing %d files into %d affecting %d'
1505
1487
' revisions', self, total_packs, total_revisions, num_old_packs,
1506
1488
num_new_packs, num_revs_affected)
1507
result = self._execute_pack_operations(pack_operations,
1489
self._execute_pack_operations(pack_operations,
1508
1490
reload_func=self._restart_autopack)
1509
1491
mutter('Auto-packing repository %s completed', self)
1512
1494
def _execute_pack_operations(self, pack_operations, _packer_class=Packer,
1513
1495
reload_func=None):
1537
1519
self._remove_pack_from_memory(pack)
1538
1520
# 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)
1522
self._save_pack_names(clear_obsolete_packs=True)
1523
# Move the old packs out of the way now they are no longer referenced.
1524
for revision_count, packs in pack_operations:
1525
self._obsolete_packs(packs)
1547
1527
def _flush_new_pack(self):
1548
1528
if self._new_pack is not None:
1559
1539
def _already_packed(self):
1560
1540
"""Is the collection already packed?"""
1561
return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1541
return len(self._names) < 2
1563
def pack(self, hint=None, clean_obsolete_packs=False):
1564
1544
"""Pack the pack collection totally."""
1565
1545
self.ensure_loaded()
1566
1546
total_packs = len(self._names)
1567
1547
if self._already_packed():
1548
# This is arguably wrong because we might not be optimal, but for
1549
# now lets leave it in. (e.g. reconcile -> one pack. But not
1569
1552
total_revisions = self.revision_index.combined_index.key_count()
1570
1553
# XXX: the following may want to be a class, to pack with a given
1572
1555
mutter('Packing repository %s, which has %d pack files, '
1573
'containing %d revisions with hint %r.', self, total_packs,
1574
total_revisions, hint)
1556
'containing %d revisions into 1 packs.', self, total_packs,
1575
1558
# determine which packs need changing
1559
pack_distribution = [1]
1576
1560
pack_operations = [[0, []]]
1577
1561
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.
1581
pack_operations[-1][0] += pack.get_revision_count()
1582
pack_operations[-1][1].append(pack)
1562
pack_operations[-1][0] += pack.get_revision_count()
1563
pack_operations[-1][1].append(pack)
1583
1564
self._execute_pack_operations(pack_operations, OptimisingPacker)
1585
if clean_obsolete_packs:
1586
self._clear_obsolete_packs()
1588
1566
def plan_autopack_combinations(self, existing_packs, pack_distribution):
1589
1567
"""Plan a pack operation.
1702
1680
inv_index = self._make_index(name, '.iix', resume=True)
1703
1681
txt_index = self._make_index(name, '.tix', resume=True)
1704
1682
sig_index = self._make_index(name, '.six', resume=True)
1705
if self.chk_index is not None:
1706
chk_index = self._make_index(name, '.cix', resume=True,
1707
unlimited_cache=True)
1710
result = self.resumed_pack_factory(name, rev_index, inv_index,
1711
txt_index, sig_index, self._upload_transport,
1712
self._pack_transport, self._index_transport, self,
1713
chk_index=chk_index)
1683
result = ResumedPack(name, rev_index, inv_index, txt_index,
1684
sig_index, self._upload_transport, self._pack_transport,
1685
self._index_transport, self)
1714
1686
except errors.NoSuchFile, e:
1715
1687
raise errors.UnresumableWriteGroup(self.repo, [name], str(e))
1716
1688
self.add_pack_to_memory(result)
1784
1755
:param return: None.
1786
1757
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"
1758
pack.pack_transport.rename(pack.file_name(),
1759
'../obsolete_packs/' + pack.file_name())
1794
1760
# TODO: Probably needs to know all possible indices for this pack
1795
1761
# - or maybe list the directory and move all indices matching this
1796
1762
# name whether we recognize it or not?
1798
1764
if self.chk_index is not None:
1799
1765
suffixes.append('.cix')
1800
1766
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"
1767
self._index_transport.rename(pack.name + suffix,
1768
'../obsolete_packs/' + pack.name + suffix)
1808
1770
def pack_distribution(self, total_revisions):
1809
1771
"""Generate a list of the number of revisions to put in each pack.
1835
1797
self._remove_pack_indices(pack)
1836
1798
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)
1800
def _remove_pack_indices(self, pack):
1801
"""Remove the indices for pack from the aggregated indices."""
1802
self.revision_index.remove_index(pack.revision_index, pack)
1803
self.inventory_index.remove_index(pack.inventory_index, pack)
1804
self.text_index.remove_index(pack.text_index, pack)
1805
self.signature_index.remove_index(pack.signature_index, pack)
1806
if self.chk_index is not None:
1807
self.chk_index.remove_index(pack.chk_index, pack)
1855
1809
def reset(self):
1856
1810
"""Clear all cached data."""
1857
1811
# cached revision data
1812
self.repo._revision_knit = None
1858
1813
self.revision_index.clear()
1859
1814
# cached signature data
1815
self.repo._signature_knit = None
1860
1816
self.signature_index.clear()
1861
1817
# cached file text data
1862
1818
self.text_index.clear()
1819
self.repo._text_knit = None
1863
1820
# cached inventory data
1864
1821
self.inventory_index.clear()
1865
1822
# cached chk data
1965
1921
:param clear_obsolete_packs: If True, clear out the contents of the
1966
1922
obsolete_packs directory.
1967
:param obsolete_packs: Packs that are obsolete once the new pack-names
1968
file has been written.
1969
:return: A list of the names saved that were not previously on disk.
1971
already_obsolete = []
1972
1924
self.lock_names()
1974
1926
builder = self._index_builder_class()
1975
(disk_nodes, deleted_nodes, new_nodes,
1976
orig_disk_nodes) = self._diff_pack_names()
1927
disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1977
1928
# TODO: handle same-name, index-size-changes here -
1978
1929
# e.g. use the value from disk, not ours, *unless* we're the one
1981
1932
builder.add_node(key, value)
1982
1933
self.transport.put_file('pack-names', builder.finish(),
1983
1934
mode=self.repo.bzrdir._get_file_mode())
1935
# move the baseline forward
1984
1936
self._packs_at_load = disk_nodes
1985
1937
if clear_obsolete_packs:
1988
to_preserve = set([o.name for o in obsolete_packs])
1989
already_obsolete = self._clear_obsolete_packs(to_preserve)
1938
self._clear_obsolete_packs()
1991
1940
self._unlock_names()
1992
1941
# synchronise the memory packs list with what we just wrote:
1993
1942
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
return [new_node[0][0] for new_node in new_nodes]
2005
1944
def reload_pack_names(self):
2006
1945
"""Sync our pack listing with what is present in the repository.
2022
1961
# 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
1962
disk_nodes, _, _ = self._diff_pack_names()
1963
self._packs_at_load = disk_nodes
2029
1964
(removed, added,
2030
1965
modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2031
1966
if removed or added or modified:
2041
1976
raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2043
def _clear_obsolete_packs(self, preserve=None):
1978
def _clear_obsolete_packs(self):
2044
1979
"""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
1981
obsolete_pack_transport = self.transport.clone('obsolete_packs')
2051
if preserve is None:
2053
1982
for filename in obsolete_pack_transport.list_dir('.'):
2054
name, ext = osutils.splitext(filename)
2057
if name in preserve:
2060
1984
obsolete_pack_transport.delete(filename)
2061
1985
except (errors.PathError, errors.TransportError), e:
2062
warning("couldn't delete obsolete pack, skipping it:\n%s"
1986
warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2066
1988
def _start_write_group(self):
2067
1989
# Do not permit preparation for writing if we're not in a 'write lock'.
2094
2016
# FIXME: just drop the transient index.
2095
2017
# forget what names there are
2096
2018
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()
2020
self._new_pack.abort()
2022
# XXX: If we aborted while in the middle of finishing the write
2023
# group, _remove_pack_indices can fail because the indexes are
2024
# already gone. If they're not there we shouldn't fail in this
2025
# case. -- mbp 20081113
2026
self._remove_pack_indices(self._new_pack)
2027
self._new_pack = None
2106
2028
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()
2030
resumed_pack.abort()
2032
# See comment in previous finally block.
2034
self._remove_pack_indices(resumed_pack)
2112
2037
del self._resumed_packs[:]
2038
self.repo._text_knit = None
2114
2040
def _remove_resumed_pack_indices(self):
2115
2041
for resumed_pack in self._resumed_packs:
2116
2042
self._remove_pack_indices(resumed_pack)
2117
2043
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
2045
def _commit_write_group(self):
2130
2046
all_missing = set()
2131
2047
for prefix, versioned_file in (
2140
2056
raise errors.BzrCheckError(
2141
2057
"Repository %s has missing compression parent(s) %r "
2142
2058
% (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
2059
self._remove_pack_indices(self._new_pack)
2149
any_new_content = False
2060
should_autopack = False
2150
2061
if self._new_pack.data_inserted():
2151
2062
# get all the data to disk and read to use
2152
2063
self._new_pack.finish()
2153
2064
self.allocate(self._new_pack)
2154
2065
self._new_pack = None
2155
any_new_content = True
2066
should_autopack = True
2157
2068
self._new_pack.abort()
2158
2069
self._new_pack = None
2280
2190
self._reconcile_fixes_text_parents = True
2281
2191
self._reconcile_backsup_inventory = False
2283
def _warn_if_deprecated(self, branch=None):
2193
def _warn_if_deprecated(self):
2284
2194
# This class isn't deprecated, but one sub-format is
2285
2195
if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2286
super(KnitPackRepository, self)._warn_if_deprecated(branch)
2196
from bzrlib import repository
2197
if repository._deprecation_warning_done:
2199
repository._deprecation_warning_done = True
2200
warning("Format %s for %s is deprecated - please use"
2201
" 'bzr upgrade --1.6.1-rich-root'"
2202
% (self._format, self.bzrdir.transport.base))
2288
2204
def _abort_write_group(self):
2289
self.revisions._index._key_dependencies.clear()
2290
2205
self._pack_collection._abort_write_group()
2292
def _get_source(self, to_format):
2293
if to_format.network_name() == self._format.network_name():
2294
return KnitPackStreamSource(self, to_format)
2295
return super(KnitPackRepository, self)._get_source(to_format)
2207
def _find_inconsistent_revision_parents(self):
2208
"""Find revisions with incorrectly cached parents.
2210
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
2211
parents-in-revision).
2213
if not self.is_locked():
2214
raise errors.ObjectNotLocked(self)
2215
pb = ui.ui_factory.nested_progress_bar()
2218
revision_nodes = self._pack_collection.revision_index \
2219
.combined_index.iter_all_entries()
2220
index_positions = []
2221
# Get the cached index values for all revisions, and also the
2222
# location in each index of the revision text so we can perform
2224
for index, key, value, refs in revision_nodes:
2225
node = (index, key, value, refs)
2226
index_memo = self.revisions._index._node_to_position(node)
2227
if index_memo[0] != index:
2228
raise AssertionError('%r != %r' % (index_memo[0], index))
2229
index_positions.append((index_memo, key[0],
2230
tuple(parent[0] for parent in refs[0])))
2231
pb.update("Reading revision index", 0, 0)
2232
index_positions.sort()
2234
pb.update("Checking cached revision graph", 0,
2235
len(index_positions))
2236
for offset in xrange(0, len(index_positions), 1000):
2237
pb.update("Checking cached revision graph", offset)
2238
to_query = index_positions[offset:offset + batch_size]
2241
rev_ids = [item[1] for item in to_query]
2242
revs = self.get_revisions(rev_ids)
2243
for revision, item in zip(revs, to_query):
2244
index_parents = item[2]
2245
rev_parents = tuple(revision.parent_ids)
2246
if index_parents != rev_parents:
2247
result.append((revision.revision_id, index_parents,
2297
2253
def _make_parents_provider(self):
2298
2254
return graph.CachingParentsProvider(self)
2306
2262
self._pack_collection._start_write_group()
2308
2264
def _commit_write_group(self):
2309
hint = self._pack_collection._commit_write_group()
2310
self.revisions._index._key_dependencies.clear()
2265
return self._pack_collection._commit_write_group()
2313
2267
def suspend_write_group(self):
2314
2268
# XXX check self._write_group is self.get_transaction()?
2315
2269
tokens = self._pack_collection._suspend_write_group()
2316
self.revisions._index._key_dependencies.clear()
2317
2270
self._write_group = None
2320
2273
def _resume_write_group(self, tokens):
2321
2274
self._start_write_group()
2323
self._pack_collection._resume_write_group(tokens)
2324
except errors.UnresumableWriteGroup:
2325
self._abort_write_group()
2275
self._pack_collection._resume_write_group(tokens)
2327
2276
for pack in self._pack_collection._resumed_packs:
2328
2277
self.revisions._index.scan_unvalidated_index(pack.revision_index)
2413
2356
transaction = self._transaction
2414
2357
self._transaction = None
2415
2358
transaction.finish()
2359
for repo in self._fallback_repositories:
2417
2362
self.control_files.unlock()
2419
if not self.is_locked():
2420
2363
for repo in self._fallback_repositories:
2424
class KnitPackStreamSource(StreamSource):
2425
"""A StreamSource used to transfer data between same-format KnitPack repos.
2427
This source assumes:
2428
1) Same serialization format for all objects
2429
2) Same root information
2430
3) XML format inventories
2431
4) Atomic inserts (so we can stream inventory texts before text
2436
def __init__(self, from_repository, to_format):
2437
super(KnitPackStreamSource, self).__init__(from_repository, to_format)
2438
self._text_keys = None
2439
self._text_fetch_order = 'unordered'
2441
def _get_filtered_inv_stream(self, revision_ids):
2442
from_repo = self.from_repository
2443
parent_ids = from_repo._find_parent_ids_of_revisions(revision_ids)
2444
parent_keys = [(p,) for p in parent_ids]
2445
find_text_keys = from_repo._find_text_key_references_from_xml_inventory_lines
2446
parent_text_keys = set(find_text_keys(
2447
from_repo._inventory_xml_lines_for_keys(parent_keys)))
2448
content_text_keys = set()
2449
knit = KnitVersionedFiles(None, None)
2450
factory = KnitPlainFactory()
2451
def find_text_keys_from_content(record):
2452
if record.storage_kind not in ('knit-delta-gz', 'knit-ft-gz'):
2453
raise ValueError("Unknown content storage kind for"
2454
" inventory text: %s" % (record.storage_kind,))
2455
# It's a knit record, it has a _raw_record field (even if it was
2456
# reconstituted from a network stream).
2457
raw_data = record._raw_record
2458
# read the entire thing
2459
revision_id = record.key[-1]
2460
content, _ = knit._parse_record(revision_id, raw_data)
2461
if record.storage_kind == 'knit-delta-gz':
2462
line_iterator = factory.get_linedelta_content(content)
2463
elif record.storage_kind == 'knit-ft-gz':
2464
line_iterator = factory.get_fulltext_content(content)
2465
content_text_keys.update(find_text_keys(
2466
[(line, revision_id) for line in line_iterator]))
2467
revision_keys = [(r,) for r in revision_ids]
2468
def _filtered_inv_stream():
2469
source_vf = from_repo.inventories
2470
stream = source_vf.get_record_stream(revision_keys,
2472
for record in stream:
2473
if record.storage_kind == 'absent':
2474
raise errors.NoSuchRevision(from_repo, record.key)
2475
find_text_keys_from_content(record)
2477
self._text_keys = content_text_keys - parent_text_keys
2478
return ('inventories', _filtered_inv_stream())
2480
def _get_text_stream(self):
2481
# Note: We know we don't have to handle adding root keys, because both
2482
# the source and target are the identical network name.
2483
text_stream = self.from_repository.texts.get_record_stream(
2484
self._text_keys, self._text_fetch_order, False)
2485
return ('texts', text_stream)
2487
def get_stream(self, search):
2488
revision_ids = search.get_keys()
2489
for stream_info in self._fetch_revision_texts(revision_ids):
2491
self._revision_keys = [(rev_id,) for rev_id in revision_ids]
2492
yield self._get_filtered_inv_stream(revision_ids)
2493
yield self._get_text_stream()
2497
2367
class RepositoryFormatPack(MetaDirRepositoryFormat):
2498
2368
"""Format logic for pack structured repositories.
2546
2416
utf8_files = [('format', self.get_format_string())]
2548
2418
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)
2419
return self.open(a_bzrdir=a_bzrdir, _found=True)
2553
2421
def open(self, a_bzrdir, _found=False, _override_transport=None):
2554
2422
"""See RepositoryFormat.open().
2636
2506
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2508
def check_conversion_target(self, target_format):
2509
if not target_format.rich_root_data:
2510
raise errors.BadConversionTarget(
2511
'Does not support rich root data.', target_format)
2512
if not getattr(target_format, 'supports_tree_reference', False):
2513
raise errors.BadConversionTarget(
2514
'Does not support nested trees', target_format)
2638
2516
def get_format_string(self):
2639
2517
"""See RepositoryFormat.get_format_string()."""
2640
2518
return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2912
2815
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2817
def check_conversion_target(self, target_format):
2818
if not target_format.rich_root_data:
2819
raise errors.BadConversionTarget(
2820
'Does not support rich root data.', target_format)
2821
if not getattr(target_format, 'supports_tree_reference', False):
2822
raise errors.BadConversionTarget(
2823
'Does not support nested trees', target_format)
2914
2825
def get_format_string(self):
2915
2826
"""See RepositoryFormat.get_format_string()."""
2916
2827
return ("Bazaar development format 2 with subtree support "
added
removed
bzrlib/repofmt/pack_repo.py
