← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

Add a NEWS entry and prepare submission.

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.
47
46
  indicating that the revision was found/not found.
48
47
"""
49
48
 
50
 
from bzrlib import (
51
 
    errors,
52
 
    ui,
53
 
    )
 
49
from bzrlib import errors, osutils
 
50
from bzrlib import repository as _mod_repository
 
51
from bzrlib import revision
54
52
from bzrlib.branch import Branch
55
53
from bzrlib.bzrdir import BzrDir
 
54
from bzrlib.errors import BzrCheckError
 
55
from bzrlib.repository import Repository
56
56
from bzrlib.revision import NULL_REVISION
 
57
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
57
58
from bzrlib.trace import note
 
59
import bzrlib.ui
58
60
from bzrlib.workingtree import WorkingTree
59
 
from bzrlib.i18n import gettext
60
61
 
61
62
class Check(object):
62
63
    """Check a repository"""
63
64
 
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
65
    # The Check object interacts with InventoryEntry.check, etc.
75
66
 
76
67
    def __init__(self, repository, check_repo=True):
101
92
        if callback_refs is None:
102
93
            callback_refs = {}
103
94
        self.repository.lock_read()
104
 
        self.progress = ui.ui_factory.nested_progress_bar()
 
95
        self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
105
96
        try:
106
 
            self.progress.update(gettext('check'), 0, 4)
 
97
            self.progress.update('check', 0, 4)
107
98
            if self.check_repo:
108
 
                self.progress.update(gettext('checking revisions'), 0)
 
99
                self.progress.update('checking revisions', 0)
109
100
                self.check_revisions()
110
 
                self.progress.update(gettext('checking commit contents'), 1)
 
101
                self.progress.update('checking commit contents', 1)
111
102
                self.repository._check_inventories(self)
112
 
                self.progress.update(gettext('checking file graphs'), 2)
 
103
                self.progress.update('checking file graphs', 2)
113
104
                # check_weaves is done after the revision scan so that
114
105
                # revision index is known to be valid.
115
106
                self.check_weaves()
116
 
            self.progress.update(gettext('checking branches and trees'), 3)
 
107
            self.progress.update('checking branches and trees', 3)
117
108
            if callback_refs:
118
109
                repo = self.repository
119
110
                # calculate all refs, and callback the objects requesting them.
183
174
        # - we can fill out existence flags at this point
184
175
        # - we can read the revision inventory sha at this point
185
176
        # - we can check properties and serialisers etc.
186
 
        if not self.repository._format.revision_graph_can_have_wrong_parents:
 
177
        if not self.repository.revision_graph_can_have_wrong_parents():
187
178
            # The check against the index isn't needed.
188
179
            self.revs_with_bad_parents_in_index = None
189
180
            for thing in revision_iterator:
200
191
            result.report_results(verbose)
201
192
 
202
193
    def _report_repo_results(self, verbose):
203
 
        note(gettext('checked repository {0} format {1}').format(
204
 
            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
        note('checked repository %s format %s',
 
195
             self.repository.bzrdir.root_transport,
 
196
             self.repository._format)
 
197
        note('%6d revisions', self.checked_rev_cnt)
 
198
        note('%6d file-ids', len(self.checked_weaves))
208
199
        if verbose:
209
 
            note(gettext('%6d unreferenced text versions'),
 
200
            note('%6d unreferenced text versions',
210
201
                len(self.unreferenced_versions))
211
202
        if verbose and len(self.unreferenced_versions):
212
203
                for file_id, revision_id in self.unreferenced_versions:
213
 
                    note(gettext('unreferenced version: {{{0}}} in {1}').format(revision_id,
214
 
                        file_id))
 
204
                    note('unreferenced version: {%s} in %s', revision_id,
 
205
                        file_id)
215
206
        if self.missing_inventory_sha_cnt:
216
 
            note(gettext('%6d revisions are missing inventory_sha1'),
 
207
            note('%6d revisions are missing inventory_sha1',
217
208
                 self.missing_inventory_sha_cnt)
218
209
        if self.missing_revision_cnt:
219
 
            note(gettext('%6d revisions are mentioned but not present'),
 
210
            note('%6d revisions are mentioned but not present',
220
211
                 self.missing_revision_cnt)
221
212
        if len(self.ghosts):
222
 
            note(gettext('%6d ghost revisions'), len(self.ghosts))
 
213
            note('%6d ghost revisions', len(self.ghosts))
223
214
            if verbose:
224
215
                for ghost in self.ghosts:
225
216
                    note('      %s', ghost)
226
217
        if len(self.missing_parent_links):
227
 
            note(gettext('%6d revisions missing parents in ancestry'),
 
218
            note('%6d revisions missing parents in ancestry',
228
219
                 len(self.missing_parent_links))
229
220
            if verbose:
230
221
                for link, linkers in self.missing_parent_links.items():
231
 
                    note(gettext('      %s should be in the ancestry for:'), link)
 
222
                    note('      %s should be in the ancestry for:', link)
232
223
                    for linker in linkers:
233
224
                        note('       * %s', linker)
234
225
        if len(self.inconsistent_parents):
235
 
            note(gettext('%6d inconsistent parents'), len(self.inconsistent_parents))
 
226
            note('%6d inconsistent parents', len(self.inconsistent_parents))
236
227
            if verbose:
237
228
                for info in self.inconsistent_parents:
238
229
                    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,
 
230
                    note('      * %s version %s has parents %r '
 
231
                         'but should have %r'
 
232
                         % (file_id, revision_id, found_parents,
242
233
                             correct_parents))
243
234
        if self.revs_with_bad_parents_in_index:
244
 
            note(gettext(
245
 
                 '%6d revisions have incorrect parents in the revision index'),
 
235
            note('%6d revisions have incorrect parents in the revision index',
246
236
                 len(self.revs_with_bad_parents_in_index))
247
237
            if verbose:
248
238
                for item in self.revs_with_bad_parents_in_index:
249
239
                    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))
 
240
                    note(
 
241
                        '       %s has wrong parents in index: '
 
242
                        '%r should be %r',
 
243
                        revision_id, index_parents, actual_parents)
254
244
        for item in self._report_items:
255
245
            note(item)
256
246
 
261
251
        :param rev: A revision or None to indicate a missing revision.
262
252
        """
263
253
        if rev.revision_id != rev_id:
264
 
            self._report_items.append(gettext(
265
 
                'Mismatched internal revid {{{0}}} and index revid {{{1}}}').format(
 
254
            self._report_items.append(
 
255
                'Mismatched internal revid {%s} and index revid {%s}' % (
266
256
                rev.revision_id, rev_id))
267
257
            rev_id = rev.revision_id
268
258
        # Check this revision tree etc, and count as seen when we encounter a
291
281
        existing = self.pending_keys.get(key)
292
282
        if existing:
293
283
            if sha1 != existing[1]:
294
 
                self._report_items.append(gettext('Multiple expected sha1s for {0}. {{{1}}}'
295
 
                    ' expects {{{2}}}, {{{3}}} expects {{{4}}}').format(
 
284
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
 
285
                    ' expects {%s}, {%s} expects {%s}', (
296
286
                    key, referer, sha1, existing[1], existing[0]))
297
287
        else:
298
288
            self.pending_keys[key] = (kind, sha1, referer)
301
291
        """Check all the weaves we can get our hands on.
302
292
        """
303
293
        weave_ids = []
304
 
        storebar = ui.ui_factory.nested_progress_bar()
 
294
        storebar = bzrlib.ui.ui_factory.nested_progress_bar()
305
295
        try:
306
296
            self._check_weaves(storebar)
307
297
        finally:
342
332
            self.text_key_references[key] = True
343
333
 
344
334
 
 
335
@deprecated_function(deprecated_in((1,6,0)))
 
336
def check(branch, verbose):
 
337
    """Run consistency checks on a branch.
 
338
 
 
339
    Results are reported through logging.
 
340
 
 
341
    Deprecated in 1.6.  Please use check_dwim instead.
 
342
 
 
343
    :raise BzrCheckError: if there's a consistency error.
 
344
    """
 
345
    check_branch(branch, verbose)
 
346
 
 
347
 
 
348
@deprecated_function(deprecated_in((1,16,0)))
 
349
def check_branch(branch, verbose):
 
350
    """Run consistency checks on a branch.
 
351
 
 
352
    Results are reported through logging.
 
353
 
 
354
    :raise BzrCheckError: if there's a consistency error.
 
355
    """
 
356
    branch.lock_read()
 
357
    try:
 
358
        needed_refs = {}
 
359
        for ref in branch._get_check_refs():
 
360
            needed_refs.setdefault(ref, []).append(branch)
 
361
        result = branch.repository.check([branch.last_revision()], needed_refs)
 
362
        branch_result = result.other_results[0]
 
363
    finally:
 
364
        branch.unlock()
 
365
    branch_result.report_results(verbose)
 
366
 
 
367
 
345
368
def scan_branch(branch, needed_refs, to_unlock):
346
369
    """Scan a branch for refs.
347
370
 
349
372
    :param needed_refs: Refs we are accumulating.
350
373
    :param to_unlock: The unlock list accumulating.
351
374
    """
352
 
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
375
    note("Checking branch at '%s'." % (branch.base,))
353
376
    branch.lock_read()
354
377
    to_unlock.append(branch)
355
378
    branch_refs = branch._get_check_refs()
369
392
    """
370
393
    if base_tree is not None and tree.basedir == base_tree.basedir:
371
394
        return
372
 
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
395
    note("Checking working tree at '%s'." % (tree.basedir,))
373
396
    tree.lock_read()
374
397
    to_unlock.append(tree)
375
398
    tree_refs = tree._get_check_refs()
422
445
                    if do_branch:
423
446
                        scan_branch(branch, needed_refs, to_unlock)
424
447
            if do_branch and not branches:
425
 
                note(gettext("No branch found at specified location."))
 
448
                note("No branch found at specified location.")
426
449
            if do_tree and base_tree is None and not saw_tree:
427
 
                note(gettext("No working tree found at specified location."))
 
450
                note("No working tree found at specified location.")
428
451
            if do_repo or do_branch or do_tree:
429
452
                if do_repo:
430
 
                    note(gettext("Checking repository at '%s'.")
431
 
                         % (repo.user_url,))
 
453
                    note("Checking repository at '%s'."
 
454
                         % (repo.bzrdir.root_transport.base,))
432
455
                result = repo.check(None, callback_refs=needed_refs,
433
456
                    check_repo=do_repo)
434
457
                result.report_results(verbose)
435
458
        else:
436
459
            if do_tree:
437
 
                note(gettext("No working tree found at specified location."))
 
460
                note("No working tree found at specified location.")
438
461
            if do_branch:
439
 
                note(gettext("No branch found at specified location."))
 
462
                note("No branch found at specified location.")
440
463
            if do_repo:
441
 
                note(gettext("No repository found at specified location."))
 
464
                note("No repository found at specified location.")
442
465
    finally:
443
466
        for thing in to_unlock:
444
467
            thing.unlock()