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
226
225
return self.index_name('text', name)
228
227
def _replace_index_with_readonly(self, index_type):
229
unlimited_cache = False
230
if index_type == 'chk':
231
unlimited_cache = True
232
228
setattr(self, index_type + '_index',
233
229
self.index_class(self.index_transport,
234
230
self.index_name(index_type, self.name),
235
self.index_sizes[self.index_offset(index_type)],
236
unlimited_cache=unlimited_cache))
231
self.index_sizes[self.index_offset(index_type)]))
239
234
class ExistingPack(Pack):
587
582
flush_func=flush_func)
588
583
self.add_callback = None
585
def replace_indices(self, index_to_pack, indices):
586
"""Replace the current mappings with fresh ones.
588
This should probably not be used eventually, rather incremental add and
589
removal of indices. It has been added during refactoring of existing
592
:param index_to_pack: A mapping from index objects to
593
(transport, name) tuples for the pack file data.
594
:param indices: A list of indices.
596
# refresh the revision pack map dict without replacing the instance.
597
self.index_to_pack.clear()
598
self.index_to_pack.update(index_to_pack)
599
# XXX: API break - clearly a 'replace' method would be good?
600
self.combined_index._indices[:] = indices
601
# the current add nodes callback for the current writable index if
603
self.add_callback = None
590
605
def add_index(self, index, pack):
591
606
"""Add index to the aggregate, which is an index for Pack pack.
599
614
# expose it to the index map
600
615
self.index_to_pack[index] = pack.access_tuple()
601
616
# put it at the front of the linear index list
602
self.combined_index.insert_index(0, index, pack.name)
617
self.combined_index.insert_index(0, index)
604
619
def add_writable_index(self, index, pack):
605
620
"""Add an index which is able to have data added to it.
625
640
self.data_access.set_writer(None, None, (None, None))
626
641
self.index_to_pack.clear()
627
642
del self.combined_index._indices[:]
628
del self.combined_index._index_names[:]
629
643
self.add_callback = None
631
def remove_index(self, index):
645
def remove_index(self, index, pack):
632
646
"""Remove index from the indices used to answer queries.
634
648
:param index: An index from the pack parameter.
649
:param pack: A Pack instance.
636
651
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]
652
self.combined_index._indices.remove(index)
640
653
if (self.add_callback is not None and
641
654
getattr(index, 'add_nodes', None) == self.add_callback):
642
655
self.add_callback = None
1100
1113
iterator is a tuple with:
1101
1114
index, readv_vector, node_vector. readv_vector is a list ready to
1102
1115
hand to the transport readv method, and node_vector is a list of
1103
(key, eol_flag, references) for the node retrieved by the
1116
(key, eol_flag, references) for the the node retrieved by the
1104
1117
matching readv_vector.
1106
1119
# group by pack so we do one readv per pack
1398
1411
self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1399
1412
self.text_index = AggregateIndex(self.reload_pack_names, flush)
1400
1413
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
1414
if use_chk_index:
1404
1415
self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1405
all_indices.append(self.chk_index)
1407
1417
# used to determine if we're using a chk_index elsewhere.
1408
1418
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
1419
# resumed packs
1416
1420
self._resumed_packs = []
1419
return '%s(%r)' % (self.__class__.__name__, self.repo)
1421
1422
def add_pack_to_memory(self, pack):
1422
1423
"""Make a Pack object available to the repository to satisfy queries.
1537
1538
self._remove_pack_from_memory(pack)
1538
1539
# 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)
1541
result = self._save_pack_names(clear_obsolete_packs=True)
1542
# Move the old packs out of the way now they are no longer referenced.
1543
for revision_count, packs in pack_operations:
1544
self._obsolete_packs(packs)
1547
1547
def _flush_new_pack(self):
1560
1560
"""Is the collection already packed?"""
1561
1561
return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1563
def pack(self, hint=None, clean_obsolete_packs=False):
1563
def pack(self, hint=None):
1564
1564
"""Pack the pack collection totally."""
1565
1565
self.ensure_loaded()
1566
1566
total_packs = len(self._names)
1582
1582
pack_operations[-1][1].append(pack)
1583
1583
self._execute_pack_operations(pack_operations, OptimisingPacker)
1585
if clean_obsolete_packs:
1586
self._clear_obsolete_packs()
1588
1585
def plan_autopack_combinations(self, existing_packs, pack_distribution):
1589
1586
"""Plan a pack operation.
1678
1675
txt_index = self._make_index(name, '.tix')
1679
1676
sig_index = self._make_index(name, '.six')
1680
1677
if self.chk_index is not None:
1681
chk_index = self._make_index(name, '.cix', unlimited_cache=True)
1678
chk_index = self._make_index(name, '.cix')
1683
1680
chk_index = None
1684
1681
result = ExistingPack(self._pack_transport, name, rev_index,
1703
1700
txt_index = self._make_index(name, '.tix', resume=True)
1704
1701
sig_index = self._make_index(name, '.six', resume=True)
1705
1702
if self.chk_index is not None:
1706
chk_index = self._make_index(name, '.cix', resume=True,
1707
unlimited_cache=True)
1703
chk_index = self._make_index(name, '.cix', resume=True)
1709
1705
chk_index = None
1710
1706
result = self.resumed_pack_factory(name, rev_index, inv_index,
1740
1736
return self._index_class(self.transport, 'pack-names', None
1741
1737
).iter_all_entries()
1743
def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
1739
def _make_index(self, name, suffix, resume=False):
1744
1740
size_offset = self._suffix_offsets[suffix]
1745
1741
index_name = name + suffix
1750
1746
transport = self._index_transport
1751
1747
index_size = self._names[name][size_offset]
1752
return self._index_class(transport, index_name, index_size,
1753
unlimited_cache=unlimited_cache)
1748
return self._index_class(transport, index_name, index_size)
1755
1750
def _max_pack_count(self, total_revisions):
1756
1751
"""Return the maximum number of packs to use for total revisions.
1784
1779
:param return: None.
1786
1781
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"
1782
pack.pack_transport.rename(pack.file_name(),
1783
'../obsolete_packs/' + pack.file_name())
1794
1784
# TODO: Probably needs to know all possible indices for this pack
1795
1785
# - or maybe list the directory and move all indices matching this
1796
1786
# name whether we recognize it or not?
1798
1788
if self.chk_index is not None:
1799
1789
suffixes.append('.cix')
1800
1790
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"
1791
self._index_transport.rename(pack.name + suffix,
1792
'../obsolete_packs/' + pack.name + suffix)
1808
1794
def pack_distribution(self, total_revisions):
1809
1795
"""Generate a list of the number of revisions to put in each pack.
1835
1821
self._remove_pack_indices(pack)
1836
1822
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)
1824
def _remove_pack_indices(self, pack):
1825
"""Remove the indices for pack from the aggregated indices."""
1826
self.revision_index.remove_index(pack.revision_index, pack)
1827
self.inventory_index.remove_index(pack.inventory_index, pack)
1828
self.text_index.remove_index(pack.text_index, pack)
1829
self.signature_index.remove_index(pack.signature_index, pack)
1830
if self.chk_index is not None:
1831
self.chk_index.remove_index(pack.chk_index, pack)
1855
1833
def reset(self):
1856
1834
"""Clear all cached data."""
1889
1867
disk_nodes = set()
1890
1868
for index, key, value in self._iter_disk_pack_index():
1891
1869
disk_nodes.add((key, value))
1892
orig_disk_nodes = set(disk_nodes)
1894
1871
# do a two-way diff against our original content
1895
1872
current_nodes = set()
1908
1885
disk_nodes.difference_update(deleted_nodes)
1909
1886
disk_nodes.update(new_nodes)
1911
return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
1888
return disk_nodes, deleted_nodes, new_nodes
1913
1890
def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1914
1891
"""Given the correct set of pack files, update our saved info.
1954
1931
added.append(name)
1955
1932
return removed, added, modified
1957
def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):
1934
def _save_pack_names(self, clear_obsolete_packs=False):
1958
1935
"""Save the list of packs.
1960
1937
This will take out the mutex around the pack names list for the
1965
1942
:param clear_obsolete_packs: If True, clear out the contents of the
1966
1943
obsolete_packs directory.
1967
:param obsolete_packs: Packs that are obsolete once the new pack-names
1968
file has been written.
1969
1944
:return: A list of the names saved that were not previously on disk.
1971
already_obsolete = []
1972
1946
self.lock_names()
1974
1948
builder = self._index_builder_class()
1975
(disk_nodes, deleted_nodes, new_nodes,
1976
orig_disk_nodes) = self._diff_pack_names()
1949
disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1977
1950
# TODO: handle same-name, index-size-changes here -
1978
1951
# e.g. use the value from disk, not ours, *unless* we're the one
1981
1954
builder.add_node(key, value)
1982
1955
self.transport.put_file('pack-names', builder.finish(),
1983
1956
mode=self.repo.bzrdir._get_file_mode())
1957
# move the baseline forward
1984
1958
self._packs_at_load = disk_nodes
1985
1959
if clear_obsolete_packs:
1988
to_preserve = set([o.name for o in obsolete_packs])
1989
already_obsolete = self._clear_obsolete_packs(to_preserve)
1960
self._clear_obsolete_packs()
1991
1962
self._unlock_names()
1992
1963
# synchronise the memory packs list with what we just wrote:
1993
1964
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
1965
return [new_node[0][0] for new_node in new_nodes]
2005
1967
def reload_pack_names(self):
2022
1984
# 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
1985
disk_nodes, _, _ = self._diff_pack_names()
1986
self._packs_at_load = disk_nodes
2029
1987
(removed, added,
2030
1988
modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2031
1989
if removed or added or modified:
2041
1999
raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2043
def _clear_obsolete_packs(self, preserve=None):
2001
def _clear_obsolete_packs(self):
2044
2002
"""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
2004
obsolete_pack_transport = self.transport.clone('obsolete_packs')
2051
if preserve is None:
2053
2005
for filename in obsolete_pack_transport.list_dir('.'):
2054
name, ext = osutils.splitext(filename)
2057
if name in preserve:
2060
2007
obsolete_pack_transport.delete(filename)
2061
2008
except (errors.PathError, errors.TransportError), e:
2062
warning("couldn't delete obsolete pack, skipping it:\n%s"
2009
warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2066
2011
def _start_write_group(self):
2067
2012
# Do not permit preparation for writing if we're not in a 'write lock'.
2094
2039
# FIXME: just drop the transient index.
2095
2040
# forget what names there are
2096
2041
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()
2043
self._new_pack.abort()
2045
# XXX: If we aborted while in the middle of finishing the write
2046
# group, _remove_pack_indices can fail because the indexes are
2047
# already gone. If they're not there we shouldn't fail in this
2048
# case. -- mbp 20081113
2049
self._remove_pack_indices(self._new_pack)
2050
self._new_pack = None
2106
2051
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()
2053
resumed_pack.abort()
2055
# See comment in previous finally block.
2057
self._remove_pack_indices(resumed_pack)
2112
2060
del self._resumed_packs[:]
2114
2062
def _remove_resumed_pack_indices(self):
2280
2228
self._reconcile_fixes_text_parents = True
2281
2229
self._reconcile_backsup_inventory = False
2283
def _warn_if_deprecated(self, branch=None):
2231
def _warn_if_deprecated(self):
2284
2232
# This class isn't deprecated, but one sub-format is
2285
2233
if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2286
super(KnitPackRepository, self)._warn_if_deprecated(branch)
2234
from bzrlib import repository
2235
if repository._deprecation_warning_done:
2237
repository._deprecation_warning_done = True
2238
warning("Format %s for %s is deprecated - please use"
2239
" 'bzr upgrade --1.6.1-rich-root'"
2240
% (self._format, self.bzrdir.transport.base))
2288
2242
def _abort_write_group(self):
2289
2243
self.revisions._index._key_dependencies.clear()
2378
2332
raise NotImplementedError(self.dont_leave_lock_in_place)
2380
2334
@needs_write_lock
2381
def pack(self, hint=None, clean_obsolete_packs=False):
2335
def pack(self, hint=None):
2382
2336
"""Compress the data within the repository.
2384
2338
This will pack all the data to a single pack. In future it may
2385
2339
recompress deltas or do other such expensive operations.
2387
self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
2341
self._pack_collection.pack(hint=hint)
2389
2343
@needs_write_lock
2390
2344
def reconcile(self, other=None, thorough=False):
2546
2500
utf8_files = [('format', self.get_format_string())]
2548
2502
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)
2503
return self.open(a_bzrdir=a_bzrdir, _found=True)
2553
2505
def open(self, a_bzrdir, _found=False, _override_transport=None):
2554
2506
"""See RepositoryFormat.open().
2891
2842
repository_class = KnitPackRepository
2892
2843
_commit_builder_class = PackRootCommitBuilder
2893
2844
rich_root_data = True
2895
2845
supports_tree_reference = True
2896
2846
supports_external_lookups = True
2897
2847
# What index classes to use
added
removed
bzrlib/repofmt/pack_repo.py
