← 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 03:19:29 UTC
  • Revision ID: robertc@robertcollins.net-20051011031929-2d523107133c43be
further tuning of pull, do not do a local merge or fetch at all, if the remote branch is no newer than we are

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
 
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
 
44
57
        self.checked_text_cnt = 0
45
58
        self.checked_rev_cnt = 0
46
 
        self.ghosts = []
47
59
        self.repeated_text_cnt = 0
48
 
        self.missing_parent_links = {}
49
60
        self.missing_inventory_sha_cnt = 0
50
61
        self.missing_revision_cnt = 0
51
62
        # maps (file-id, version) -> sha1
52
63
        self.checked_texts = {}
53
 
        self.checked_weaves = {}
54
 
 
55
 
    def check(self):
56
 
        self.branch.lock_read()
 
64
 
 
65
        history = branch.revision_history()
 
66
        revno = 0
 
67
        revcount = len(history)
 
68
 
 
69
        last_rev_id = None
57
70
        self.progress = bzrlib.ui.ui_factory.progress_bar()
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):
 
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):
99
81
        note('checked branch %s format %d',
100
82
             self.branch.base, 
101
83
             self.branch._branch_format)
103
85
        note('%6d revisions', self.checked_rev_cnt)
104
86
        note('%6d unique file texts', self.checked_text_cnt)
105
87
        note('%6d repeated file texts', self.repeated_text_cnt)
106
 
        note('%6d weaves', len(self.checked_weaves))
107
88
        if self.missing_inventory_sha_cnt:
108
 
            note('%6d revisions are missing inventory_sha1',
 
89
            note('%d revisions are missing inventory_sha1',
109
90
                 self.missing_inventory_sha_cnt)
110
91
        if self.missing_revision_cnt:
111
 
            note('%6d revisions are mentioned but not present',
 
92
            note('%d revisions are mentioned but not present',
112
93
                 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):
 
94
 
 
95
 
 
96
    def check_one_rev(self, rev_id, last_rev_id):
128
97
        """Check one revision.
129
98
 
130
99
        rev_id - the one to check
132
101
        last_rev_id - the previous one on the mainline, if any.
133
102
        """
134
103
 
135
 
        # mutter('    revision {%s}', rev_id)
 
104
        # mutter('    revision {%s}' % rev_id)
136
105
        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.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
 
                
 
106
        rev = branch.get_revision(rev_id)
149
107
        if rev.revision_id != rev_id:
150
108
            raise BzrCheckError('wrong internal revision id in revision {%s}'
151
109
                                % rev_id)
152
110
 
153
111
        # check the previous history entry is a parent of this entry
154
112
        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.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)
 
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))
178
124
        elif last_rev_id:
179
125
            raise BzrCheckError("revision {%s} has no parents listed "
180
126
                                "but preceded by {%s}"
187
133
                    ' value in revision {%s}' % rev_id)
188
134
        else:
189
135
            missing_inventory_sha_cnt += 1
190
 
            mutter("no inventory_sha1 on revision {%s}", rev_id)
 
136
            mutter("no inventory_sha1 on revision {%s}" % rev_id)
191
137
        self._check_revision_tree(rev_id)
192
138
        self.checked_rev_cnt += 1
193
139
 
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
 
 
212
140
    def _check_revision_tree(self, rev_id):
213
141
        tree = self.branch.revision_tree(rev_id)
214
142
        inv = tree.inventory
231
159
            seen_names[path] = True
232
160
 
233
161
 
234
 
def check(branch, verbose):
 
162
def check(branch):
235
163
    """Run consistency checks on a branch."""
236
 
    checker = Check(branch)
237
 
    checker.check()
238
 
    checker.report_results(verbose)
 
164
    Check(branch)