/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/check.py

  • Committer: Michael Ellerman
  • Date: 2006-03-09 00:24:48 UTC
  • mto: (1610.1.8 bzr.mbp.integration)
  • mto: This revision was merged to the branch mainline in revision 1616.
  • Revision ID: michael@ellerman.id.au-20060309002448-70cce15e3d605130
Make the "ignore line" in the commit message editor the "right" width, so
that if you make your message that wide it won't wrap in bzr log output.
Just as a visual aid.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
 
1
# Copyright (C) 2004, 2005 by Martin Pool
 
2
# Copyright (C) 2005 by Canonical Ltd
 
3
 
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
 
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
 
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
# TODO: Check ancestries are correct for every revision: includes
 
19
# every committed so far, and in a reasonable order.
 
20
 
 
21
# TODO: Also check non-mainline revisions mentioned as parents.
 
22
 
 
23
# TODO: Check for extra files in the control directory.
 
24
 
 
25
# TODO: Check revision, inventory and entry objects have all 
 
26
# required fields.
 
27
 
 
28
# TODO: Get every revision in the revision-store even if they're not
 
29
# referenced by history and make sure they're all valid.
 
30
 
 
31
import bzrlib.ui
 
32
from bzrlib.trace import note, warning
 
33
from bzrlib.osutils import rename, sha_string, fingerprint_file
 
34
from bzrlib.trace import mutter
 
35
from bzrlib.errors import BzrCheckError, NoSuchRevision
 
36
from bzrlib.inventory import ROOT_ID
 
37
 
 
38
 
 
39
class Check(object):
 
40
    """Check a branch"""
 
41
 
 
42
    def __init__(self, branch):
 
43
        self.branch = branch
 
44
        self.repository = branch.repository
 
45
        self.checked_text_cnt = 0
 
46
        self.checked_rev_cnt = 0
 
47
        self.ghosts = []
 
48
        self.repeated_text_cnt = 0
 
49
        self.missing_parent_links = {}
 
50
        self.missing_inventory_sha_cnt = 0
 
51
        self.missing_revision_cnt = 0
 
52
        # maps (file-id, version) -> sha1
 
53
        self.checked_texts = {}
 
54
        self.checked_weaves = {}
 
55
 
 
56
    def check(self):
 
57
        self.branch.lock_read()
 
58
        self.progress = bzrlib.ui.ui_factory.progress_bar()
 
59
        try:
 
60
            self.progress.update('retrieving inventory', 0, 0)
 
61
            # do not put in init, as it should be done with progess,
 
62
            # and inside the lock.
 
63
            self.inventory_weave = self.branch.repository.get_inventory_weave()
 
64
            self.history = self.branch.revision_history()
 
65
            if not len(self.history):
 
66
                # nothing to see here
 
67
                return
 
68
            self.plan_revisions()
 
69
            revno = 0
 
70
            self.check_weaves()
 
71
            while revno < len(self.planned_revisions):
 
72
                rev_id = self.planned_revisions[revno]
 
73
                self.progress.update('checking revision', revno,
 
74
                                     len(self.planned_revisions))
 
75
                revno += 1
 
76
                self.check_one_rev(rev_id)
 
77
        finally:
 
78
            self.progress.clear()
 
79
            self.branch.unlock()
 
80
 
 
81
    def plan_revisions(self):
 
82
        repository = self.branch.repository
 
83
        if not repository.revision_store.listable():
 
84
            self.planned_revisions = repository.get_ancestry(self.history[-1])
 
85
            self.planned_revisions.remove(None)
 
86
            # FIXME progress bars should support this more nicely.
 
87
            self.progress.clear()
 
88
            print ("Checking reachable history -"
 
89
                   " for a complete check use a local branch.")
 
90
            return
 
91
        
 
92
        self.planned_revisions = set(repository.revision_store)
 
93
        inventoried = set(self.inventory_weave.names())
 
94
        awol = self.planned_revisions - inventoried
 
95
        if len(awol) > 0:
 
96
            raise BzrCheckError('Stored revisions missing from inventory'
 
97
                '{%s}' % ','.join([f for f in awol]))
 
98
        self.planned_revisions = list(self.planned_revisions)
 
99
 
 
100
    def report_results(self, verbose):
 
101
        note('checked branch %s format %s',
 
102
             self.branch.base, 
 
103
             self.branch._format)
 
104
 
 
105
        note('%6d revisions', self.checked_rev_cnt)
 
106
        note('%6d unique file texts', self.checked_text_cnt)
 
107
        note('%6d repeated file texts', self.repeated_text_cnt)
 
108
        note('%6d weaves', len(self.checked_weaves))
 
109
        if self.missing_inventory_sha_cnt:
 
110
            note('%6d revisions are missing inventory_sha1',
 
111
                 self.missing_inventory_sha_cnt)
 
112
        if self.missing_revision_cnt:
 
113
            note('%6d revisions are mentioned but not present',
 
114
                 self.missing_revision_cnt)
 
115
        if len(self.ghosts):
 
116
            note('%6d ghost revisions', len(self.ghosts))
 
117
            if verbose:
 
118
                for ghost in self.ghosts:
 
119
                    note('      %s', ghost)
 
120
        if len(self.missing_parent_links):
 
121
            note('%6d revisions missing parents in ancestry', 
 
122
                 len(self.missing_parent_links))
 
123
            if verbose:
 
124
                for link, linkers in self.missing_parent_links.items():
 
125
                    note('      %s should be in the ancestry for:', link)
 
126
                    for linker in linkers:
 
127
                        note('       * %s', linker)
 
128
 
 
129
    def check_one_rev(self, rev_id):
 
130
        """Check one revision.
 
131
 
 
132
        rev_id - the one to check
 
133
 
 
134
        last_rev_id - the previous one on the mainline, if any.
 
135
        """
 
136
 
 
137
        # mutter('    revision {%s}', rev_id)
 
138
        branch = self.branch
 
139
        try:
 
140
            rev_history_position = self.history.index(rev_id)
 
141
        except ValueError:
 
142
            rev_history_position = None
 
143
        last_rev_id = None
 
144
        if rev_history_position:
 
145
            rev = branch.repository.get_revision(rev_id)
 
146
            if rev_history_position > 0:
 
147
                last_rev_id = self.history[rev_history_position - 1]
 
148
        else:
 
149
            rev = branch.repository.get_revision(rev_id)
 
150
                
 
151
        if rev.revision_id != rev_id:
 
152
            raise BzrCheckError('wrong internal revision id in revision {%s}'
 
153
                                % rev_id)
 
154
 
 
155
        # check the previous history entry is a parent of this entry
 
156
        if rev.parent_ids:
 
157
            if last_rev_id is not None:
 
158
                for parent_id in rev.parent_ids:
 
159
                    if parent_id == last_rev_id:
 
160
                        break
 
161
                else:
 
162
                    raise BzrCheckError("previous revision {%s} not listed among "
 
163
                                        "parents of {%s}"
 
164
                                        % (last_rev_id, rev_id))
 
165
            for parent in rev.parent_ids:
 
166
                if not parent in self.planned_revisions:
 
167
                    missing_links = self.missing_parent_links.get(parent, [])
 
168
                    missing_links.append(rev_id)
 
169
                    self.missing_parent_links[parent] = missing_links
 
170
                    # list based so somewhat slow,
 
171
                    # TODO have a planned_revisions list and set.
 
172
                    if self.branch.repository.has_revision(parent):
 
173
                        missing_ancestry = self.repository.get_ancestry(parent)
 
174
                        for missing in missing_ancestry:
 
175
                            if (missing is not None 
 
176
                                and missing not in self.planned_revisions):
 
177
                                self.planned_revisions.append(missing)
 
178
                    else:
 
179
                        self.ghosts.append(rev_id)
 
180
        elif last_rev_id:
 
181
            raise BzrCheckError("revision {%s} has no parents listed "
 
182
                                "but preceded by {%s}"
 
183
                                % (rev_id, last_rev_id))
 
184
 
 
185
        if rev.inventory_sha1:
 
186
            inv_sha1 = branch.repository.get_inventory_sha1(rev_id)
 
187
            if inv_sha1 != rev.inventory_sha1:
 
188
                raise BzrCheckError('Inventory sha1 hash doesn\'t match'
 
189
                    ' value in revision {%s}' % rev_id)
 
190
        else:
 
191
            missing_inventory_sha_cnt += 1
 
192
            mutter("no inventory_sha1 on revision {%s}", rev_id)
 
193
        self._check_revision_tree(rev_id)
 
194
        self.checked_rev_cnt += 1
 
195
 
 
196
    def check_weaves(self):
 
197
        """Check all the weaves we can get our hands on.
 
198
        """
 
199
        n_weaves = 1
 
200
        weave_ids = []
 
201
        if self.branch.repository.weave_store.listable():
 
202
            weave_ids = list(self.branch.repository.weave_store)
 
203
            n_weaves = len(weave_ids)
 
204
        self.progress.update('checking weave', 0, n_weaves)
 
205
        self.inventory_weave.check(progress_bar=self.progress)
 
206
        for i, weave_id in enumerate(weave_ids):
 
207
            self.progress.update('checking weave', i, n_weaves)
 
208
            w = self.branch.repository.weave_store.get_weave(weave_id,
 
209
                    self.branch.repository.get_transaction())
 
210
            # No progress here, because it looks ugly.
 
211
            w.check()
 
212
            self.checked_weaves[weave_id] = True
 
213
 
 
214
    def _check_revision_tree(self, rev_id):
 
215
        tree = self.branch.repository.revision_tree(rev_id)
 
216
        inv = tree.inventory
 
217
        seen_ids = {}
 
218
        for file_id in inv:
 
219
            if file_id in seen_ids:
 
220
                raise BzrCheckError('duplicated file_id {%s} '
 
221
                                    'in inventory for revision {%s}'
 
222
                                    % (file_id, rev_id))
 
223
            seen_ids[file_id] = True
 
224
        for file_id in inv:
 
225
            ie = inv[file_id]
 
226
            ie.check(self, rev_id, inv, tree)
 
227
        seen_names = {}
 
228
        for path, ie in inv.iter_entries():
 
229
            if path in seen_names:
 
230
                raise BzrCheckError('duplicated path %s '
 
231
                                    'in inventory for revision {%s}'
 
232
                                    % (path, rev_id))
 
233
            seen_names[path] = True
 
234
 
 
235
 
 
236
def check(branch, verbose):
 
237
    """Run consistency checks on a branch."""
 
238
    checker = Check(branch)
 
239
    checker.check()
 
240
    checker.report_results(verbose)