/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/check.py

  • Committer: Jelmer Vernooij
  • Date: 2018-03-30 14:47:14 UTC
  • mto: This revision was merged to the branch mainline in revision 6930.
  • Revision ID: jelmer@jelmer.uk-20180330144714-sncrnhqh8y4nmpbr
Add basic tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
 
42
43
* 'trees', where value is a revid and the looked up objects are revision trees.
43
44
* 'lefthand-distance', where value is a revid and the looked up objects are the
44
45
  distance along the lefthand path to NULL for that revid.
46
47
  indicating that the revision was found/not found.
47
48
"""
48
49
 
49
 
from bzrlib import errors
50
 
from bzrlib.branch import Branch
51
 
from bzrlib.bzrdir import BzrDir
52
 
from bzrlib.revision import NULL_REVISION
53
 
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
54
 
from bzrlib.trace import note
55
 
import bzrlib.ui
56
 
from bzrlib.workingtree import WorkingTree
 
50
from __future__ import absolute_import
 
51
 
 
52
from . import (
 
53
    errors,
 
54
    ui,
 
55
    )
 
56
from .branch import Branch
 
57
from .controldir import ControlDir
 
58
from .revision import NULL_REVISION
 
59
from .sixish import (
 
60
    viewitems,
 
61
    )
 
62
from .trace import note
 
63
from .workingtree import WorkingTree
 
64
from .i18n import gettext
57
65
 
58
66
class Check(object):
59
67
    """Check a repository"""
60
68
 
 
69
    def __init__(self, repository, check_repo=True):
 
70
        self.repository = repository
 
71
 
 
72
    def report_results(self, verbose):
 
73
        raise NotImplementedError(self.report_results)
 
74
 
 
75
 
 
76
class VersionedFileCheck(Check):
 
77
    """Check a versioned file repository"""
 
78
 
61
79
    # The Check object interacts with InventoryEntry.check, etc.
62
80
 
63
81
    def __init__(self, repository, check_repo=True):
87
105
    def check(self, callback_refs=None, check_repo=True):
88
106
        if callback_refs is None:
89
107
            callback_refs = {}
90
 
        self.repository.lock_read()
91
 
        self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
92
 
        try:
93
 
            self.progress.update('check', 0, 4)
 
108
        with self.repository.lock_read(), ui.ui_factory.nested_progress_bar() as self.progress:
 
109
            self.progress.update(gettext('check'), 0, 4)
94
110
            if self.check_repo:
95
 
                self.progress.update('checking revisions', 0)
 
111
                self.progress.update(gettext('checking revisions'), 0)
96
112
                self.check_revisions()
97
 
                self.progress.update('checking commit contents', 1)
 
113
                self.progress.update(gettext('checking commit contents'), 1)
98
114
                self.repository._check_inventories(self)
99
 
                self.progress.update('checking file graphs', 2)
 
115
                self.progress.update(gettext('checking file graphs'), 2)
100
116
                # check_weaves is done after the revision scan so that
101
117
                # revision index is known to be valid.
102
118
                self.check_weaves()
103
 
            self.progress.update('checking branches and trees', 3)
 
119
            self.progress.update(gettext('checking branches and trees'), 3)
104
120
            if callback_refs:
105
121
                repo = self.repository
106
122
                # calculate all refs, and callback the objects requesting them.
113
129
                # landing].
114
130
                distances = set()
115
131
                existences = set()
116
 
                for ref, wantlist in callback_refs.iteritems():
 
132
                for ref, wantlist in viewitems(callback_refs):
117
133
                    wanting_items.update(wantlist)
118
134
                    kind, value = ref
119
135
                    if kind == 'trees':
126
142
                        raise AssertionError(
127
143
                            'unknown ref kind for ref %s' % ref)
128
144
                node_distances = repo.get_graph().find_lefthand_distances(distances)
129
 
                for key, distance in node_distances.iteritems():
 
145
                for key, distance in viewitems(node_distances):
130
146
                    refs[('lefthand-distance', key)] = distance
131
147
                    if key in existences and distance > 0:
132
148
                        refs[('revision-existence', key)] = True
142
158
                        item._check(refs)
143
159
                    if isinstance(item, Branch):
144
160
                        self.other_results.append(item.check(refs))
145
 
        finally:
146
 
            self.progress.finished()
147
 
            self.repository.unlock()
148
161
 
149
162
    def _check_revisions(self, revisions_iterator):
150
163
        """Check revision objects by decorating a generator.
163
176
 
164
177
    def check_revisions(self):
165
178
        """Scan revisions, checking data directly available as we go."""
166
 
        revision_iterator = self.repository._iter_revisions(None)
 
179
        revision_iterator = self.repository.iter_revisions(
 
180
            self.repository.all_revision_ids())
167
181
        revision_iterator = self._check_revisions(revision_iterator)
168
182
        # We read the all revisions here:
169
183
        # - doing this allows later code to depend on the revision index.
170
184
        # - we can fill out existence flags at this point
171
185
        # - we can read the revision inventory sha at this point
172
186
        # - we can check properties and serialisers etc.
173
 
        if not self.repository.revision_graph_can_have_wrong_parents():
 
187
        if not self.repository._format.revision_graph_can_have_wrong_parents:
174
188
            # The check against the index isn't needed.
175
189
            self.revs_with_bad_parents_in_index = None
176
190
            for thing in revision_iterator:
187
201
            result.report_results(verbose)
188
202
 
189
203
    def _report_repo_results(self, verbose):
190
 
        note('checked repository %s format %s',
 
204
        note(gettext('checked repository {0} format {1}').format(
191
205
            self.repository.user_url,
192
 
            self.repository._format)
193
 
        note('%6d revisions', self.checked_rev_cnt)
194
 
        note('%6d file-ids', len(self.checked_weaves))
 
206
            self.repository._format))
 
207
        note(gettext('%6d revisions'), self.checked_rev_cnt)
 
208
        note(gettext('%6d file-ids'), len(self.checked_weaves))
195
209
        if verbose:
196
 
            note('%6d unreferenced text versions',
 
210
            note(gettext('%6d unreferenced text versions'),
197
211
                len(self.unreferenced_versions))
198
212
        if verbose and len(self.unreferenced_versions):
199
213
                for file_id, revision_id in self.unreferenced_versions:
200
 
                    note('unreferenced version: {%s} in %s', revision_id,
201
 
                        file_id)
 
214
                    note(gettext('unreferenced version: {{{0}}} in {1}').format(revision_id,
 
215
                        file_id))
202
216
        if self.missing_inventory_sha_cnt:
203
 
            note('%6d revisions are missing inventory_sha1',
 
217
            note(gettext('%6d revisions are missing inventory_sha1'),
204
218
                 self.missing_inventory_sha_cnt)
205
219
        if self.missing_revision_cnt:
206
 
            note('%6d revisions are mentioned but not present',
 
220
            note(gettext('%6d revisions are mentioned but not present'),
207
221
                 self.missing_revision_cnt)
208
222
        if len(self.ghosts):
209
 
            note('%6d ghost revisions', len(self.ghosts))
 
223
            note(gettext('%6d ghost revisions'), len(self.ghosts))
210
224
            if verbose:
211
225
                for ghost in self.ghosts:
212
226
                    note('      %s', ghost)
213
227
        if len(self.missing_parent_links):
214
 
            note('%6d revisions missing parents in ancestry',
 
228
            note(gettext('%6d revisions missing parents in ancestry'),
215
229
                 len(self.missing_parent_links))
216
230
            if verbose:
217
 
                for link, linkers in self.missing_parent_links.items():
218
 
                    note('      %s should be in the ancestry for:', link)
 
231
                for link, linkers in viewitems(self.missing_parent_links):
 
232
                    note(gettext('      %s should be in the ancestry for:'), link)
219
233
                    for linker in linkers:
220
234
                        note('       * %s', linker)
221
235
        if len(self.inconsistent_parents):
222
 
            note('%6d inconsistent parents', len(self.inconsistent_parents))
 
236
            note(gettext('%6d inconsistent parents'), len(self.inconsistent_parents))
223
237
            if verbose:
224
238
                for info in self.inconsistent_parents:
225
239
                    revision_id, file_id, found_parents, correct_parents = info
226
 
                    note('      * %s version %s has parents %r '
227
 
                         'but should have %r'
228
 
                         % (file_id, revision_id, found_parents,
 
240
                    note(gettext('      * {0} version {1} has parents {2!r} '
 
241
                         'but should have {3!r}').format(
 
242
                         file_id, revision_id, found_parents,
229
243
                             correct_parents))
230
244
        if self.revs_with_bad_parents_in_index:
231
 
            note('%6d revisions have incorrect parents in the revision index',
 
245
            note(gettext(
 
246
                 '%6d revisions have incorrect parents in the revision index'),
232
247
                 len(self.revs_with_bad_parents_in_index))
233
248
            if verbose:
234
249
                for item in self.revs_with_bad_parents_in_index:
235
250
                    revision_id, index_parents, actual_parents = item
236
 
                    note(
237
 
                        '       %s has wrong parents in index: '
238
 
                        '%r should be %r',
239
 
                        revision_id, index_parents, actual_parents)
 
251
                    note(gettext(
 
252
                        '       {0} has wrong parents in index: '
 
253
                        '{1!r} should be {2!r}').format(
 
254
                        revision_id, index_parents, actual_parents))
240
255
        for item in self._report_items:
241
256
            note(item)
242
257
 
247
262
        :param rev: A revision or None to indicate a missing revision.
248
263
        """
249
264
        if rev.revision_id != rev_id:
250
 
            self._report_items.append(
251
 
                'Mismatched internal revid {%s} and index revid {%s}' % (
 
265
            self._report_items.append(gettext(
 
266
                'Mismatched internal revid {{{0}}} and index revid {{{1}}}').format(
252
267
                rev.revision_id, rev_id))
253
268
            rev_id = rev.revision_id
254
269
        # Check this revision tree etc, and count as seen when we encounter a
277
292
        existing = self.pending_keys.get(key)
278
293
        if existing:
279
294
            if sha1 != existing[1]:
280
 
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
281
 
                    ' expects {%s}, {%s} expects {%s}', (
 
295
                self._report_items.append(gettext('Multiple expected sha1s for {0}. {{{1}}}'
 
296
                    ' expects {{{2}}}, {{{3}}} expects {{{4}}}').format(
282
297
                    key, referer, sha1, existing[1], existing[0]))
283
298
        else:
284
299
            self.pending_keys[key] = (kind, sha1, referer)
287
302
        """Check all the weaves we can get our hands on.
288
303
        """
289
304
        weave_ids = []
290
 
        storebar = bzrlib.ui.ui_factory.nested_progress_bar()
291
 
        try:
 
305
        with ui.ui_factory.nested_progress_bar() as storebar:
292
306
            self._check_weaves(storebar)
293
 
        finally:
294
 
            storebar.finished()
295
307
 
296
308
    def _check_weaves(self, storebar):
297
309
        storebar.update('text-index', 0, 2)
304
316
                text_key_references=self.text_key_references,
305
317
                ancestors=self.ancestors)
306
318
        storebar.update('file-graph', 1)
307
 
        result = weave_checker.check_file_version_parents(
 
319
        wrongs, unused_versions = weave_checker.check_file_version_parents(
308
320
            self.repository.texts)
309
321
        self.checked_weaves = weave_checker.file_ids
310
 
        bad_parents, unused_versions = result
311
 
        bad_parents = bad_parents.items()
312
 
        for text_key, (stored_parents, correct_parents) in bad_parents:
 
322
        for text_key, (stored_parents, correct_parents) in viewitems(wrongs):
313
323
            # XXX not ready for id join/split operations.
314
324
            weave_id = text_key[0]
315
325
            revision_id = text_key[-1]
328
338
            self.text_key_references[key] = True
329
339
 
330
340
 
331
 
@deprecated_function(deprecated_in((1,6,0)))
332
 
def check(branch, verbose):
333
 
    """Run consistency checks on a branch.
334
 
 
335
 
    Results are reported through logging.
336
 
 
337
 
    Deprecated in 1.6.  Please use check_dwim instead.
338
 
 
339
 
    :raise BzrCheckError: if there's a consistency error.
340
 
    """
341
 
    check_branch(branch, verbose)
342
 
 
343
 
 
344
 
@deprecated_function(deprecated_in((1,16,0)))
345
 
def check_branch(branch, verbose):
346
 
    """Run consistency checks on a branch.
347
 
 
348
 
    Results are reported through logging.
349
 
 
350
 
    :raise BzrCheckError: if there's a consistency error.
351
 
    """
352
 
    branch.lock_read()
353
 
    try:
354
 
        needed_refs = {}
355
 
        for ref in branch._get_check_refs():
356
 
            needed_refs.setdefault(ref, []).append(branch)
357
 
        result = branch.repository.check([branch.last_revision()], needed_refs)
358
 
        branch_result = result.other_results[0]
359
 
    finally:
360
 
        branch.unlock()
361
 
    branch_result.report_results(verbose)
362
 
 
363
 
 
364
341
def scan_branch(branch, needed_refs, to_unlock):
365
342
    """Scan a branch for refs.
366
343
 
368
345
    :param needed_refs: Refs we are accumulating.
369
346
    :param to_unlock: The unlock list accumulating.
370
347
    """
371
 
    note("Checking branch at '%s'." % (branch.base,))
 
348
    note(gettext("Checking branch at '%s'.") % (branch.base,))
372
349
    branch.lock_read()
373
350
    to_unlock.append(branch)
374
351
    branch_refs = branch._get_check_refs()
388
365
    """
389
366
    if base_tree is not None and tree.basedir == base_tree.basedir:
390
367
        return
391
 
    note("Checking working tree at '%s'." % (tree.basedir,))
 
368
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
392
369
    tree.lock_read()
393
370
    to_unlock.append(tree)
394
371
    tree_refs = tree._get_check_refs()
405
382
    """
406
383
    try:
407
384
        base_tree, branch, repo, relpath = \
408
 
                        BzrDir.open_containing_tree_branch_or_repository(path)
 
385
                        ControlDir.open_containing_tree_branch_or_repository(path)
409
386
    except errors.NotBranchError:
410
387
        base_tree = branch = repo = None
411
388
 
432
409
                for branch in branches:
433
410
                    if do_tree:
434
411
                        try:
435
 
                            tree = branch.bzrdir.open_workingtree()
 
412
                            tree = branch.controldir.open_workingtree()
436
413
                            saw_tree = True
437
414
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
438
415
                            pass
441
418
                    if do_branch:
442
419
                        scan_branch(branch, needed_refs, to_unlock)
443
420
            if do_branch and not branches:
444
 
                note("No branch found at specified location.")
 
421
                note(gettext("No branch found at specified location."))
445
422
            if do_tree and base_tree is None and not saw_tree:
446
 
                note("No working tree found at specified location.")
 
423
                note(gettext("No working tree found at specified location."))
447
424
            if do_repo or do_branch or do_tree:
448
425
                if do_repo:
449
 
                    note("Checking repository at '%s'."
 
426
                    note(gettext("Checking repository at '%s'.")
450
427
                         % (repo.user_url,))
451
428
                result = repo.check(None, callback_refs=needed_refs,
452
429
                    check_repo=do_repo)
453
430
                result.report_results(verbose)
454
431
        else:
455
432
            if do_tree:
456
 
                note("No working tree found at specified location.")
 
433
                note(gettext("No working tree found at specified location."))
457
434
            if do_branch:
458
 
                note("No branch found at specified location.")
 
435
                note(gettext("No branch found at specified location."))
459
436
            if do_repo:
460
 
                note("No repository found at specified location.")
 
437
                note(gettext("No repository found at specified location."))
461
438
    finally:
462
439
        for thing in to_unlock:
463
440
            thing.unlock()