← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: Martin Pool
  • Date: 2006-01-13 06:31:42 UTC
  • Revision ID: mbp@sourcefrog.net-20060113063142-8e706dc1483c69e1
Bump version to 0.8pre

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
25
25
# TODO: Check revision, inventory and entry objects have all 
26
26
# required fields.
27
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.
28
30
 
29
31
import bzrlib.ui
30
32
from bzrlib.trace import note, warning
32
34
from bzrlib.trace import mutter
33
35
from bzrlib.errors import BzrCheckError, NoSuchRevision
34
36
from bzrlib.inventory import ROOT_ID
35
 
from bzrlib.branch import gen_root_id
36
37
 
37
38
 
38
39
class Check(object):
39
40
    """Check a branch"""
 
41
 
40
42
    def __init__(self, branch):
41
43
        self.branch = branch
42
 
        branch.lock_read()
43
 
        try:
44
 
            branch.weave_store.enable_cache = True
45
 
            branch.control_weaves.enable_cache = True
46
 
            self.run()
47
 
        finally:
48
 
            branch.unlock()
49
 
            branch.weave_store.enable_cache = False
50
 
            branch.control_weaves.enable_cache = False
51
 
 
52
 
 
53
 
    def run(self):
54
 
        branch = self.branch
55
 
 
56
 
 
57
44
        self.checked_text_cnt = 0
58
45
        self.checked_rev_cnt = 0
 
46
        self.ghosts = []
59
47
        self.repeated_text_cnt = 0
 
48
        self.missing_parent_links = {}
60
49
        self.missing_inventory_sha_cnt = 0
61
50
        self.missing_revision_cnt = 0
62
51
        # maps (file-id, version) -> sha1
63
52
        self.checked_texts = {}
64
 
 
65
 
        history = branch.revision_history()
66
 
        revno = 0
67
 
        revcount = len(history)
68
 
 
69
 
        last_rev_id = None
 
53
        self.checked_weaves = {}
 
54
 
 
55
    def check(self):
 
56
        self.branch.lock_read()
70
57
        self.progress = bzrlib.ui.ui_factory.progress_bar()
71
 
        for rev_id in history:
72
 
            self.progress.update('checking revision', revno, revcount)
73
 
            revno += 1
74
 
            self.check_one_rev(rev_id, last_rev_id)
75
 
            last_rev_id = rev_id
76
 
        self.progress.clear()
77
 
        self.report_results()
78
 
 
79
 
 
80
 
    def report_results(self):
 
58
        try:
 
59
            self.progress.update('retrieving inventory', 0, 0)
 
60
            # do not put in init, as it should be done with progess,
 
61
            # and inside the lock.
 
62
            self.inventory_weave = self.branch._get_inventory_weave()
 
63
            self.history = self.branch.revision_history()
 
64
            if not len(self.history):
 
65
                # nothing to see here
 
66
                return
 
67
            self.plan_revisions()
 
68
            revno = 0
 
69
            self.check_weaves()
 
70
            while revno < len(self.planned_revisions):
 
71
                rev_id = self.planned_revisions[revno]
 
72
                self.progress.update('checking revision', revno,
 
73
                                     len(self.planned_revisions))
 
74
                revno += 1
 
75
                self.check_one_rev(rev_id)
 
76
        finally:
 
77
            self.progress.clear()
 
78
            self.branch.unlock()
 
79
 
 
80
    def plan_revisions(self):
 
81
        if not self.branch.revision_store.listable():
 
82
            self.planned_revisions = self.branch.get_ancestry(self.history[-1])
 
83
            self.planned_revisions.remove(None)
 
84
            # FIXME progress bars should support this more nicely.
 
85
            self.progress.clear()
 
86
            print ("Checking reachable history -"
 
87
                   " for a complete check use a local branch.")
 
88
            return
 
89
        
 
90
        self.planned_revisions = set(self.branch.revision_store)
 
91
        inventoried = set(self.inventory_weave.names())
 
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):
81
99
        note('checked branch %s format %d',
82
100
             self.branch.base, 
83
101
             self.branch._branch_format)
85
103
        note('%6d revisions', self.checked_rev_cnt)
86
104
        note('%6d unique file texts', self.checked_text_cnt)
87
105
        note('%6d repeated file texts', self.repeated_text_cnt)
 
106
        note('%6d weaves', len(self.checked_weaves))
88
107
        if self.missing_inventory_sha_cnt:
89
 
            note('%d revisions are missing inventory_sha1',
 
108
            note('%6d revisions are missing inventory_sha1',
90
109
                 self.missing_inventory_sha_cnt)
91
110
        if self.missing_revision_cnt:
92
 
            note('%d revisions are mentioned but not present',
 
111
            note('%6d revisions are mentioned but not present',
93
112
                 self.missing_revision_cnt)
94
 
 
95
 
 
96
 
    def check_one_rev(self, rev_id, last_rev_id):
 
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):
97
128
        """Check one revision.
98
129
 
99
130
        rev_id - the one to check
101
132
        last_rev_id - the previous one on the mainline, if any.
102
133
        """
103
134
 
104
 
        # mutter('    revision {%s}' % rev_id)
 
135
        # mutter('    revision {%s}', rev_id)
105
136
        branch = self.branch
106
 
        rev = branch.get_revision(rev_id)
 
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.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.get_revision(rev_id)
 
148
                
107
149
        if rev.revision_id != rev_id:
108
150
            raise BzrCheckError('wrong internal revision id in revision {%s}'
109
151
                                % rev_id)
110
152
 
111
153
        # check the previous history entry is a parent of this entry
112
154
        if rev.parent_ids:
113
 
            if last_rev_id is None:
114
 
                raise BzrCheckError("revision {%s} has %d parents, but is the "
115
 
                                    "start of the branch"
116
 
                                    % (rev_id, len(rev.parent_ids)))
117
 
            for parent_id in rev.parent_ids:
118
 
                if parent_id == last_rev_id:
119
 
                    break
120
 
            else:
121
 
                raise BzrCheckError("previous revision {%s} not listed among "
122
 
                                    "parents of {%s}"
123
 
                                    % (last_rev_id, rev_id))
 
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.has_revision(parent):
 
171
                        missing_ancestry = self.branch.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)
124
178
        elif last_rev_id:
125
179
            raise BzrCheckError("revision {%s} has no parents listed "
126
180
                                "but preceded by {%s}"
133
187
                    ' value in revision {%s}' % rev_id)
134
188
        else:
135
189
            missing_inventory_sha_cnt += 1
136
 
            mutter("no inventory_sha1 on revision {%s}" % rev_id)
 
190
            mutter("no inventory_sha1 on revision {%s}", rev_id)
137
191
        self._check_revision_tree(rev_id)
138
192
        self.checked_rev_cnt += 1
139
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.weave_store.listable():
 
200
            weave_ids = list(self.branch.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.weave_store.get_weave(weave_id,
 
207
                    self.branch.get_transaction())
 
208
            # No progress here, because it looks ugly.
 
209
            w.check()
 
210
            self.checked_weaves[weave_id] = True
 
211
 
140
212
    def _check_revision_tree(self, rev_id):
141
213
        tree = self.branch.revision_tree(rev_id)
142
214
        inv = tree.inventory
159
231
            seen_names[path] = True
160
232
 
161
233
 
162
 
def check(branch):
 
234
def check(branch, verbose):
163
235
    """Run consistency checks on a branch."""
164
 
    Check(branch)
 
236
    checker = Check(branch)
 
237
    checker.check()
 
238
    checker.report_results(verbose)