/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

Store-escaping must quote uppercase characters too, so that they're safely 
stored on Windows.  We can't use urllib.quote anymore but must have our own 
version that can do this.  Test.

Make KnitRepository use escaped stores.

Update existing storage-escaping tests.

Show diffs side-by-side

added added

removed removed

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