← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

(gz) Fix test failure on alpha by correcting format string for
 gc_chk_sha1_record (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
39
39
so that when the dependent object is checked, matches can be pulled out and
40
40
evaluated in-line rather than re-reading the same data many times.
41
41
check_refs are tuples (kind, value). Currently defined kinds are:
42
 
 
43
42
* 'trees', where value is a revid and the looked up objects are revision trees.
44
43
* 'lefthand-distance', where value is a revid and the looked up objects are the
45
44
  distance along the lefthand path to NULL for that revid.
54
53
from bzrlib.branch import Branch
55
54
from bzrlib.bzrdir import BzrDir
56
55
from bzrlib.revision import NULL_REVISION
 
56
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
57
57
from bzrlib.trace import note
58
58
from bzrlib.workingtree import WorkingTree
59
 
from bzrlib.i18n import gettext
60
59
 
61
60
class Check(object):
62
61
    """Check a repository"""
63
62
 
64
 
    def __init__(self, repository, check_repo=True):
65
 
        self.repository = repository
66
 
 
67
 
    def report_results(self, verbose):
68
 
        raise NotImplementedError(self.report_results)
69
 
 
70
 
 
71
 
class VersionedFileCheck(Check):
72
 
    """Check a versioned file repository"""
73
 
 
74
63
    # The Check object interacts with InventoryEntry.check, etc.
75
64
 
76
65
    def __init__(self, repository, check_repo=True):
103
92
        self.repository.lock_read()
104
93
        self.progress = ui.ui_factory.nested_progress_bar()
105
94
        try:
106
 
            self.progress.update(gettext('check'), 0, 4)
 
95
            self.progress.update('check', 0, 4)
107
96
            if self.check_repo:
108
 
                self.progress.update(gettext('checking revisions'), 0)
 
97
                self.progress.update('checking revisions', 0)
109
98
                self.check_revisions()
110
 
                self.progress.update(gettext('checking commit contents'), 1)
 
99
                self.progress.update('checking commit contents', 1)
111
100
                self.repository._check_inventories(self)
112
 
                self.progress.update(gettext('checking file graphs'), 2)
 
101
                self.progress.update('checking file graphs', 2)
113
102
                # check_weaves is done after the revision scan so that
114
103
                # revision index is known to be valid.
115
104
                self.check_weaves()
116
 
            self.progress.update(gettext('checking branches and trees'), 3)
 
105
            self.progress.update('checking branches and trees', 3)
117
106
            if callback_refs:
118
107
                repo = self.repository
119
108
                # calculate all refs, and callback the objects requesting them.
183
172
        # - we can fill out existence flags at this point
184
173
        # - we can read the revision inventory sha at this point
185
174
        # - we can check properties and serialisers etc.
186
 
        if not self.repository._format.revision_graph_can_have_wrong_parents:
 
175
        if not self.repository.revision_graph_can_have_wrong_parents():
187
176
            # The check against the index isn't needed.
188
177
            self.revs_with_bad_parents_in_index = None
189
178
            for thing in revision_iterator:
200
189
            result.report_results(verbose)
201
190
 
202
191
    def _report_repo_results(self, verbose):
203
 
        note(gettext('checked repository {0} format {1}').format(
 
192
        note('checked repository %s format %s',
204
193
            self.repository.user_url,
205
 
            self.repository._format))
206
 
        note(gettext('%6d revisions'), self.checked_rev_cnt)
207
 
        note(gettext('%6d file-ids'), len(self.checked_weaves))
 
194
            self.repository._format)
 
195
        note('%6d revisions', self.checked_rev_cnt)
 
196
        note('%6d file-ids', len(self.checked_weaves))
208
197
        if verbose:
209
 
            note(gettext('%6d unreferenced text versions'),
 
198
            note('%6d unreferenced text versions',
210
199
                len(self.unreferenced_versions))
211
200
        if verbose and len(self.unreferenced_versions):
212
201
                for file_id, revision_id in self.unreferenced_versions:
213
 
                    note(gettext('unreferenced version: {{{0}}} in {1}').format(revision_id,
214
 
                        file_id))
 
202
                    note('unreferenced version: {%s} in %s', revision_id,
 
203
                        file_id)
215
204
        if self.missing_inventory_sha_cnt:
216
 
            note(gettext('%6d revisions are missing inventory_sha1'),
 
205
            note('%6d revisions are missing inventory_sha1',
217
206
                 self.missing_inventory_sha_cnt)
218
207
        if self.missing_revision_cnt:
219
 
            note(gettext('%6d revisions are mentioned but not present'),
 
208
            note('%6d revisions are mentioned but not present',
220
209
                 self.missing_revision_cnt)
221
210
        if len(self.ghosts):
222
 
            note(gettext('%6d ghost revisions'), len(self.ghosts))
 
211
            note('%6d ghost revisions', len(self.ghosts))
223
212
            if verbose:
224
213
                for ghost in self.ghosts:
225
214
                    note('      %s', ghost)
226
215
        if len(self.missing_parent_links):
227
 
            note(gettext('%6d revisions missing parents in ancestry'),
 
216
            note('%6d revisions missing parents in ancestry',
228
217
                 len(self.missing_parent_links))
229
218
            if verbose:
230
219
                for link, linkers in self.missing_parent_links.items():
231
 
                    note(gettext('      %s should be in the ancestry for:'), link)
 
220
                    note('      %s should be in the ancestry for:', link)
232
221
                    for linker in linkers:
233
222
                        note('       * %s', linker)
234
223
        if len(self.inconsistent_parents):
235
 
            note(gettext('%6d inconsistent parents'), len(self.inconsistent_parents))
 
224
            note('%6d inconsistent parents', len(self.inconsistent_parents))
236
225
            if verbose:
237
226
                for info in self.inconsistent_parents:
238
227
                    revision_id, file_id, found_parents, correct_parents = info
239
 
                    note(gettext('      * {0} version {1} has parents {2!r} '
240
 
                         'but should have {3!r}').format(
241
 
                         file_id, revision_id, found_parents,
 
228
                    note('      * %s version %s has parents %r '
 
229
                         'but should have %r'
 
230
                         % (file_id, revision_id, found_parents,
242
231
                             correct_parents))
243
232
        if self.revs_with_bad_parents_in_index:
244
 
            note(gettext(
245
 
                 '%6d revisions have incorrect parents in the revision index'),
 
233
            note('%6d revisions have incorrect parents in the revision index',
246
234
                 len(self.revs_with_bad_parents_in_index))
247
235
            if verbose:
248
236
                for item in self.revs_with_bad_parents_in_index:
249
237
                    revision_id, index_parents, actual_parents = item
250
 
                    note(gettext(
251
 
                        '       {0} has wrong parents in index: '
252
 
                        '{1!r} should be {2!r}').format(
253
 
                        revision_id, index_parents, actual_parents))
 
238
                    note(
 
239
                        '       %s has wrong parents in index: '
 
240
                        '%r should be %r',
 
241
                        revision_id, index_parents, actual_parents)
254
242
        for item in self._report_items:
255
243
            note(item)
256
244
 
261
249
        :param rev: A revision or None to indicate a missing revision.
262
250
        """
263
251
        if rev.revision_id != rev_id:
264
 
            self._report_items.append(gettext(
265
 
                'Mismatched internal revid {{{0}}} and index revid {{{1}}}').format(
 
252
            self._report_items.append(
 
253
                'Mismatched internal revid {%s} and index revid {%s}' % (
266
254
                rev.revision_id, rev_id))
267
255
            rev_id = rev.revision_id
268
256
        # Check this revision tree etc, and count as seen when we encounter a
291
279
        existing = self.pending_keys.get(key)
292
280
        if existing:
293
281
            if sha1 != existing[1]:
294
 
                self._report_items.append(gettext('Multiple expected sha1s for {0}. {{{1}}}'
295
 
                    ' expects {{{2}}}, {{{3}}} expects {{{4}}}').format(
 
282
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
 
283
                    ' expects {%s}, {%s} expects {%s}', (
296
284
                    key, referer, sha1, existing[1], existing[0]))
297
285
        else:
298
286
            self.pending_keys[key] = (kind, sha1, referer)
349
337
    :param needed_refs: Refs we are accumulating.
350
338
    :param to_unlock: The unlock list accumulating.
351
339
    """
352
 
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
340
    note("Checking branch at '%s'." % (branch.base,))
353
341
    branch.lock_read()
354
342
    to_unlock.append(branch)
355
343
    branch_refs = branch._get_check_refs()
369
357
    """
370
358
    if base_tree is not None and tree.basedir == base_tree.basedir:
371
359
        return
372
 
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
360
    note("Checking working tree at '%s'." % (tree.basedir,))
373
361
    tree.lock_read()
374
362
    to_unlock.append(tree)
375
363
    tree_refs = tree._get_check_refs()
422
410
                    if do_branch:
423
411
                        scan_branch(branch, needed_refs, to_unlock)
424
412
            if do_branch and not branches:
425
 
                note(gettext("No branch found at specified location."))
 
413
                note("No branch found at specified location.")
426
414
            if do_tree and base_tree is None and not saw_tree:
427
 
                note(gettext("No working tree found at specified location."))
 
415
                note("No working tree found at specified location.")
428
416
            if do_repo or do_branch or do_tree:
429
417
                if do_repo:
430
 
                    note(gettext("Checking repository at '%s'.")
 
418
                    note("Checking repository at '%s'."
431
419
                         % (repo.user_url,))
432
420
                result = repo.check(None, callback_refs=needed_refs,
433
421
                    check_repo=do_repo)
434
422
                result.report_results(verbose)
435
423
        else:
436
424
            if do_tree:
437
 
                note(gettext("No working tree found at specified location."))
 
425
                note("No working tree found at specified location.")
438
426
            if do_branch:
439
 
                note(gettext("No branch found at specified location."))
 
427
                note("No branch found at specified location.")
440
428
            if do_repo:
441
 
                note(gettext("No repository found at specified location."))
 
429
                note("No repository found at specified location.")
442
430
    finally:
443
431
        for thing in to_unlock:
444
432
            thing.unlock()