/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/pack_repo.py

  • Committer: Aaron Bentley
  • Date: 2009-06-29 14:51:13 UTC
  • mfrom: (4489 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4490.
  • Revision ID: aaron@aaronbentley.com-20090629145113-3w350dxgqppnzo4g
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/pack_repo.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
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
24
24
 
25
25
from bzrlib import (
26
26
    chk_map,
27
 
    cleanup,
28
27
    debug,
29
28
    graph,
30
29
    osutils,
37
36
    )
38
37
from bzrlib.index import (
39
38
    CombinedGraphIndex,
 
39
    GraphIndex,
 
40
    GraphIndexBuilder,
40
41
    GraphIndexPrefixAdapter,
 
42
    InMemoryGraphIndex,
41
43
    )
42
44
from bzrlib.knit import (
43
45
    KnitPlainFactory,
53
55
    lockable_files,
54
56
    lockdir,
55
57
    revision as _mod_revision,
 
58
    symbol_versioning,
56
59
    )
57
60
 
58
 
from bzrlib.decorators import needs_write_lock, only_raises
 
61
from bzrlib.decorators import needs_write_lock
59
62
from bzrlib.btree_index import (
60
63
    BTreeGraphIndex,
61
64
    BTreeBuilder,
72
75
    RootCommitBuilder,
73
76
    StreamSource,
74
77
    )
 
78
import bzrlib.revision as _mod_revision
75
79
from bzrlib.trace import (
76
80
    mutter,
77
 
    note,
78
81
    warning,
79
82
    )
80
83
 
226
229
        return self.index_name('text', name)
227
230
 
228
231
    def _replace_index_with_readonly(self, index_type):
229
 
        unlimited_cache = False
230
 
        if index_type == 'chk':
231
 
            unlimited_cache = True
232
232
        setattr(self, index_type + '_index',
233
233
            self.index_class(self.index_transport,
234
234
                self.index_name(index_type, self.name),
235
 
                self.index_sizes[self.index_offset(index_type)],
236
 
                unlimited_cache=unlimited_cache))
 
235
                self.index_sizes[self.index_offset(index_type)]))
237
236
 
238
237
 
239
238
class ExistingPack(Pack):
428
427
        self._writer.begin()
429
428
        # what state is the pack in? (open, finished, aborted)
430
429
        self._state = 'open'
431
 
        # no name until we finish writing the content
432
 
        self.name = None
433
430
 
434
431
    def abort(self):
435
432
        """Cancel creating this pack."""
456
453
            self.signature_index.key_count() or
457
454
            (self.chk_index is not None and self.chk_index.key_count()))
458
455
 
459
 
    def finish_content(self):
460
 
        if self.name is not None:
461
 
            return
462
 
        self._writer.end()
463
 
        if self._buffer[1]:
464
 
            self._write_data('', flush=True)
465
 
        self.name = self._hash.hexdigest()
466
 
 
467
456
    def finish(self, suspend=False):
468
457
        """Finish the new pack.
469
458
 
475
464
         - stores the index size tuple for the pack in the index_sizes
476
465
           attribute.
477
466
        """
478
 
        self.finish_content()
 
467
        self._writer.end()
 
468
        if self._buffer[1]:
 
469
            self._write_data('', flush=True)
 
470
        self.name = self._hash.hexdigest()
479
471
        if not suspend:
480
472
            self._check_references()
481
473
        # write indices
587
579
                                             flush_func=flush_func)
588
580
        self.add_callback = None
589
581
 
 
582
    def replace_indices(self, index_to_pack, indices):
 
583
        """Replace the current mappings with fresh ones.
 
584
 
 
585
        This should probably not be used eventually, rather incremental add and
 
586
        removal of indices. It has been added during refactoring of existing
 
587
        code.
 
588
 
 
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.
 
592
        """
 
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
 
599
        # there is one.
 
600
        self.add_callback = None
 
601
 
590
602
    def add_index(self, index, pack):
591
603
        """Add index to the aggregate, which is an index for Pack pack.
592
604
 
599
611
        # expose it to the index map
600
612
        self.index_to_pack[index] = pack.access_tuple()
601
613
        # put it at the front of the linear index list
602
 
        self.combined_index.insert_index(0, index, pack.name)
 
614
        self.combined_index.insert_index(0, index)
603
615
 
604
616
    def add_writable_index(self, index, pack):
605
617
        """Add an index which is able to have data added to it.
625
637
        self.data_access.set_writer(None, None, (None, None))
626
638
        self.index_to_pack.clear()
627
639
        del self.combined_index._indices[:]
628
 
        del self.combined_index._index_names[:]
629
640
        self.add_callback = None
630
641
 
631
 
    def remove_index(self, index):
 
642
    def remove_index(self, index, pack):
632
643
        """Remove index from the indices used to answer queries.
633
644
 
634
645
        :param index: An index from the pack parameter.
 
646
        :param pack: A Pack instance.
635
647
        """
636
648
        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]
 
649
        self.combined_index._indices.remove(index)
640
650
        if (self.add_callback is not None and
641
651
            getattr(index, 'add_nodes', None) == self.add_callback):
642
652
            self.add_callback = None
1100
1110
            iterator is a tuple with:
1101
1111
            index, readv_vector, node_vector. readv_vector is a list ready to
1102
1112
            hand to the transport readv method, and node_vector is a list of
1103
 
            (key, eol_flag, references) for the node retrieved by the
 
1113
            (key, eol_flag, references) for the the node retrieved by the
1104
1114
            matching readv_vector.
1105
1115
        """
1106
1116
        # group by pack so we do one readv per pack
1398
1408
        self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1399
1409
        self.text_index = AggregateIndex(self.reload_pack_names, flush)
1400
1410
        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
1411
        if use_chk_index:
1404
1412
            self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1405
 
            all_indices.append(self.chk_index)
1406
1413
        else:
1407
1414
            # used to determine if we're using a chk_index elsewhere.
1408
1415
            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
1416
        # resumed packs
1416
1417
        self._resumed_packs = []
1417
1418
 
1418
 
    def __repr__(self):
1419
 
        return '%s(%r)' % (self.__class__.__name__, self.repo)
1420
 
 
1421
1419
    def add_pack_to_memory(self, pack):
1422
1420
        """Make a Pack object available to the repository to satisfy queries.
1423
1421
 
1537
1535
                self._remove_pack_from_memory(pack)
1538
1536
        # record the newly available packs and stop advertising the old
1539
1537
        # packs
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)
 
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)
1545
1542
        return result
1546
1543
 
1547
1544
    def _flush_new_pack(self):
1560
1557
        """Is the collection already packed?"""
1561
1558
        return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1562
1559
 
1563
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1560
    def pack(self, hint=None):
1564
1561
        """Pack the pack collection totally."""
1565
1562
        self.ensure_loaded()
1566
1563
        total_packs = len(self._names)
1575
1572
        # determine which packs need changing
1576
1573
        pack_operations = [[0, []]]
1577
1574
        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.
 
1575
            if not hint or pack.name in hint:
1581
1576
                pack_operations[-1][0] += pack.get_revision_count()
1582
1577
                pack_operations[-1][1].append(pack)
1583
1578
        self._execute_pack_operations(pack_operations, OptimisingPacker)
1584
1579
 
1585
 
        if clean_obsolete_packs:
1586
 
            self._clear_obsolete_packs()
1587
 
 
1588
1580
    def plan_autopack_combinations(self, existing_packs, pack_distribution):
1589
1581
        """Plan a pack operation.
1590
1582
 
1678
1670
            txt_index = self._make_index(name, '.tix')
1679
1671
            sig_index = self._make_index(name, '.six')
1680
1672
            if self.chk_index is not None:
1681
 
                chk_index = self._make_index(name, '.cix', unlimited_cache=True)
 
1673
                chk_index = self._make_index(name, '.cix')
1682
1674
            else:
1683
1675
                chk_index = None
1684
1676
            result = ExistingPack(self._pack_transport, name, rev_index,
1703
1695
            txt_index = self._make_index(name, '.tix', resume=True)
1704
1696
            sig_index = self._make_index(name, '.six', resume=True)
1705
1697
            if self.chk_index is not None:
1706
 
                chk_index = self._make_index(name, '.cix', resume=True,
1707
 
                                             unlimited_cache=True)
 
1698
                chk_index = self._make_index(name, '.cix', resume=True)
1708
1699
            else:
1709
1700
                chk_index = None
1710
1701
            result = self.resumed_pack_factory(name, rev_index, inv_index,
1740
1731
        return self._index_class(self.transport, 'pack-names', None
1741
1732
                ).iter_all_entries()
1742
1733
 
1743
 
    def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
 
1734
    def _make_index(self, name, suffix, resume=False):
1744
1735
        size_offset = self._suffix_offsets[suffix]
1745
1736
        index_name = name + suffix
1746
1737
        if resume:
1749
1740
        else:
1750
1741
            transport = self._index_transport
1751
1742
            index_size = self._names[name][size_offset]
1752
 
        return self._index_class(transport, index_name, index_size,
1753
 
                                 unlimited_cache=unlimited_cache)
 
1743
        return self._index_class(transport, index_name, index_size)
1754
1744
 
1755
1745
    def _max_pack_count(self, total_revisions):
1756
1746
        """Return the maximum number of packs to use for total revisions.
1784
1774
        :param return: None.
1785
1775
        """
1786
1776
        for pack in packs:
1787
 
            try:
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"
1793
 
                       % (e,))
 
1777
            pack.pack_transport.rename(pack.file_name(),
 
1778
                '../obsolete_packs/' + pack.file_name())
1794
1779
            # TODO: Probably needs to know all possible indices for this pack
1795
1780
            # - or maybe list the directory and move all indices matching this
1796
1781
            # name whether we recognize it or not?
1798
1783
            if self.chk_index is not None:
1799
1784
                suffixes.append('.cix')
1800
1785
            for suffix in suffixes:
1801
 
                try:
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"
1806
 
                           % (e,))
 
1786
                self._index_transport.rename(pack.name + suffix,
 
1787
                    '../obsolete_packs/' + pack.name + suffix)
1807
1788
 
1808
1789
    def pack_distribution(self, total_revisions):
1809
1790
        """Generate a list of the number of revisions to put in each pack.
1835
1816
        self._remove_pack_indices(pack)
1836
1817
        self.packs.remove(pack)
1837
1818
 
1838
 
    def _remove_pack_indices(self, pack, ignore_missing=False):
1839
 
        """Remove the indices for pack from the aggregated indices.
1840
 
        
1841
 
        :param ignore_missing: Suppress KeyErrors from calling remove_index.
1842
 
        """
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)
1848
 
                try:
1849
 
                    aggregate_index.remove_index(pack_index)
1850
 
                except KeyError:
1851
 
                    if ignore_missing:
1852
 
                        continue
1853
 
                    raise
 
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)
1854
1827
 
1855
1828
    def reset(self):
1856
1829
        """Clear all cached data."""
1889
1862
        disk_nodes = set()
1890
1863
        for index, key, value in self._iter_disk_pack_index():
1891
1864
            disk_nodes.add((key, value))
1892
 
        orig_disk_nodes = set(disk_nodes)
1893
1865
 
1894
1866
        # do a two-way diff against our original content
1895
1867
        current_nodes = set()
1908
1880
        disk_nodes.difference_update(deleted_nodes)
1909
1881
        disk_nodes.update(new_nodes)
1910
1882
 
1911
 
        return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
 
1883
        return disk_nodes, deleted_nodes, new_nodes
1912
1884
 
1913
1885
    def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1914
1886
        """Given the correct set of pack files, update our saved info.
1954
1926
                added.append(name)
1955
1927
        return removed, added, modified
1956
1928
 
1957
 
    def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):
 
1929
    def _save_pack_names(self, clear_obsolete_packs=False):
1958
1930
        """Save the list of packs.
1959
1931
 
1960
1932
        This will take out the mutex around the pack names list for the
1964
1936
 
1965
1937
        :param clear_obsolete_packs: If True, clear out the contents of the
1966
1938
            obsolete_packs directory.
1967
 
        :param obsolete_packs: Packs that are obsolete once the new pack-names
1968
 
            file has been written.
1969
1939
        :return: A list of the names saved that were not previously on disk.
1970
1940
        """
1971
 
        already_obsolete = []
1972
1941
        self.lock_names()
1973
1942
        try:
1974
1943
            builder = self._index_builder_class()
1975
 
            (disk_nodes, deleted_nodes, new_nodes,
1976
 
             orig_disk_nodes) = self._diff_pack_names()
 
1944
            disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1977
1945
            # TODO: handle same-name, index-size-changes here -
1978
1946
            # e.g. use the value from disk, not ours, *unless* we're the one
1979
1947
            # changing it.
1981
1949
                builder.add_node(key, value)
1982
1950
            self.transport.put_file('pack-names', builder.finish(),
1983
1951
                mode=self.repo.bzrdir._get_file_mode())
 
1952
            # move the baseline forward
1984
1953
            self._packs_at_load = disk_nodes
1985
1954
            if clear_obsolete_packs:
1986
 
                to_preserve = None
1987
 
                if obsolete_packs:
1988
 
                    to_preserve = set([o.name for o in obsolete_packs])
1989
 
                already_obsolete = self._clear_obsolete_packs(to_preserve)
 
1955
                self._clear_obsolete_packs()
1990
1956
        finally:
1991
1957
            self._unlock_names()
1992
1958
        # synchronise the memory packs list with what we just wrote:
1993
1959
        self._syncronize_pack_names_from_disk_nodes(disk_nodes)
1994
 
        if obsolete_packs:
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
1960
        return [new_node[0][0] for new_node in new_nodes]
2004
1961
 
2005
1962
    def reload_pack_names(self):
2020
1977
        if first_read:
2021
1978
            return True
2022
1979
        # 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
 
1980
        disk_nodes, _, _ = self._diff_pack_names()
 
1981
        self._packs_at_load = disk_nodes
2029
1982
        (removed, added,
2030
1983
         modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2031
1984
        if removed or added or modified:
2040
1993
            raise
2041
1994
        raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2042
1995
 
2043
 
    def _clear_obsolete_packs(self, preserve=None):
 
1996
    def _clear_obsolete_packs(self):
2044
1997
        """Delete everything from the obsolete-packs directory.
2045
 
 
2046
 
        :return: A list of pack identifiers (the filename without '.pack') that
2047
 
            were found in obsolete_packs.
2048
1998
        """
2049
 
        found = []
2050
1999
        obsolete_pack_transport = self.transport.clone('obsolete_packs')
2051
 
        if preserve is None:
2052
 
            preserve = set()
2053
2000
        for filename in obsolete_pack_transport.list_dir('.'):
2054
 
            name, ext = osutils.splitext(filename)
2055
 
            if ext == '.pack':
2056
 
                found.append(name)
2057
 
            if name in preserve:
2058
 
                continue
2059
2001
            try:
2060
2002
                obsolete_pack_transport.delete(filename)
2061
2003
            except (errors.PathError, errors.TransportError), e:
2062
 
                warning("couldn't delete obsolete pack, skipping it:\n%s"
2063
 
                        % (e,))
2064
 
        return found
 
2004
                warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2065
2005
 
2066
2006
    def _start_write_group(self):
2067
2007
        # Do not permit preparation for writing if we're not in a 'write lock'.
2094
2034
        # FIXME: just drop the transient index.
2095
2035
        # forget what names there are
2096
2036
        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()
 
2037
            try:
 
2038
                self._new_pack.abort()
 
2039
            finally:
 
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
2106
2046
        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()
 
2047
            try:
 
2048
                resumed_pack.abort()
 
2049
            finally:
 
2050
                # See comment in previous finally block.
 
2051
                try:
 
2052
                    self._remove_pack_indices(resumed_pack)
 
2053
                except KeyError:
 
2054
                    pass
2112
2055
        del self._resumed_packs[:]
2113
2056
 
2114
2057
    def _remove_resumed_pack_indices(self):
2116
2059
            self._remove_pack_indices(resumed_pack)
2117
2060
        del self._resumed_packs[:]
2118
2061
 
2119
 
    def _check_new_inventories(self):
2120
 
        """Detect missing inventories in this write group.
2121
 
 
2122
 
        :returns: list of strs, summarising any problems found.  If the list is
2123
 
            empty no problems were found.
2124
 
        """
2125
 
        # The base implementation does no checks.  GCRepositoryPackCollection
2126
 
        # overrides this.
2127
 
        return []
2128
 
        
2129
2062
    def _commit_write_group(self):
2130
2063
        all_missing = set()
2131
2064
        for prefix, versioned_file in (
2140
2073
            raise errors.BzrCheckError(
2141
2074
                "Repository %s has missing compression parent(s) %r "
2142
2075
                 % (self.repo, sorted(all_missing)))
2143
 
        problems = self._check_new_inventories()
2144
 
        if problems:
2145
 
            problems_summary = '\n'.join(problems)
2146
 
            raise errors.BzrCheckError(
2147
 
                "Cannot add revision(s) to repository: " + problems_summary)
2148
2076
        self._remove_pack_indices(self._new_pack)
2149
 
        any_new_content = False
 
2077
        should_autopack = False
2150
2078
        if self._new_pack.data_inserted():
2151
2079
            # get all the data to disk and read to use
2152
2080
            self._new_pack.finish()
2153
2081
            self.allocate(self._new_pack)
2154
2082
            self._new_pack = None
2155
 
            any_new_content = True
 
2083
            should_autopack = True
2156
2084
        else:
2157
2085
            self._new_pack.abort()
2158
2086
            self._new_pack = None
2163
2091
            self._remove_pack_from_memory(resumed_pack)
2164
2092
            resumed_pack.finish()
2165
2093
            self.allocate(resumed_pack)
2166
 
            any_new_content = True
 
2094
            should_autopack = True
2167
2095
        del self._resumed_packs[:]
2168
 
        if any_new_content:
2169
 
            result = self.autopack()
2170
 
            if not result:
 
2096
        if should_autopack:
 
2097
            if not self.autopack():
2171
2098
                # when autopack takes no steps, the names list is still
2172
2099
                # unsaved.
2173
2100
                return self._save_pack_names()
2174
 
            return result
2175
 
        return []
2176
2101
 
2177
2102
    def _suspend_write_group(self):
2178
2103
        tokens = [pack.name for pack in self._resumed_packs]
2280
2205
        self._reconcile_fixes_text_parents = True
2281
2206
        self._reconcile_backsup_inventory = False
2282
2207
 
2283
 
    def _warn_if_deprecated(self, branch=None):
 
2208
    def _warn_if_deprecated(self):
2284
2209
        # This class isn't deprecated, but one sub-format is
2285
2210
        if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2286
 
            super(KnitPackRepository, self)._warn_if_deprecated(branch)
 
2211
            from bzrlib import repository
 
2212
            if repository._deprecation_warning_done:
 
2213
                return
 
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))
2287
2218
 
2288
2219
    def _abort_write_group(self):
2289
 
        self.revisions._index._key_dependencies.clear()
 
2220
        self.revisions._index._key_dependencies.refs.clear()
2290
2221
        self._pack_collection._abort_write_group()
2291
2222
 
 
2223
    def _find_inconsistent_revision_parents(self):
 
2224
        """Find revisions with incorrectly cached parents.
 
2225
 
 
2226
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
2227
            parents-in-revision).
 
2228
        """
 
2229
        if not self.is_locked():
 
2230
            raise errors.ObjectNotLocked(self)
 
2231
        pb = ui.ui_factory.nested_progress_bar()
 
2232
        result = []
 
2233
        try:
 
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
 
2239
            # linear IO.
 
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()
 
2249
            batch_size = 1000
 
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]
 
2255
                if not to_query:
 
2256
                    break
 
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,
 
2264
                                       rev_parents))
 
2265
        finally:
 
2266
            pb.finished()
 
2267
        return result
 
2268
 
2292
2269
    def _get_source(self, to_format):
2293
2270
        if to_format.network_name() == self._format.network_name():
2294
2271
            return KnitPackStreamSource(self, to_format)
2306
2283
        self._pack_collection._start_write_group()
2307
2284
 
2308
2285
    def _commit_write_group(self):
2309
 
        hint = self._pack_collection._commit_write_group()
2310
 
        self.revisions._index._key_dependencies.clear()
2311
 
        return hint
 
2286
        self.revisions._index._key_dependencies.refs.clear()
 
2287
        return self._pack_collection._commit_write_group()
2312
2288
 
2313
2289
    def suspend_write_group(self):
2314
2290
        # XXX check self._write_group is self.get_transaction()?
2315
2291
        tokens = self._pack_collection._suspend_write_group()
2316
 
        self.revisions._index._key_dependencies.clear()
 
2292
        self.revisions._index._key_dependencies.refs.clear()
2317
2293
        self._write_group = None
2318
2294
        return tokens
2319
2295
 
2347
2323
        if self._write_lock_count == 1:
2348
2324
            self._transaction = transactions.WriteTransaction()
2349
2325
        if not locked:
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
2326
            for repo in self._fallback_repositories:
2354
2327
                # Writes don't affect fallback repos
2355
2328
                repo.lock_read()
2362
2335
        else:
2363
2336
            self.control_files.lock_read()
2364
2337
        if not locked:
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
2338
            for repo in self._fallback_repositories:
2369
2339
                repo.lock_read()
2370
2340
            self._refresh_data()
2378
2348
        raise NotImplementedError(self.dont_leave_lock_in_place)
2379
2349
 
2380
2350
    @needs_write_lock
2381
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2351
    def pack(self, hint=None):
2382
2352
        """Compress the data within the repository.
2383
2353
 
2384
2354
        This will pack all the data to a single pack. In future it may
2385
2355
        recompress deltas or do other such expensive operations.
2386
2356
        """
2387
 
        self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2357
        self._pack_collection.pack(hint=hint)
2388
2358
 
2389
2359
    @needs_write_lock
2390
2360
    def reconcile(self, other=None, thorough=False):
2398
2368
        packer = ReconcilePacker(collection, packs, extension, revs)
2399
2369
        return packer.pack(pb)
2400
2370
 
2401
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2402
2371
    def unlock(self):
2403
2372
        if self._write_lock_count == 1 and self._write_group is not None:
2404
2373
            self.abort_write_group()
2546
2515
        utf8_files = [('format', self.get_format_string())]
2547
2516
 
2548
2517
        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)
2551
 
        return repository
 
2518
        return self.open(a_bzrdir=a_bzrdir, _found=True)
2552
2519
 
2553
2520
    def open(self, a_bzrdir, _found=False, _override_transport=None):
2554
2521
        """See RepositoryFormat.open().
2603
2570
        """See RepositoryFormat.get_format_description()."""
2604
2571
        return "Packs containing knits without subtree support"
2605
2572
 
 
2573
    def check_conversion_target(self, target_format):
 
2574
        pass
 
2575
 
2606
2576
 
2607
2577
class RepositoryFormatKnitPack3(RepositoryFormatPack):
2608
2578
    """A subtrees parameterized Pack repository.
2617
2587
    repository_class = KnitPackRepository
2618
2588
    _commit_builder_class = PackRootCommitBuilder
2619
2589
    rich_root_data = True
2620
 
    experimental = True
2621
2590
    supports_tree_reference = True
2622
2591
    @property
2623
2592
    def _serializer(self):
2635
2604
 
2636
2605
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2637
2606
 
 
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)
 
2614
 
2638
2615
    def get_format_string(self):
2639
2616
        """See RepositoryFormat.get_format_string()."""
2640
2617
        return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2673
2650
 
2674
2651
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2675
2652
 
 
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)
 
2657
 
2676
2658
    def get_format_string(self):
2677
2659
        """See RepositoryFormat.get_format_string()."""
2678
2660
        return ("Bazaar pack repository format 1 with rich root"
2719
2701
        """See RepositoryFormat.get_format_description()."""
2720
2702
        return "Packs 5 (adds stacking support, requires bzr 1.6)"
2721
2703
 
 
2704
    def check_conversion_target(self, target_format):
 
2705
        pass
 
2706
 
2722
2707
 
2723
2708
class RepositoryFormatKnitPack5RichRoot(RepositoryFormatPack):
2724
2709
    """A repository with rich roots and stacking.
2751
2736
 
2752
2737
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2753
2738
 
 
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)
 
2743
 
2754
2744
    def get_format_string(self):
2755
2745
        """See RepositoryFormat.get_format_string()."""
2756
2746
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n"
2797
2787
 
2798
2788
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2799
2789
 
 
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)
 
2794
 
2800
2795
    def get_format_string(self):
2801
2796
        """See RepositoryFormat.get_format_string()."""
2802
2797
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n"
2840
2835
        """See RepositoryFormat.get_format_description()."""
2841
2836
        return "Packs 6 (uses btree indexes, requires bzr 1.9)"
2842
2837
 
 
2838
    def check_conversion_target(self, target_format):
 
2839
        pass
 
2840
 
2843
2841
 
2844
2842
class RepositoryFormatKnitPack6RichRoot(RepositoryFormatPack):
2845
2843
    """A repository with rich roots, no subtrees, stacking and btree indexes.
2869
2867
 
2870
2868
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2871
2869
 
 
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)
 
2874
 
2872
2875
    def get_format_string(self):
2873
2876
        """See RepositoryFormat.get_format_string()."""
2874
2877
        return "Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n"
2891
2894
    repository_class = KnitPackRepository
2892
2895
    _commit_builder_class = PackRootCommitBuilder
2893
2896
    rich_root_data = True
2894
 
    experimental = True
2895
2897
    supports_tree_reference = True
2896
2898
    supports_external_lookups = True
2897
2899
    # What index classes to use
2911
2913
 
2912
2914
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2913
2915
 
 
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)
 
2923
 
2914
2924
    def get_format_string(self):
2915
2925
        """See RepositoryFormat.get_format_string()."""
2916
2926
        return ("Bazaar development format 2 with subtree support "