← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: Robert Collins
  • Date: 2005-10-11 07:21:00 UTC
  • mto: This revision was merged to the branch mainline in revision 1443.
  • Revision ID: robertc@robertcollins.net-20051011072100-16996b55c43ff24f
move editor into the config file too

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.
30
28
 
31
29
import bzrlib.ui
32
30
from bzrlib.trace import note, warning
34
32
from bzrlib.trace import mutter
35
33
from bzrlib.errors import BzrCheckError, NoSuchRevision
36
34
from bzrlib.inventory import ROOT_ID
 
35
from bzrlib.branch import gen_root_id
37
36
 
38
37
 
39
38
class Check(object):
40
39
    """Check a branch"""
41
 
 
42
40
    def __init__(self, branch):
43
41
        self.branch = branch
44
 
        self.repository = branch.repository
 
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
 
45
57
        self.checked_text_cnt = 0
46
58
        self.checked_rev_cnt = 0
47
 
        self.ghosts = []
48
59
        self.repeated_text_cnt = 0
49
 
        self.missing_parent_links = {}
50
60
        self.missing_inventory_sha_cnt = 0
51
61
        self.missing_revision_cnt = 0
52
62
        # maps (file-id, version) -> sha1
53
63
        self.checked_texts = {}
54
 
        self.checked_weaves = {}
55
 
 
56
 
    def check(self):
57
 
        self.branch.lock_read()
 
64
 
 
65
        history = branch.revision_history()
 
66
        revno = 0
 
67
        revcount = len(history)
 
68
 
 
69
        last_rev_id = None
58
70
        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',
 
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):
 
81
        note('checked branch %s format %d',
102
82
             self.branch.base, 
103
 
             self.branch._format)
 
83
             self.branch._branch_format)
104
84
 
105
85
        note('%6d revisions', self.checked_rev_cnt)
106
86
        note('%6d unique file texts', self.checked_text_cnt)
107
87
        note('%6d repeated file texts', self.repeated_text_cnt)
108
 
        note('%6d weaves', len(self.checked_weaves))
109
88
        if self.missing_inventory_sha_cnt:
110
 
            note('%6d revisions are missing inventory_sha1',
 
89
            note('%d revisions are missing inventory_sha1',
111
90
                 self.missing_inventory_sha_cnt)
112
91
        if self.missing_revision_cnt:
113
 
            note('%6d revisions are mentioned but not present',
 
92
            note('%d revisions are mentioned but not present',
114
93
                 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):
 
94
 
 
95
 
 
96
    def check_one_rev(self, rev_id, last_rev_id):
130
97
        """Check one revision.
131
98
 
132
99
        rev_id - the one to check
134
101
        last_rev_id - the previous one on the mainline, if any.
135
102
        """
136
103
 
137
 
        # mutter('    revision {%s}', rev_id)
 
104
        # mutter('    revision {%s}' % rev_id)
138
105
        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
 
                
 
106
        rev = branch.get_revision(rev_id)
151
107
        if rev.revision_id != rev_id:
152
108
            raise BzrCheckError('wrong internal revision id in revision {%s}'
153
109
                                % rev_id)
154
110
 
155
111
        # check the previous history entry is a parent of this entry
156
112
        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.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)
 
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))
180
124
        elif last_rev_id:
181
125
            raise BzrCheckError("revision {%s} has no parents listed "
182
126
                                "but preceded by {%s}"
183
127
                                % (rev_id, last_rev_id))
184
128
 
185
129
        if rev.inventory_sha1:
186
 
            inv_sha1 = branch.repository.get_inventory_sha1(rev_id)
 
130
            inv_sha1 = branch.get_inventory_sha1(rev_id)
187
131
            if inv_sha1 != rev.inventory_sha1:
188
132
                raise BzrCheckError('Inventory sha1 hash doesn\'t match'
189
133
                    ' value in revision {%s}' % rev_id)
190
134
        else:
191
135
            missing_inventory_sha_cnt += 1
192
 
            mutter("no inventory_sha1 on revision {%s}", rev_id)
 
136
            mutter("no inventory_sha1 on revision {%s}" % rev_id)
193
137
        self._check_revision_tree(rev_id)
194
138
        self.checked_rev_cnt += 1
195
139
 
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
140
    def _check_revision_tree(self, rev_id):
215
 
        tree = self.branch.repository.revision_tree(rev_id)
 
141
        tree = self.branch.revision_tree(rev_id)
216
142
        inv = tree.inventory
217
143
        seen_ids = {}
218
144
        for file_id in inv:
233
159
            seen_names[path] = True
234
160
 
235
161
 
236
 
def check(branch, verbose):
 
162
def check(branch):
237
163
    """Run consistency checks on a branch."""
238
 
    checker = Check(branch)
239
 
    checker.check()
240
 
    checker.report_results(verbose)
 
164
    Check(branch)