← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: Vincent Ladeuil
  • Date: 2011-10-27 15:38:14 UTC
  • mfrom: (6015.44.4 2.4)
  • mto: This revision was merged to the branch mainline in revision 6236.
  • Revision ID: v.ladeuil+lp@free.fr-20111027153814-0r4nd2io1jv6t47f
Merge 2.4 into trunk including fix for bug #880701

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
52
52
    ui,
53
53
    )
54
54
from bzrlib.branch import Branch
55
 
from bzrlib.bzrdir import BzrDir
 
55
from bzrlib.controldir import ControlDir
56
56
from bzrlib.revision import NULL_REVISION
57
57
from bzrlib.trace import note
58
58
from bzrlib.workingtree import WorkingTree
59
 
 
 
59
from bzrlib.i18n import gettext
60
60
 
61
61
class Check(object):
62
62
    """Check a repository"""
103
103
        self.repository.lock_read()
104
104
        self.progress = ui.ui_factory.nested_progress_bar()
105
105
        try:
106
 
            self.progress.update('check', 0, 4)
 
106
            self.progress.update(gettext('check'), 0, 4)
107
107
            if self.check_repo:
108
 
                self.progress.update('checking revisions', 0)
 
108
                self.progress.update(gettext('checking revisions'), 0)
109
109
                self.check_revisions()
110
 
                self.progress.update('checking commit contents', 1)
 
110
                self.progress.update(gettext('checking commit contents'), 1)
111
111
                self.repository._check_inventories(self)
112
 
                self.progress.update('checking file graphs', 2)
 
112
                self.progress.update(gettext('checking file graphs'), 2)
113
113
                # check_weaves is done after the revision scan so that
114
114
                # revision index is known to be valid.
115
115
                self.check_weaves()
116
 
            self.progress.update('checking branches and trees', 3)
 
116
            self.progress.update(gettext('checking branches and trees'), 3)
117
117
            if callback_refs:
118
118
                repo = self.repository
119
119
                # calculate all refs, and callback the objects requesting them.
200
200
            result.report_results(verbose)
201
201
 
202
202
    def _report_repo_results(self, verbose):
203
 
        note('checked repository %s format %s',
 
203
        note(gettext('checked repository {0} format {1}').format(
204
204
            self.repository.user_url,
205
 
            self.repository._format)
206
 
        note('%6d revisions', self.checked_rev_cnt)
207
 
        note('%6d file-ids', len(self.checked_weaves))
 
205
            self.repository._format))
 
206
        note(gettext('%6d revisions'), self.checked_rev_cnt)
 
207
        note(gettext('%6d file-ids'), len(self.checked_weaves))
208
208
        if verbose:
209
 
            note('%6d unreferenced text versions',
 
209
            note(gettext('%6d unreferenced text versions'),
210
210
                len(self.unreferenced_versions))
211
211
        if verbose and len(self.unreferenced_versions):
212
212
                for file_id, revision_id in self.unreferenced_versions:
213
 
                    note('unreferenced version: {%s} in %s', revision_id,
214
 
                        file_id)
 
213
                    note(gettext('unreferenced version: {{{0}}} in {1}').format(revision_id,
 
214
                        file_id))
215
215
        if self.missing_inventory_sha_cnt:
216
 
            note('%6d revisions are missing inventory_sha1',
 
216
            note(gettext('%6d revisions are missing inventory_sha1'),
217
217
                 self.missing_inventory_sha_cnt)
218
218
        if self.missing_revision_cnt:
219
 
            note('%6d revisions are mentioned but not present',
 
219
            note(gettext('%6d revisions are mentioned but not present'),
220
220
                 self.missing_revision_cnt)
221
221
        if len(self.ghosts):
222
 
            note('%6d ghost revisions', len(self.ghosts))
 
222
            note(gettext('%6d ghost revisions'), len(self.ghosts))
223
223
            if verbose:
224
224
                for ghost in self.ghosts:
225
225
                    note('      %s', ghost)
226
226
        if len(self.missing_parent_links):
227
 
            note('%6d revisions missing parents in ancestry',
 
227
            note(gettext('%6d revisions missing parents in ancestry'),
228
228
                 len(self.missing_parent_links))
229
229
            if verbose:
230
230
                for link, linkers in self.missing_parent_links.items():
231
 
                    note('      %s should be in the ancestry for:', link)
 
231
                    note(gettext('      %s should be in the ancestry for:'), link)
232
232
                    for linker in linkers:
233
233
                        note('       * %s', linker)
234
234
        if len(self.inconsistent_parents):
235
 
            note('%6d inconsistent parents', len(self.inconsistent_parents))
 
235
            note(gettext('%6d inconsistent parents'), len(self.inconsistent_parents))
236
236
            if verbose:
237
237
                for info in self.inconsistent_parents:
238
238
                    revision_id, file_id, found_parents, correct_parents = info
239
 
                    note('      * %s version %s has parents %r '
240
 
                         'but should have %r'
241
 
                         % (file_id, revision_id, found_parents,
 
239
                    note(gettext('      * {0} version {1} has parents {2!r} '
 
240
                         'but should have {3!r}').format(
 
241
                         file_id, revision_id, found_parents,
242
242
                             correct_parents))
243
243
        if self.revs_with_bad_parents_in_index:
244
 
            note('%6d revisions have incorrect parents in the revision index',
 
244
            note(gettext(
 
245
                 '%6d revisions have incorrect parents in the revision index'),
245
246
                 len(self.revs_with_bad_parents_in_index))
246
247
            if verbose:
247
248
                for item in self.revs_with_bad_parents_in_index:
248
249
                    revision_id, index_parents, actual_parents = item
249
 
                    note(
250
 
                        '       %s has wrong parents in index: '
251
 
                        '%r should be %r',
252
 
                        revision_id, index_parents, actual_parents)
 
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))
253
254
        for item in self._report_items:
254
255
            note(item)
255
256
 
260
261
        :param rev: A revision or None to indicate a missing revision.
261
262
        """
262
263
        if rev.revision_id != rev_id:
263
 
            self._report_items.append(
264
 
                'Mismatched internal revid {%s} and index revid {%s}' % (
 
264
            self._report_items.append(gettext(
 
265
                'Mismatched internal revid {{{0}}} and index revid {{{1}}}').format(
265
266
                rev.revision_id, rev_id))
266
267
            rev_id = rev.revision_id
267
268
        # Check this revision tree etc, and count as seen when we encounter a
290
291
        existing = self.pending_keys.get(key)
291
292
        if existing:
292
293
            if sha1 != existing[1]:
293
 
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
294
 
                    ' expects {%s}, {%s} expects {%s}', (
 
294
                self._report_items.append(gettext('Multiple expected sha1s for {0}. {{{1}}}'
 
295
                    ' expects {{{2}}}, {{{3}}} expects {{{4}}}').format(
295
296
                    key, referer, sha1, existing[1], existing[0]))
296
297
        else:
297
298
            self.pending_keys[key] = (kind, sha1, referer)
348
349
    :param needed_refs: Refs we are accumulating.
349
350
    :param to_unlock: The unlock list accumulating.
350
351
    """
351
 
    note("Checking branch at '%s'." % (branch.base,))
 
352
    note(gettext("Checking branch at '%s'.") % (branch.base,))
352
353
    branch.lock_read()
353
354
    to_unlock.append(branch)
354
355
    branch_refs = branch._get_check_refs()
368
369
    """
369
370
    if base_tree is not None and tree.basedir == base_tree.basedir:
370
371
        return
371
 
    note("Checking working tree at '%s'." % (tree.basedir,))
 
372
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
372
373
    tree.lock_read()
373
374
    to_unlock.append(tree)
374
375
    tree_refs = tree._get_check_refs()
385
386
    """
386
387
    try:
387
388
        base_tree, branch, repo, relpath = \
388
 
                        BzrDir.open_containing_tree_branch_or_repository(path)
 
389
                        ControlDir.open_containing_tree_branch_or_repository(path)
389
390
    except errors.NotBranchError:
390
391
        base_tree = branch = repo = None
391
392
 
421
422
                    if do_branch:
422
423
                        scan_branch(branch, needed_refs, to_unlock)
423
424
            if do_branch and not branches:
424
 
                note("No branch found at specified location.")
 
425
                note(gettext("No branch found at specified location."))
425
426
            if do_tree and base_tree is None and not saw_tree:
426
 
                note("No working tree found at specified location.")
 
427
                note(gettext("No working tree found at specified location."))
427
428
            if do_repo or do_branch or do_tree:
428
429
                if do_repo:
429
 
                    note("Checking repository at '%s'."
 
430
                    note(gettext("Checking repository at '%s'.")
430
431
                         % (repo.user_url,))
431
432
                result = repo.check(None, callback_refs=needed_refs,
432
433
                    check_repo=do_repo)
433
434
                result.report_results(verbose)
434
435
        else:
435
436
            if do_tree:
436
 
                note("No working tree found at specified location.")
 
437
                note(gettext("No working tree found at specified location."))
437
438
            if do_branch:
438
 
                note("No branch found at specified location.")
 
439
                note(gettext("No branch found at specified location."))
439
440
            if do_repo:
440
 
                note("No repository found at specified location.")
 
441
                note(gettext("No repository found at specified location."))
441
442
    finally:
442
443
        for thing in to_unlock:
443
444
            thing.unlock()