/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: Vincent Ladeuil
  • Date: 2009-07-02 09:09:35 UTC
  • mto: (4536.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4537.
  • Revision ID: v.ladeuil+lp@free.fr-20090702090935-ya2kx3t8mz1tsf2k
ui.get_boolean can also use bool_from_string.

* bzrlib/ui/__init__.py:
(CLIUIFactory.get_boolean): Simplified by using bool_from_string.

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,
69
72
    CommitBuilder,
70
73
    MetaDirRepositoryFormat,
71
74
    RepositoryFormat,
72
 
    RepositoryWriteLockResult,
73
75
    RootCommitBuilder,
74
76
    StreamSource,
75
77
    )
 
78
import bzrlib.revision as _mod_revision
76
79
from bzrlib.trace import (
77
80
    mutter,
78
 
    note,
79
81
    warning,
80
82
    )
81
83
 
227
229
        return self.index_name('text', name)
228
230
 
229
231
    def _replace_index_with_readonly(self, index_type):
230
 
        unlimited_cache = False
231
 
        if index_type == 'chk':
232
 
            unlimited_cache = True
233
232
        setattr(self, index_type + '_index',
234
233
            self.index_class(self.index_transport,
235
234
                self.index_name(index_type, self.name),
236
 
                self.index_sizes[self.index_offset(index_type)],
237
 
                unlimited_cache=unlimited_cache))
 
235
                self.index_sizes[self.index_offset(index_type)]))
238
236
 
239
237
 
240
238
class ExistingPack(Pack):
429
427
        self._writer.begin()
430
428
        # what state is the pack in? (open, finished, aborted)
431
429
        self._state = 'open'
432
 
        # no name until we finish writing the content
433
 
        self.name = None
434
430
 
435
431
    def abort(self):
436
432
        """Cancel creating this pack."""
457
453
            self.signature_index.key_count() or
458
454
            (self.chk_index is not None and self.chk_index.key_count()))
459
455
 
460
 
    def finish_content(self):
461
 
        if self.name is not None:
462
 
            return
463
 
        self._writer.end()
464
 
        if self._buffer[1]:
465
 
            self._write_data('', flush=True)
466
 
        self.name = self._hash.hexdigest()
467
 
 
468
456
    def finish(self, suspend=False):
469
457
        """Finish the new pack.
470
458
 
476
464
         - stores the index size tuple for the pack in the index_sizes
477
465
           attribute.
478
466
        """
479
 
        self.finish_content()
 
467
        self._writer.end()
 
468
        if self._buffer[1]:
 
469
            self._write_data('', flush=True)
 
470
        self.name = self._hash.hexdigest()
480
471
        if not suspend:
481
472
            self._check_references()
482
473
        # write indices
588
579
                                             flush_func=flush_func)
589
580
        self.add_callback = None
590
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
 
591
602
    def add_index(self, index, pack):
592
603
        """Add index to the aggregate, which is an index for Pack pack.
593
604
 
600
611
        # expose it to the index map
601
612
        self.index_to_pack[index] = pack.access_tuple()
602
613
        # put it at the front of the linear index list
603
 
        self.combined_index.insert_index(0, index, pack.name)
 
614
        self.combined_index.insert_index(0, index)
604
615
 
605
616
    def add_writable_index(self, index, pack):
606
617
        """Add an index which is able to have data added to it.
626
637
        self.data_access.set_writer(None, None, (None, None))
627
638
        self.index_to_pack.clear()
628
639
        del self.combined_index._indices[:]
629
 
        del self.combined_index._index_names[:]
630
640
        self.add_callback = None
631
641
 
632
 
    def remove_index(self, index):
 
642
    def remove_index(self, index, pack):
633
643
        """Remove index from the indices used to answer queries.
634
644
 
635
645
        :param index: An index from the pack parameter.
 
646
        :param pack: A Pack instance.
636
647
        """
637
648
        del self.index_to_pack[index]
638
 
        pos = self.combined_index._indices.index(index)
639
 
        del self.combined_index._indices[pos]
640
 
        del self.combined_index._index_names[pos]
 
649
        self.combined_index._indices.remove(index)
641
650
        if (self.add_callback is not None and
642
651
            getattr(index, 'add_nodes', None) == self.add_callback):
643
652
            self.add_callback = None
1101
1110
            iterator is a tuple with:
1102
1111
            index, readv_vector, node_vector. readv_vector is a list ready to
1103
1112
            hand to the transport readv method, and node_vector is a list of
1104
 
            (key, eol_flag, references) for the node retrieved by the
 
1113
            (key, eol_flag, references) for the the node retrieved by the
1105
1114
            matching readv_vector.
1106
1115
        """
1107
1116
        # group by pack so we do one readv per pack
1399
1408
        self.inventory_index = AggregateIndex(self.reload_pack_names, flush)
1400
1409
        self.text_index = AggregateIndex(self.reload_pack_names, flush)
1401
1410
        self.signature_index = AggregateIndex(self.reload_pack_names, flush)
1402
 
        all_indices = [self.revision_index, self.inventory_index,
1403
 
                self.text_index, self.signature_index]
1404
1411
        if use_chk_index:
1405
1412
            self.chk_index = AggregateIndex(self.reload_pack_names, flush)
1406
 
            all_indices.append(self.chk_index)
1407
1413
        else:
1408
1414
            # used to determine if we're using a chk_index elsewhere.
1409
1415
            self.chk_index = None
1410
 
        # Tell all the CombinedGraphIndex objects about each other, so they can
1411
 
        # share hints about which pack names to search first.
1412
 
        all_combined = [agg_idx.combined_index for agg_idx in all_indices]
1413
 
        for combined_idx in all_combined:
1414
 
            combined_idx.set_sibling_indices(
1415
 
                set(all_combined).difference([combined_idx]))
1416
1416
        # resumed packs
1417
1417
        self._resumed_packs = []
1418
1418
 
1419
 
    def __repr__(self):
1420
 
        return '%s(%r)' % (self.__class__.__name__, self.repo)
1421
 
 
1422
1419
    def add_pack_to_memory(self, pack):
1423
1420
        """Make a Pack object available to the repository to satisfy queries.
1424
1421
 
1538
1535
                self._remove_pack_from_memory(pack)
1539
1536
        # record the newly available packs and stop advertising the old
1540
1537
        # packs
1541
 
        to_be_obsoleted = []
1542
 
        for _, packs in pack_operations:
1543
 
            to_be_obsoleted.extend(packs)
1544
 
        result = self._save_pack_names(clear_obsolete_packs=True,
1545
 
                                       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)
1546
1542
        return result
1547
1543
 
1548
1544
    def _flush_new_pack(self):
1561
1557
        """Is the collection already packed?"""
1562
1558
        return not (self.repo._format.pack_compresses or (len(self._names) > 1))
1563
1559
 
1564
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1560
    def pack(self, hint=None):
1565
1561
        """Pack the pack collection totally."""
1566
1562
        self.ensure_loaded()
1567
1563
        total_packs = len(self._names)
1576
1572
        # determine which packs need changing
1577
1573
        pack_operations = [[0, []]]
1578
1574
        for pack in self.all_packs():
1579
 
            if hint is None or pack.name in hint:
1580
 
                # Either no hint was provided (so we are packing everything),
1581
 
                # or this pack was included in the hint.
 
1575
            if not hint or pack.name in hint:
1582
1576
                pack_operations[-1][0] += pack.get_revision_count()
1583
1577
                pack_operations[-1][1].append(pack)
1584
1578
        self._execute_pack_operations(pack_operations, OptimisingPacker)
1585
1579
 
1586
 
        if clean_obsolete_packs:
1587
 
            self._clear_obsolete_packs()
1588
 
 
1589
1580
    def plan_autopack_combinations(self, existing_packs, pack_distribution):
1590
1581
        """Plan a pack operation.
1591
1582
 
1679
1670
            txt_index = self._make_index(name, '.tix')
1680
1671
            sig_index = self._make_index(name, '.six')
1681
1672
            if self.chk_index is not None:
1682
 
                chk_index = self._make_index(name, '.cix', unlimited_cache=True)
 
1673
                chk_index = self._make_index(name, '.cix')
1683
1674
            else:
1684
1675
                chk_index = None
1685
1676
            result = ExistingPack(self._pack_transport, name, rev_index,
1704
1695
            txt_index = self._make_index(name, '.tix', resume=True)
1705
1696
            sig_index = self._make_index(name, '.six', resume=True)
1706
1697
            if self.chk_index is not None:
1707
 
                chk_index = self._make_index(name, '.cix', resume=True,
1708
 
                                             unlimited_cache=True)
 
1698
                chk_index = self._make_index(name, '.cix', resume=True)
1709
1699
            else:
1710
1700
                chk_index = None
1711
1701
            result = self.resumed_pack_factory(name, rev_index, inv_index,
1741
1731
        return self._index_class(self.transport, 'pack-names', None
1742
1732
                ).iter_all_entries()
1743
1733
 
1744
 
    def _make_index(self, name, suffix, resume=False, unlimited_cache=False):
 
1734
    def _make_index(self, name, suffix, resume=False):
1745
1735
        size_offset = self._suffix_offsets[suffix]
1746
1736
        index_name = name + suffix
1747
1737
        if resume:
1750
1740
        else:
1751
1741
            transport = self._index_transport
1752
1742
            index_size = self._names[name][size_offset]
1753
 
        return self._index_class(transport, index_name, index_size,
1754
 
                                 unlimited_cache=unlimited_cache)
 
1743
        return self._index_class(transport, index_name, index_size)
1755
1744
 
1756
1745
    def _max_pack_count(self, total_revisions):
1757
1746
        """Return the maximum number of packs to use for total revisions.
1785
1774
        :param return: None.
1786
1775
        """
1787
1776
        for pack in packs:
1788
 
            try:
1789
 
                pack.pack_transport.rename(pack.file_name(),
1790
 
                    '../obsolete_packs/' + pack.file_name())
1791
 
            except (errors.PathError, errors.TransportError), e:
1792
 
                # TODO: Should these be warnings or mutters?
1793
 
                mutter("couldn't rename obsolete pack, skipping it:\n%s"
1794
 
                       % (e,))
 
1777
            pack.pack_transport.rename(pack.file_name(),
 
1778
                '../obsolete_packs/' + pack.file_name())
1795
1779
            # TODO: Probably needs to know all possible indices for this pack
1796
1780
            # - or maybe list the directory and move all indices matching this
1797
1781
            # name whether we recognize it or not?
1799
1783
            if self.chk_index is not None:
1800
1784
                suffixes.append('.cix')
1801
1785
            for suffix in suffixes:
1802
 
                try:
1803
 
                    self._index_transport.rename(pack.name + suffix,
1804
 
                        '../obsolete_packs/' + pack.name + suffix)
1805
 
                except (errors.PathError, errors.TransportError), e:
1806
 
                    mutter("couldn't rename obsolete index, skipping it:\n%s"
1807
 
                           % (e,))
 
1786
                self._index_transport.rename(pack.name + suffix,
 
1787
                    '../obsolete_packs/' + pack.name + suffix)
1808
1788
 
1809
1789
    def pack_distribution(self, total_revisions):
1810
1790
        """Generate a list of the number of revisions to put in each pack.
1836
1816
        self._remove_pack_indices(pack)
1837
1817
        self.packs.remove(pack)
1838
1818
 
1839
 
    def _remove_pack_indices(self, pack, ignore_missing=False):
1840
 
        """Remove the indices for pack from the aggregated indices.
1841
 
        
1842
 
        :param ignore_missing: Suppress KeyErrors from calling remove_index.
1843
 
        """
1844
 
        for index_type in Pack.index_definitions.keys():
1845
 
            attr_name = index_type + '_index'
1846
 
            aggregate_index = getattr(self, attr_name)
1847
 
            if aggregate_index is not None:
1848
 
                pack_index = getattr(pack, attr_name)
1849
 
                try:
1850
 
                    aggregate_index.remove_index(pack_index)
1851
 
                except KeyError:
1852
 
                    if ignore_missing:
1853
 
                        continue
1854
 
                    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)
1855
1827
 
1856
1828
    def reset(self):
1857
1829
        """Clear all cached data."""
1890
1862
        disk_nodes = set()
1891
1863
        for index, key, value in self._iter_disk_pack_index():
1892
1864
            disk_nodes.add((key, value))
1893
 
        orig_disk_nodes = set(disk_nodes)
1894
1865
 
1895
1866
        # do a two-way diff against our original content
1896
1867
        current_nodes = set()
1909
1880
        disk_nodes.difference_update(deleted_nodes)
1910
1881
        disk_nodes.update(new_nodes)
1911
1882
 
1912
 
        return disk_nodes, deleted_nodes, new_nodes, orig_disk_nodes
 
1883
        return disk_nodes, deleted_nodes, new_nodes
1913
1884
 
1914
1885
    def _syncronize_pack_names_from_disk_nodes(self, disk_nodes):
1915
1886
        """Given the correct set of pack files, update our saved info.
1955
1926
                added.append(name)
1956
1927
        return removed, added, modified
1957
1928
 
1958
 
    def _save_pack_names(self, clear_obsolete_packs=False, obsolete_packs=None):
 
1929
    def _save_pack_names(self, clear_obsolete_packs=False):
1959
1930
        """Save the list of packs.
1960
1931
 
1961
1932
        This will take out the mutex around the pack names list for the
1965
1936
 
1966
1937
        :param clear_obsolete_packs: If True, clear out the contents of the
1967
1938
            obsolete_packs directory.
1968
 
        :param obsolete_packs: Packs that are obsolete once the new pack-names
1969
 
            file has been written.
1970
1939
        :return: A list of the names saved that were not previously on disk.
1971
1940
        """
1972
 
        already_obsolete = []
1973
1941
        self.lock_names()
1974
1942
        try:
1975
1943
            builder = self._index_builder_class()
1976
 
            (disk_nodes, deleted_nodes, new_nodes,
1977
 
             orig_disk_nodes) = self._diff_pack_names()
 
1944
            disk_nodes, deleted_nodes, new_nodes = self._diff_pack_names()
1978
1945
            # TODO: handle same-name, index-size-changes here -
1979
1946
            # e.g. use the value from disk, not ours, *unless* we're the one
1980
1947
            # changing it.
1982
1949
                builder.add_node(key, value)
1983
1950
            self.transport.put_file('pack-names', builder.finish(),
1984
1951
                mode=self.repo.bzrdir._get_file_mode())
 
1952
            # move the baseline forward
1985
1953
            self._packs_at_load = disk_nodes
1986
1954
            if clear_obsolete_packs:
1987
 
                to_preserve = None
1988
 
                if obsolete_packs:
1989
 
                    to_preserve = set([o.name for o in obsolete_packs])
1990
 
                already_obsolete = self._clear_obsolete_packs(to_preserve)
 
1955
                self._clear_obsolete_packs()
1991
1956
        finally:
1992
1957
            self._unlock_names()
1993
1958
        # synchronise the memory packs list with what we just wrote:
1994
1959
        self._syncronize_pack_names_from_disk_nodes(disk_nodes)
1995
 
        if obsolete_packs:
1996
 
            # TODO: We could add one more condition here. "if o.name not in
1997
 
            #       orig_disk_nodes and o != the new_pack we haven't written to
1998
 
            #       disk yet. However, the new pack object is not easily
1999
 
            #       accessible here (it would have to be passed through the
2000
 
            #       autopacking code, etc.)
2001
 
            obsolete_packs = [o for o in obsolete_packs
2002
 
                              if o.name not in already_obsolete]
2003
 
            self._obsolete_packs(obsolete_packs)
2004
1960
        return [new_node[0][0] for new_node in new_nodes]
2005
1961
 
2006
1962
    def reload_pack_names(self):
2021
1977
        if first_read:
2022
1978
            return True
2023
1979
        # out the new value.
2024
 
        (disk_nodes, deleted_nodes, new_nodes,
2025
 
         orig_disk_nodes) = self._diff_pack_names()
2026
 
        # _packs_at_load is meant to be the explicit list of names in
2027
 
        # 'pack-names' at then start. As such, it should not contain any
2028
 
        # pending names that haven't been written out yet.
2029
 
        self._packs_at_load = orig_disk_nodes
 
1980
        disk_nodes, _, _ = self._diff_pack_names()
 
1981
        self._packs_at_load = disk_nodes
2030
1982
        (removed, added,
2031
1983
         modified) = self._syncronize_pack_names_from_disk_nodes(disk_nodes)
2032
1984
        if removed or added or modified:
2041
1993
            raise
2042
1994
        raise errors.RetryAutopack(self.repo, False, sys.exc_info())
2043
1995
 
2044
 
    def _clear_obsolete_packs(self, preserve=None):
 
1996
    def _clear_obsolete_packs(self):
2045
1997
        """Delete everything from the obsolete-packs directory.
2046
 
 
2047
 
        :return: A list of pack identifiers (the filename without '.pack') that
2048
 
            were found in obsolete_packs.
2049
1998
        """
2050
 
        found = []
2051
1999
        obsolete_pack_transport = self.transport.clone('obsolete_packs')
2052
 
        if preserve is None:
2053
 
            preserve = set()
2054
2000
        for filename in obsolete_pack_transport.list_dir('.'):
2055
 
            name, ext = osutils.splitext(filename)
2056
 
            if ext == '.pack':
2057
 
                found.append(name)
2058
 
            if name in preserve:
2059
 
                continue
2060
2001
            try:
2061
2002
                obsolete_pack_transport.delete(filename)
2062
2003
            except (errors.PathError, errors.TransportError), e:
2063
 
                warning("couldn't delete obsolete pack, skipping it:\n%s"
2064
 
                        % (e,))
2065
 
        return found
 
2004
                warning("couldn't delete obsolete pack, skipping it:\n%s" % (e,))
2066
2005
 
2067
2006
    def _start_write_group(self):
2068
2007
        # Do not permit preparation for writing if we're not in a 'write lock'.
2095
2034
        # FIXME: just drop the transient index.
2096
2035
        # forget what names there are
2097
2036
        if self._new_pack is not None:
2098
 
            operation = cleanup.OperationWithCleanups(self._new_pack.abort)
2099
 
            operation.add_cleanup(setattr, self, '_new_pack', None)
2100
 
            # If we aborted while in the middle of finishing the write
2101
 
            # group, _remove_pack_indices could fail because the indexes are
2102
 
            # already gone.  But they're not there we shouldn't fail in this
2103
 
            # case, so we pass ignore_missing=True.
2104
 
            operation.add_cleanup(self._remove_pack_indices, self._new_pack,
2105
 
                ignore_missing=True)
2106
 
            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
2107
2046
        for resumed_pack in self._resumed_packs:
2108
 
            operation = cleanup.OperationWithCleanups(resumed_pack.abort)
2109
 
            # See comment in previous finally block.
2110
 
            operation.add_cleanup(self._remove_pack_indices, resumed_pack,
2111
 
                ignore_missing=True)
2112
 
            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
2113
2055
        del self._resumed_packs[:]
2114
2056
 
2115
2057
    def _remove_resumed_pack_indices(self):
2117
2059
            self._remove_pack_indices(resumed_pack)
2118
2060
        del self._resumed_packs[:]
2119
2061
 
2120
 
    def _check_new_inventories(self):
2121
 
        """Detect missing inventories in this write group.
2122
 
 
2123
 
        :returns: list of strs, summarising any problems found.  If the list is
2124
 
            empty no problems were found.
2125
 
        """
2126
 
        # The base implementation does no checks.  GCRepositoryPackCollection
2127
 
        # overrides this.
2128
 
        return []
2129
 
        
2130
2062
    def _commit_write_group(self):
2131
2063
        all_missing = set()
2132
2064
        for prefix, versioned_file in (
2141
2073
            raise errors.BzrCheckError(
2142
2074
                "Repository %s has missing compression parent(s) %r "
2143
2075
                 % (self.repo, sorted(all_missing)))
2144
 
        problems = self._check_new_inventories()
2145
 
        if problems:
2146
 
            problems_summary = '\n'.join(problems)
2147
 
            raise errors.BzrCheckError(
2148
 
                "Cannot add revision(s) to repository: " + problems_summary)
2149
2076
        self._remove_pack_indices(self._new_pack)
2150
 
        any_new_content = False
 
2077
        should_autopack = False
2151
2078
        if self._new_pack.data_inserted():
2152
2079
            # get all the data to disk and read to use
2153
2080
            self._new_pack.finish()
2154
2081
            self.allocate(self._new_pack)
2155
2082
            self._new_pack = None
2156
 
            any_new_content = True
 
2083
            should_autopack = True
2157
2084
        else:
2158
2085
            self._new_pack.abort()
2159
2086
            self._new_pack = None
2164
2091
            self._remove_pack_from_memory(resumed_pack)
2165
2092
            resumed_pack.finish()
2166
2093
            self.allocate(resumed_pack)
2167
 
            any_new_content = True
 
2094
            should_autopack = True
2168
2095
        del self._resumed_packs[:]
2169
 
        if any_new_content:
2170
 
            result = self.autopack()
2171
 
            if not result:
 
2096
        if should_autopack:
 
2097
            if not self.autopack():
2172
2098
                # when autopack takes no steps, the names list is still
2173
2099
                # unsaved.
2174
2100
                return self._save_pack_names()
2175
 
            return result
2176
 
        return []
2177
2101
 
2178
2102
    def _suspend_write_group(self):
2179
2103
        tokens = [pack.name for pack in self._resumed_packs]
2281
2205
        self._reconcile_fixes_text_parents = True
2282
2206
        self._reconcile_backsup_inventory = False
2283
2207
 
2284
 
    def _warn_if_deprecated(self, branch=None):
 
2208
    def _warn_if_deprecated(self):
2285
2209
        # This class isn't deprecated, but one sub-format is
2286
2210
        if isinstance(self._format, RepositoryFormatKnitPack5RichRootBroken):
2287
 
            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))
2288
2218
 
2289
2219
    def _abort_write_group(self):
2290
 
        self.revisions._index._key_dependencies.clear()
 
2220
        self.revisions._index._key_dependencies.refs.clear()
2291
2221
        self._pack_collection._abort_write_group()
2292
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
 
2293
2269
    def _get_source(self, to_format):
2294
2270
        if to_format.network_name() == self._format.network_name():
2295
2271
            return KnitPackStreamSource(self, to_format)
2307
2283
        self._pack_collection._start_write_group()
2308
2284
 
2309
2285
    def _commit_write_group(self):
2310
 
        hint = self._pack_collection._commit_write_group()
2311
 
        self.revisions._index._key_dependencies.clear()
2312
 
        return hint
 
2286
        self.revisions._index._key_dependencies.refs.clear()
 
2287
        return self._pack_collection._commit_write_group()
2313
2288
 
2314
2289
    def suspend_write_group(self):
2315
2290
        # XXX check self._write_group is self.get_transaction()?
2316
2291
        tokens = self._pack_collection._suspend_write_group()
2317
 
        self.revisions._index._key_dependencies.clear()
 
2292
        self.revisions._index._key_dependencies.refs.clear()
2318
2293
        self._write_group = None
2319
2294
        return tokens
2320
2295
 
2348
2323
        if self._write_lock_count == 1:
2349
2324
            self._transaction = transactions.WriteTransaction()
2350
2325
        if not locked:
2351
 
            if 'relock' in debug.debug_flags and self._prev_lock == 'w':
2352
 
                note('%r was write locked again', self)
2353
 
            self._prev_lock = 'w'
2354
2326
            for repo in self._fallback_repositories:
2355
2327
                # Writes don't affect fallback repos
2356
2328
                repo.lock_read()
2357
2329
            self._refresh_data()
2358
 
        return RepositoryWriteLockResult(self.unlock, None)
2359
2330
 
2360
2331
    def lock_read(self):
2361
2332
        locked = self.is_locked()
2364
2335
        else:
2365
2336
            self.control_files.lock_read()
2366
2337
        if not locked:
2367
 
            if 'relock' in debug.debug_flags and self._prev_lock == 'r':
2368
 
                note('%r was read locked again', self)
2369
 
            self._prev_lock = 'r'
2370
2338
            for repo in self._fallback_repositories:
2371
2339
                repo.lock_read()
2372
2340
            self._refresh_data()
2373
 
        return self
2374
2341
 
2375
2342
    def leave_lock_in_place(self):
2376
2343
        # not supported - raise an error
2381
2348
        raise NotImplementedError(self.dont_leave_lock_in_place)
2382
2349
 
2383
2350
    @needs_write_lock
2384
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2351
    def pack(self, hint=None):
2385
2352
        """Compress the data within the repository.
2386
2353
 
2387
2354
        This will pack all the data to a single pack. In future it may
2388
2355
        recompress deltas or do other such expensive operations.
2389
2356
        """
2390
 
        self._pack_collection.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
2357
        self._pack_collection.pack(hint=hint)
2391
2358
 
2392
2359
    @needs_write_lock
2393
2360
    def reconcile(self, other=None, thorough=False):
2401
2368
        packer = ReconcilePacker(collection, packs, extension, revs)
2402
2369
        return packer.pack(pb)
2403
2370
 
2404
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2405
2371
    def unlock(self):
2406
2372
        if self._write_lock_count == 1 and self._write_group is not None:
2407
2373
            self.abort_write_group()
2549
2515
        utf8_files = [('format', self.get_format_string())]
2550
2516
 
2551
2517
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
2552
 
        repository = self.open(a_bzrdir=a_bzrdir, _found=True)
2553
 
        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
2554
 
        return repository
 
2518
        return self.open(a_bzrdir=a_bzrdir, _found=True)
2555
2519
 
2556
2520
    def open(self, a_bzrdir, _found=False, _override_transport=None):
2557
2521
        """See RepositoryFormat.open().
2606
2570
        """See RepositoryFormat.get_format_description()."""
2607
2571
        return "Packs containing knits without subtree support"
2608
2572
 
 
2573
    def check_conversion_target(self, target_format):
 
2574
        pass
 
2575
 
2609
2576
 
2610
2577
class RepositoryFormatKnitPack3(RepositoryFormatPack):
2611
2578
    """A subtrees parameterized Pack repository.
2620
2587
    repository_class = KnitPackRepository
2621
2588
    _commit_builder_class = PackRootCommitBuilder
2622
2589
    rich_root_data = True
2623
 
    experimental = True
2624
2590
    supports_tree_reference = True
2625
2591
    @property
2626
2592
    def _serializer(self):
2638
2604
 
2639
2605
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2640
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
 
2641
2615
    def get_format_string(self):
2642
2616
        """See RepositoryFormat.get_format_string()."""
2643
2617
        return "Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n"
2676
2650
 
2677
2651
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2678
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
 
2679
2658
    def get_format_string(self):
2680
2659
        """See RepositoryFormat.get_format_string()."""
2681
2660
        return ("Bazaar pack repository format 1 with rich root"
2722
2701
        """See RepositoryFormat.get_format_description()."""
2723
2702
        return "Packs 5 (adds stacking support, requires bzr 1.6)"
2724
2703
 
 
2704
    def check_conversion_target(self, target_format):
 
2705
        pass
 
2706
 
2725
2707
 
2726
2708
class RepositoryFormatKnitPack5RichRoot(RepositoryFormatPack):
2727
2709
    """A repository with rich roots and stacking.
2754
2736
 
2755
2737
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2756
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
 
2757
2744
    def get_format_string(self):
2758
2745
        """See RepositoryFormat.get_format_string()."""
2759
2746
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n"
2800
2787
 
2801
2788
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2802
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
 
2803
2795
    def get_format_string(self):
2804
2796
        """See RepositoryFormat.get_format_string()."""
2805
2797
        return "Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n"
2843
2835
        """See RepositoryFormat.get_format_description()."""
2844
2836
        return "Packs 6 (uses btree indexes, requires bzr 1.9)"
2845
2837
 
 
2838
    def check_conversion_target(self, target_format):
 
2839
        pass
 
2840
 
2846
2841
 
2847
2842
class RepositoryFormatKnitPack6RichRoot(RepositoryFormatPack):
2848
2843
    """A repository with rich roots, no subtrees, stacking and btree indexes.
2872
2867
 
2873
2868
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2874
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
 
2875
2875
    def get_format_string(self):
2876
2876
        """See RepositoryFormat.get_format_string()."""
2877
2877
        return "Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n"
2894
2894
    repository_class = KnitPackRepository
2895
2895
    _commit_builder_class = PackRootCommitBuilder
2896
2896
    rich_root_data = True
2897
 
    experimental = True
2898
2897
    supports_tree_reference = True
2899
2898
    supports_external_lookups = True
2900
2899
    # What index classes to use
2914
2913
 
2915
2914
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
2916
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
 
2917
2924
    def get_format_string(self):
2918
2925
        """See RepositoryFormat.get_format_string()."""
2919
2926
        return ("Bazaar development format 2 with subtree support "