32
32
# raising them. If there's more than one exception it'd be good to see them
35
"""Checking of bzr objects.
37
check_refs is a concept used for optimising check. Objects that depend on other
38
objects (e.g. tree on repository) can list the objects they would be requesting
39
so that when the dependent object is checked, matches can be pulled out and
40
evaluated in-line rather than re-reading the same data many times.
41
check_refs are tuples (kind, value). Currently defined kinds are:
43
* 'trees', where value is a revid and the looked up objects are revision trees.
44
* 'lefthand-distance', where value is a revid and the looked up objects are the
45
distance along the lefthand path to NULL for that revid.
46
* 'revision-existence', where value is a revid, and the result is True or False
47
indicating that the revision was found/not found.
50
from __future__ import absolute_import
56
from bzrlib.branch import Branch
57
from bzrlib.controldir import ControlDir
58
from bzrlib.revision import NULL_REVISION
59
from bzrlib.trace import note
60
from bzrlib.workingtree import WorkingTree
61
from bzrlib.i18n import gettext
35
from bzrlib import errors
36
from bzrlib import repository as _mod_repository
37
from bzrlib import revision
38
from bzrlib.errors import BzrCheckError
40
from bzrlib.trace import log_error, note
63
42
class Check(object):
64
43
"""Check a repository"""
66
def __init__(self, repository, check_repo=True):
67
self.repository = repository
69
def report_results(self, verbose):
70
raise NotImplementedError(self.report_results)
73
class VersionedFileCheck(Check):
74
"""Check a versioned file repository"""
76
45
# The Check object interacts with InventoryEntry.check, etc.
78
def __init__(self, repository, check_repo=True):
47
def __init__(self, repository):
79
48
self.repository = repository
49
self.checked_text_cnt = 0
80
50
self.checked_rev_cnt = 0
52
self.repeated_text_cnt = 0
82
53
self.missing_parent_links = {}
83
54
self.missing_inventory_sha_cnt = 0
84
55
self.missing_revision_cnt = 0
85
self.checked_weaves = set()
86
self.unreferenced_versions = set()
56
# maps (file-id, version) -> sha1; used by InventoryFile._check
57
self.checked_texts = {}
58
self.checked_weaves = {}
59
self.revision_versions = _mod_repository._RevisionTextVersionCache(
61
self.unreferenced_ancestors = set()
87
62
self.inconsistent_parents = []
88
self.rich_roots = repository.supports_rich_root()
89
self.text_key_references = {}
90
self.check_repo = check_repo
91
self.other_results = []
92
# Plain text lines to include in the report
93
self._report_items = []
94
# Keys we are looking for; may be large and need spilling to disk.
95
# key->(type(revision/inventory/text/signature/map), sha1, first-referer)
96
self.pending_keys = {}
97
# Ancestors map for all of revisions being checked; while large helper
98
# functions we call would create it anyway, so better to have once and
63
self.dangling_versions = set()
102
def check(self, callback_refs=None, check_repo=True):
103
if callback_refs is None:
105
66
self.repository.lock_read()
106
self.progress = ui.ui_factory.nested_progress_bar()
67
self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
108
self.progress.update(gettext('check'), 0, 4)
110
self.progress.update(gettext('checking revisions'), 0)
111
self.check_revisions()
112
self.progress.update(gettext('checking commit contents'), 1)
113
self.repository._check_inventories(self)
114
self.progress.update(gettext('checking file graphs'), 2)
115
# check_weaves is done after the revision scan so that
116
# revision index is known to be valid.
118
self.progress.update(gettext('checking branches and trees'), 3)
120
repo = self.repository
121
# calculate all refs, and callback the objects requesting them.
123
wanting_items = set()
124
# Current crude version calculates everything and calls
125
# everything at once. Doing a queue and popping as things are
126
# satisfied would be cheaper on memory [but few people have
127
# huge numbers of working trees today. TODO: fix before
131
for ref, wantlist in callback_refs.iteritems():
132
wanting_items.update(wantlist)
135
refs[ref] = repo.revision_tree(value)
136
elif kind == 'lefthand-distance':
138
elif kind == 'revision-existence':
139
existences.add(value)
141
raise AssertionError(
142
'unknown ref kind for ref %s' % ref)
143
node_distances = repo.get_graph().find_lefthand_distances(distances)
144
for key, distance in node_distances.iteritems():
145
refs[('lefthand-distance', key)] = distance
146
if key in existences and distance > 0:
147
refs[('revision-existence', key)] = True
148
existences.remove(key)
149
parent_map = repo.get_graph().get_parent_map(existences)
150
for key in parent_map:
151
refs[('revision-existence', key)] = True
152
existences.remove(key)
153
for key in existences:
154
refs[('revision-existence', key)] = False
155
for item in wanting_items:
156
if isinstance(item, WorkingTree):
158
if isinstance(item, Branch):
159
self.other_results.append(item.check(refs))
69
self.progress.update('retrieving inventory', 0, 2)
70
# do not put in init, as it should be done with progess,
71
# and inside the lock.
72
self.inventory_weave = self.repository.get_inventory_weave()
73
self.progress.update('checking revision graph', 1)
74
self.check_revision_graph()
77
while revno < len(self.planned_revisions):
78
rev_id = self.planned_revisions[revno]
79
self.progress.update('checking revision', revno,
80
len(self.planned_revisions))
82
self.check_one_rev(rev_id)
83
# check_weaves is done after the revision scan so that
84
# revision_versions is pre-populated
161
87
self.progress.finished()
162
88
self.repository.unlock()
164
def _check_revisions(self, revisions_iterator):
165
"""Check revision objects by decorating a generator.
167
:param revisions_iterator: An iterator of(revid, Revision-or-None).
168
:return: A generator of the contents of revisions_iterator.
170
self.planned_revisions = set()
171
for revid, revision in revisions_iterator:
172
yield revid, revision
173
self._check_one_rev(revid, revision)
174
# Flatten the revisions we found to guarantee consistent later
176
self.planned_revisions = list(self.planned_revisions)
177
# TODO: extract digital signatures as items to callback on too.
179
def check_revisions(self):
180
"""Scan revisions, checking data directly available as we go."""
181
revision_iterator = self.repository._iter_revisions(None)
182
revision_iterator = self._check_revisions(revision_iterator)
183
# We read the all revisions here:
184
# - doing this allows later code to depend on the revision index.
185
# - we can fill out existence flags at this point
186
# - we can read the revision inventory sha at this point
187
# - we can check properties and serialisers etc.
188
if not self.repository._format.revision_graph_can_have_wrong_parents:
189
# The check against the index isn't needed.
90
def check_revision_graph(self):
91
if not self.repository.revision_graph_can_have_wrong_parents():
92
# This check is not necessary.
190
93
self.revs_with_bad_parents_in_index = None
191
for thing in revision_iterator:
194
bad_revisions = self.repository._find_inconsistent_revision_parents(
196
self.revs_with_bad_parents_in_index = list(bad_revisions)
95
bad_revisions = self.repository._find_inconsistent_revision_parents()
96
self.revs_with_bad_parents_in_index = list(bad_revisions)
98
def plan_revisions(self):
99
repository = self.repository
100
self.planned_revisions = repository.all_revision_ids()
101
self.progress.clear()
102
inventoried = set(self.inventory_weave.versions())
103
awol = set(self.planned_revisions) - inventoried
105
raise BzrCheckError('Stored revisions missing from inventory'
106
'{%s}' % ','.join([f for f in awol]))
198
108
def report_results(self, verbose):
200
self._report_repo_results(verbose)
201
for result in self.other_results:
202
result.report_results(verbose)
204
def _report_repo_results(self, verbose):
205
note(gettext('checked repository {0} format {1}').format(
206
self.repository.user_url,
207
self.repository._format))
208
note(gettext('%6d revisions'), self.checked_rev_cnt)
209
note(gettext('%6d file-ids'), len(self.checked_weaves))
211
note(gettext('%6d unreferenced text versions'),
212
len(self.unreferenced_versions))
213
if verbose and len(self.unreferenced_versions):
214
for file_id, revision_id in self.unreferenced_versions:
215
note(gettext('unreferenced version: {{{0}}} in {1}').format(revision_id,
109
note('checked repository %s format %s',
110
self.repository.bzrdir.root_transport,
111
self.repository._format)
112
note('%6d revisions', self.checked_rev_cnt)
113
note('%6d file-ids', len(self.checked_weaves))
114
note('%6d unique file texts', self.checked_text_cnt)
115
note('%6d repeated file texts', self.repeated_text_cnt)
116
note('%6d unreferenced text ancestors',
117
len(self.unreferenced_ancestors))
217
118
if self.missing_inventory_sha_cnt:
218
note(gettext('%6d revisions are missing inventory_sha1'),
119
note('%6d revisions are missing inventory_sha1',
219
120
self.missing_inventory_sha_cnt)
220
121
if self.missing_revision_cnt:
221
note(gettext('%6d revisions are mentioned but not present'),
122
note('%6d revisions are mentioned but not present',
222
123
self.missing_revision_cnt)
223
124
if len(self.ghosts):
224
note(gettext('%6d ghost revisions'), len(self.ghosts))
125
note('%6d ghost revisions', len(self.ghosts))
226
127
for ghost in self.ghosts:
227
128
note(' %s', ghost)
228
129
if len(self.missing_parent_links):
229
note(gettext('%6d revisions missing parents in ancestry'),
130
note('%6d revisions missing parents in ancestry',
230
131
len(self.missing_parent_links))
232
133
for link, linkers in self.missing_parent_links.items():
233
note(gettext(' %s should be in the ancestry for:'), link)
134
note(' %s should be in the ancestry for:', link)
234
135
for linker in linkers:
235
136
note(' * %s', linker)
138
for file_id, revision_id in self.unreferenced_ancestors:
139
log_error('unreferenced ancestor: {%s} in %s', revision_id,
236
141
if len(self.inconsistent_parents):
237
note(gettext('%6d inconsistent parents'), len(self.inconsistent_parents))
142
note('%6d inconsistent parents', len(self.inconsistent_parents))
239
144
for info in self.inconsistent_parents:
240
145
revision_id, file_id, found_parents, correct_parents = info
241
note(gettext(' * {0} version {1} has parents {2!r} '
242
'but should have {3!r}').format(
243
file_id, revision_id, found_parents,
146
note(' * %s version %s has parents %r '
148
% (file_id, revision_id, found_parents,
244
149
correct_parents))
245
150
if self.revs_with_bad_parents_in_index:
247
'%6d revisions have incorrect parents in the revision index'),
151
note('%6d revisions have incorrect parents in the revision index',
248
152
len(self.revs_with_bad_parents_in_index))
250
154
for item in self.revs_with_bad_parents_in_index:
251
155
revision_id, index_parents, actual_parents = item
253
' {0} has wrong parents in index: '
254
'{1!r} should be {2!r}').format(
255
revision_id, index_parents, actual_parents))
256
for item in self._report_items:
259
def _check_one_rev(self, rev_id, rev):
260
"""Cross-check one revision.
262
:param rev_id: A revision id to check.
263
:param rev: A revision or None to indicate a missing revision.
157
' %s has wrong parents in index: '
159
revision_id, index_parents, actual_parents)
160
if self.dangling_versions:
161
note('%6d file versions are not referenced by their inventory',
162
len(self.dangling_versions))
164
def check_one_rev(self, rev_id):
165
"""Check one revision.
167
rev_id - the one to check
169
rev = self.repository.get_revision(rev_id)
265
171
if rev.revision_id != rev_id:
266
self._report_items.append(gettext(
267
'Mismatched internal revid {{{0}}} and index revid {{{1}}}').format(
268
rev.revision_id, rev_id))
269
rev_id = rev.revision_id
270
# Check this revision tree etc, and count as seen when we encounter a
272
self.planned_revisions.add(rev_id)
274
self.ghosts.discard(rev_id)
275
# Count all parents as ghosts if we haven't seen them yet.
172
raise BzrCheckError('wrong internal revision id in revision {%s}'
276
175
for parent in rev.parent_ids:
277
176
if not parent in self.planned_revisions:
278
self.ghosts.add(parent)
280
self.ancestors[rev_id] = tuple(rev.parent_ids) or (NULL_REVISION,)
281
self.add_pending_item(rev_id, ('inventories', rev_id), 'inventory',
177
missing_links = self.missing_parent_links.get(parent, [])
178
missing_links.append(rev_id)
179
self.missing_parent_links[parent] = missing_links
180
# list based so somewhat slow,
181
# TODO have a planned_revisions list and set.
182
if self.repository.has_revision(parent):
183
missing_ancestry = self.repository.get_ancestry(parent)
184
for missing in missing_ancestry:
185
if (missing is not None
186
and missing not in self.planned_revisions):
187
self.planned_revisions.append(missing)
189
self.ghosts.append(rev_id)
191
if rev.inventory_sha1:
192
inv_sha1 = self.repository.get_inventory_sha1(rev_id)
193
if inv_sha1 != rev.inventory_sha1:
194
raise BzrCheckError('Inventory sha1 hash doesn\'t match'
195
' value in revision {%s}' % rev_id)
196
self._check_revision_tree(rev_id)
283
197
self.checked_rev_cnt += 1
285
def add_pending_item(self, referer, key, kind, sha1):
286
"""Add a reference to a sha1 to be cross checked against a key.
288
:param referer: The referer that expects key to have sha1.
289
:param key: A storage key e.g. ('texts', 'foo@bar-20040504-1234')
290
:param kind: revision/inventory/text/map/signature
291
:param sha1: A hex sha1 or None if no sha1 is known.
293
existing = self.pending_keys.get(key)
295
if sha1 != existing[1]:
296
self._report_items.append(gettext('Multiple expected sha1s for {0}. {{{1}}}'
297
' expects {{{2}}}, {{{3}}} expects {{{4}}}').format(
298
key, referer, sha1, existing[1], existing[0]))
300
self.pending_keys[key] = (kind, sha1, referer)
302
199
def check_weaves(self):
303
200
"""Check all the weaves we can get our hands on.
306
storebar = ui.ui_factory.nested_progress_bar()
308
self._check_weaves(storebar)
312
def _check_weaves(self, storebar):
313
storebar.update('text-index', 0, 2)
314
if self.repository._format.fast_deltas:
315
# We haven't considered every fileid instance so far.
316
weave_checker = self.repository._get_versioned_file_checker(
317
ancestors=self.ancestors)
319
weave_checker = self.repository._get_versioned_file_checker(
320
text_key_references=self.text_key_references,
321
ancestors=self.ancestors)
322
storebar.update('file-graph', 1)
323
result = weave_checker.check_file_version_parents(
324
self.repository.texts)
325
self.checked_weaves = weave_checker.file_ids
326
bad_parents, unused_versions = result
327
bad_parents = bad_parents.items()
328
for text_key, (stored_parents, correct_parents) in bad_parents:
329
# XXX not ready for id join/split operations.
330
weave_id = text_key[0]
331
revision_id = text_key[-1]
332
weave_parents = tuple([parent[-1] for parent in stored_parents])
333
correct_parents = tuple([parent[-1] for parent in correct_parents])
334
self.inconsistent_parents.append(
335
(revision_id, weave_id, weave_parents, correct_parents))
336
self.unreferenced_versions.update(unused_versions)
338
def _add_entry_to_text_key_references(self, inv, entry):
339
if not self.rich_roots and entry.name == '':
341
key = (entry.file_id, entry.revision)
342
self.text_key_references.setdefault(key, False)
343
if entry.revision == inv.revision_id:
344
self.text_key_references[key] = True
347
def scan_branch(branch, needed_refs, to_unlock):
348
"""Scan a branch for refs.
350
:param branch: The branch to schedule for checking.
351
:param needed_refs: Refs we are accumulating.
352
:param to_unlock: The unlock list accumulating.
204
if self.repository.weave_store.listable():
205
weave_ids = list(self.repository.weave_store)
206
n_weaves = len(weave_ids) + 1
207
self.progress.update('checking versionedfile', 0, n_weaves)
208
self.inventory_weave.check(progress_bar=self.progress)
209
files_in_revisions = {}
210
revisions_of_files = {}
211
for i, weave_id in enumerate(weave_ids):
212
self.progress.update('checking versionedfile', i, n_weaves)
213
w = self.repository.weave_store.get_weave(weave_id,
214
self.repository.get_transaction())
215
# No progress here, because it looks ugly.
218
weave_checker = self.repository.get_versioned_file_checker(
219
self.planned_revisions, self.revision_versions)
220
result = weave_checker.check_file_version_parents(w, weave_id)
221
bad_parents, dangling_versions = result
222
bad_parents = bad_parents.items()
223
for revision_id, (weave_parents,correct_parents) in bad_parents:
224
self.inconsistent_parents.append(
225
(revision_id, weave_id, weave_parents, correct_parents))
226
if weave_parents is None:
228
unreferenced_parents = set(weave_parents)-set(correct_parents)
229
for unreferenced_parent in unreferenced_parents:
230
self.unreferenced_ancestors.add(
231
(weave_id, unreferenced_parent))
232
self.dangling_versions.update(dangling_versions)
233
self.checked_weaves[weave_id] = True
235
def _check_revision_tree(self, rev_id):
236
tree = self.repository.revision_tree(rev_id)
237
self.revision_versions.add_revision_text_versions(tree)
241
if file_id in seen_ids:
242
raise BzrCheckError('duplicated file_id {%s} '
243
'in inventory for revision {%s}'
245
seen_ids[file_id] = True
248
ie.check(self, rev_id, inv, tree)
250
for path, ie in inv.iter_entries():
251
if path in seen_names:
252
raise BzrCheckError('duplicated path %s '
253
'in inventory for revision {%s}'
255
seen_names[path] = True
258
def check(branch, verbose):
259
"""Run consistency checks on a branch.
261
Results are reported through logging.
263
:raise BzrCheckError: if there's a consistency error.
354
note(gettext("Checking branch at '%s'.") % (branch.base,))
355
265
branch.lock_read()
356
to_unlock.append(branch)
357
branch_refs = branch._get_check_refs()
358
for ref in branch_refs:
359
reflist = needed_refs.setdefault(ref, [])
360
reflist.append(branch)
363
def scan_tree(base_tree, tree, needed_refs, to_unlock):
364
"""Scan a tree for refs.
366
:param base_tree: The original tree check opened, used to detect duplicate
368
:param tree: The tree to schedule for checking.
369
:param needed_refs: Refs we are accumulating.
370
:param to_unlock: The unlock list accumulating.
372
if base_tree is not None and tree.basedir == base_tree.basedir:
374
note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
376
to_unlock.append(tree)
377
tree_refs = tree._get_check_refs()
378
for ref in tree_refs:
379
reflist = needed_refs.setdefault(ref, [])
383
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
384
"""Check multiple objects.
386
If errors occur they are accumulated and reported as far as possible, and
387
an exception raised at the end of the process.
390
base_tree, branch, repo, relpath = \
391
ControlDir.open_containing_tree_branch_or_repository(path)
392
except errors.NotBranchError:
393
base_tree = branch = repo = None
398
if base_tree is not None:
399
# If the tree is a lightweight checkout we won't see it in
400
# repo.find_branches - add now.
402
scan_tree(None, base_tree, needed_refs, to_unlock)
403
branch = base_tree.branch
404
if branch is not None:
407
# The branch is in a shared repository
408
repo = branch.repository
411
to_unlock.append(repo)
412
branches = repo.find_branches(using=True)
414
if do_branch or do_tree:
415
for branch in branches:
418
tree = branch.bzrdir.open_workingtree()
420
except (errors.NotLocalUrl, errors.NoWorkingTree):
423
scan_tree(base_tree, tree, needed_refs, to_unlock)
425
scan_branch(branch, needed_refs, to_unlock)
426
if do_branch and not branches:
427
note(gettext("No branch found at specified location."))
428
if do_tree and base_tree is None and not saw_tree:
429
note(gettext("No working tree found at specified location."))
430
if do_repo or do_branch or do_tree:
432
note(gettext("Checking repository at '%s'.")
434
result = repo.check(None, callback_refs=needed_refs,
436
result.report_results(verbose)
439
note(gettext("No working tree found at specified location."))
441
note(gettext("No branch found at specified location."))
443
note(gettext("No repository found at specified location."))
267
branch_result = branch.check()
268
repo_result = branch.repository.check([branch.last_revision()])
445
for thing in to_unlock:
271
branch_result.report_results(verbose)
272
repo_result.report_results(verbose)
added
removed
bzrlib/check.py
