← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

[merge] jelmer

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
1
 
#! /usr/bin/python
2
 
 
3
 
 
4
1
# Copyright (C) 2004, 2005 by Martin Pool
5
2
# Copyright (C) 2005 by Canonical Ltd
6
3
 
7
 
 
8
4
# This program is free software; you can redistribute it and/or modify
9
5
# it under the terms of the GNU General Public License as published by
10
6
# the Free Software Foundation; either version 2 of the License, or
19
15
# along with this program; if not, write to the Free Software
20
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
17
 
22
 
 
23
 
 
24
 
######################################################################
25
 
# consistency checks
26
 
 
27
 
def check():
28
 
    """Consistency check of tree."""
29
 
    assert_in_tree()
30
 
    mutter("checking tree")
31
 
    check_patches_exist()
32
 
    check_patch_chaining()
33
 
    check_patch_uniqueness()
34
 
    check_inventory()
35
 
    mutter("tree looks OK")
36
 
    ## TODO: Check that previous-inventory and previous-manifest
37
 
    ## are the same as those stored in the previous changeset.
38
 
 
39
 
    ## TODO: Check all patches present in patch directory are
40
 
    ## mentioned in patch history; having an orphaned patch only gives
41
 
    ## a warning.
42
 
 
43
 
    ## TODO: Check cached data is consistent with data reconstructed
44
 
    ## from scratch.
45
 
 
46
 
    ## TODO: Check no control files are versioned.
47
 
 
48
 
    ## TODO: Check that the before-hash of each file in a later
49
 
    ## revision matches the after-hash in the previous revision to
50
 
    ## touch it.
51
 
 
52
 
 
53
 
def check_inventory():
54
 
    mutter("checking inventory file and ids...")
55
 
    seen_ids = Set()
56
 
    seen_names = Set()
 
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
from bzrlib.branch import gen_root_id
 
38
 
 
39
 
 
40
class Check(object):
 
41
    """Check a branch"""
 
42
 
 
43
    def __init__(self, branch):
 
44
        self.branch = branch
 
45
        self.inventory_weave = branch._get_inventory_weave()
 
46
        self.checked_text_cnt = 0
 
47
        self.checked_rev_cnt = 0
 
48
        self.ghosts = []
 
49
        self.repeated_text_cnt = 0
 
50
        self.missing_parent_links = {}
 
51
        self.missing_inventory_sha_cnt = 0
 
52
        self.missing_revision_cnt = 0
 
53
        # maps (file-id, version) -> sha1
 
54
        self.checked_texts = {}
 
55
 
 
56
    def check(self):
 
57
        self.branch.lock_read()
 
58
        self.progress = bzrlib.ui.ui_factory.progress_bar()
 
59
        try:
 
60
            self.history = self.branch.revision_history()
 
61
            if not len(self.history):
 
62
                # nothing to see here
 
63
                return
 
64
            if not self.branch.revision_store.listable():
 
65
                raise BzrCheckError("Branch must be local")
 
66
            self.planned_revisions = set(self.branch.revision_store)
 
67
            inventoried = set(self.inventory_weave.names())
 
68
            awol = self.planned_revisions - inventoried
 
69
            if len(awol) > 0:
 
70
                raise BzrCheckError('Stored revisions missing from inventory'
 
71
                    '{%s}' % ','.join([f for f in awol]))
57
72
    
58
 
    for l in controlfile('inventory').readlines():
59
 
        parts = l.split()
60
 
        if len(parts) != 2:
61
 
            bailout("malformed inventory line: " + `l`)
62
 
        file_id, name = parts
63
 
        
64
 
        if file_id in seen_ids:
65
 
            bailout("duplicated file id " + file_id)
66
 
        seen_ids.add(file_id)
67
 
 
68
 
        if name in seen_names:
69
 
            bailout("duplicated file name in inventory: " + quotefn(name))
70
 
        seen_names.add(name)
71
 
        
72
 
        if is_control_file(name):
73
 
            raise BzrError("control file %s present in inventory" % quotefn(name))
74
 
 
75
 
 
76
 
def check_patches_exist():
77
 
    """Check constraint of current version: all patches exist"""
78
 
    mutter("checking all patches are present...")
79
 
    for pid in revision_history():
80
 
        read_patch_header(pid)
81
 
 
82
 
 
83
 
def check_patch_chaining():
84
 
    """Check ancestry of patches and history file is consistent"""
85
 
    mutter("checking patch chaining...")
86
 
    prev = None
87
 
    for pid in revision_history():
88
 
        log_prev = read_patch_header(pid).precursor
89
 
        if log_prev != prev:
90
 
            bailout("inconsistent precursor links on " + pid)
91
 
        prev = pid
92
 
 
93
 
 
94
 
def check_patch_uniqueness():
95
 
    """Make sure no patch is listed twice in the history.
96
 
 
97
 
    This should be implied by having correct ancestry but I'll check it
98
 
    anyhow."""
99
 
    mutter("checking history for duplicates...")
100
 
    seen = Set()
101
 
    for pid in revision_history():
102
 
        if pid in seen:
103
 
            bailout("patch " + pid + " appears twice in history")
104
 
        seen.add(pid)
105
 
        
106
 
 
 
73
            for revno, rev_id in enumerate(self.planned_revisions):
 
74
                self.progress.update('checking revision', revno+1,
 
75
                                     len(self.planned_revisions))
 
76
                self.check_one_rev(rev_id)
 
77
        finally:
 
78
            self.progress.clear()
 
79
            self.branch.unlock()
 
80
 
 
81
    def report_results(self, verbose):
 
82
        note('checked branch %s format %d',
 
83
             self.branch.base, 
 
84
             self.branch._branch_format)
 
85
 
 
86
        note('%6d revisions', self.checked_rev_cnt)
 
87
        note('%6d unique file texts', self.checked_text_cnt)
 
88
        note('%6d repeated file texts', self.repeated_text_cnt)
 
89
        if self.missing_inventory_sha_cnt:
 
90
            note('%6d revisions are missing inventory_sha1',
 
91
                 self.missing_inventory_sha_cnt)
 
92
        if self.missing_revision_cnt:
 
93
            note('%6d revisions are mentioned but not present',
 
94
                 self.missing_revision_cnt)
 
95
        if len(self.ghosts):
 
96
            note('%6d ghost revisions', len(self.ghosts))
 
97
            if verbose:
 
98
                for ghost in self.ghosts:
 
99
                    note('      %s', ghost)
 
100
        if len(self.missing_parent_links):
 
101
            note('%6d revisions missing parents in ancestry', 
 
102
                 len(self.missing_parent_links))
 
103
            if verbose:
 
104
                for link, linkers in self.missing_parent_links.items():
 
105
                    note('      %s should be in the ancestry for:', link)
 
106
                    for linker in linkers:
 
107
                        note('       * %s', linker)
 
108
 
 
109
    def check_one_rev(self, rev_id):
 
110
        """Check one revision.
 
111
 
 
112
        rev_id - the one to check
 
113
 
 
114
        last_rev_id - the previous one on the mainline, if any.
 
115
        """
 
116
 
 
117
        # mutter('    revision {%s}', rev_id)
 
118
        branch = self.branch
 
119
        try:
 
120
            rev_history_position = self.history.index(rev_id)
 
121
        except ValueError:
 
122
            rev_history_position = None
 
123
        last_rev_id = None
 
124
        if rev_history_position:
 
125
            rev = branch.get_revision(rev_id)
 
126
            if rev_history_position > 0:
 
127
                last_rev_id = self.history[rev_history_position - 1]
 
128
        else:
 
129
            rev = branch.get_revision(rev_id)
 
130
                
 
131
        if rev.revision_id != rev_id:
 
132
            raise BzrCheckError('wrong internal revision id in revision {%s}'
 
133
                                % rev_id)
 
134
 
 
135
        # check the previous history entry is a parent of this entry
 
136
        if rev.parent_ids:
 
137
            if last_rev_id is not None:
 
138
                for parent_id in rev.parent_ids:
 
139
                    if parent_id == last_rev_id:
 
140
                        break
 
141
                else:
 
142
                    raise BzrCheckError("previous revision {%s} not listed among "
 
143
                                        "parents of {%s}"
 
144
                                        % (last_rev_id, rev_id))
 
145
            for parent in rev.parent_ids:
 
146
                if not parent in self.planned_revisions:
 
147
                    missing_links = self.missing_parent_links.get(parent, [])
 
148
                    missing_links.append(rev_id)
 
149
                    self.missing_parent_links[parent] = missing_links
 
150
                    # list based so slow, TODO have a planned_revisions list and set.
 
151
                    if self.branch.has_revision(parent):
 
152
                        missing_ancestry = self.branch.get_ancestry(parent)
 
153
                        for missing in missing_ancestry:
 
154
                            if (missing is not None 
 
155
                                and missing not in self.planned_revisions):
 
156
                                self.planned_revisions.append(missing)
 
157
                    else:
 
158
                        self.ghosts.append(rev_id)
 
159
        elif last_rev_id:
 
160
            raise BzrCheckError("revision {%s} has no parents listed "
 
161
                                "but preceded by {%s}"
 
162
                                % (rev_id, last_rev_id))
 
163
 
 
164
        if rev.inventory_sha1:
 
165
            inv_sha1 = branch.get_inventory_sha1(rev_id)
 
166
            if inv_sha1 != rev.inventory_sha1:
 
167
                raise BzrCheckError('Inventory sha1 hash doesn\'t match'
 
168
                    ' value in revision {%s}' % rev_id)
 
169
        else:
 
170
            missing_inventory_sha_cnt += 1
 
171
            mutter("no inventory_sha1 on revision {%s}", rev_id)
 
172
        self._check_revision_tree(rev_id)
 
173
        self.checked_rev_cnt += 1
 
174
 
 
175
    def _check_revision_tree(self, rev_id):
 
176
        tree = self.branch.revision_tree(rev_id)
 
177
        inv = tree.inventory
 
178
        seen_ids = {}
 
179
        for file_id in inv:
 
180
            if file_id in seen_ids:
 
181
                raise BzrCheckError('duplicated file_id {%s} '
 
182
                                    'in inventory for revision {%s}'
 
183
                                    % (file_id, rev_id))
 
184
            seen_ids[file_id] = True
 
185
        for file_id in inv:
 
186
            ie = inv[file_id]
 
187
            ie.check(self, rev_id, inv, tree)
 
188
        seen_names = {}
 
189
        for path, ie in inv.iter_entries():
 
190
            if path in seen_names:
 
191
                raise BzrCheckError('duplicated path %s '
 
192
                                    'in inventory for revision {%s}'
 
193
                                    % (path, rev_id))
 
194
            seen_names[path] = True
 
195
 
 
196
 
 
197
def check(branch, verbose):
 
198
    """Run consistency checks on a branch."""
 
199
    checker = Check(branch)
 
200
    checker.check()
 
201
    checker.report_results(verbose)