60
52
self.missing_revision_cnt = 0
61
53
# maps (file-id, version) -> sha1; used by InventoryFile._check
62
54
self.checked_texts = {}
63
self.checked_weaves = set()
64
self.unreferenced_versions = set()
65
self.inconsistent_parents = []
66
self.rich_roots = repository.supports_rich_root()
67
self.text_key_references = {}
55
self.checked_weaves = {}
70
58
self.repository.lock_read()
71
59
self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
73
self.progress.update('retrieving inventory', 0, 2)
61
self.progress.update('retrieving inventory', 0, 0)
74
62
# do not put in init, as it should be done with progess,
75
63
# and inside the lock.
76
self.inventory_weave = self.repository.inventories
77
self.progress.update('checking revision graph', 1)
78
self.check_revision_graph()
64
self.inventory_weave = self.repository.get_inventory_weave()
79
65
self.plan_revisions()
81
68
while revno < len(self.planned_revisions):
82
69
rev_id = self.planned_revisions[revno]
83
70
self.progress.update('checking revision', revno,
84
71
len(self.planned_revisions))
86
73
self.check_one_rev(rev_id)
87
# check_weaves is done after the revision scan so that
88
# revision index is known to be valid.
91
75
self.progress.finished()
92
76
self.repository.unlock()
94
def check_revision_graph(self):
95
if not self.repository.revision_graph_can_have_wrong_parents():
96
# This check is not necessary.
97
self.revs_with_bad_parents_in_index = None
99
bad_revisions = self.repository._find_inconsistent_revision_parents()
100
self.revs_with_bad_parents_in_index = list(bad_revisions)
102
78
def plan_revisions(self):
103
79
repository = self.repository
104
self.planned_revisions = repository.all_revision_ids()
80
self.planned_revisions = set(repository.all_revision_ids())
105
81
self.progress.clear()
106
inventoried = set(key[-1] for key in self.inventory_weave.keys())
107
awol = set(self.planned_revisions) - inventoried
82
inventoried = set(self.inventory_weave.versions())
83
awol = self.planned_revisions - inventoried
109
85
raise BzrCheckError('Stored revisions missing from inventory'
110
86
'{%s}' % ','.join([f for f in awol]))
87
self.planned_revisions = list(self.planned_revisions)
112
89
def report_results(self, verbose):
113
90
note('checked repository %s format %s',
114
91
self.repository.bzrdir.root_transport,
115
92
self.repository._format)
116
93
note('%6d revisions', self.checked_rev_cnt)
117
note('%6d file-ids', len(self.checked_weaves))
118
94
note('%6d unique file texts', self.checked_text_cnt)
119
95
note('%6d repeated file texts', self.repeated_text_cnt)
120
note('%6d unreferenced text versions',
121
len(self.unreferenced_versions))
96
note('%6d weaves', len(self.checked_weaves))
122
97
if self.missing_inventory_sha_cnt:
123
98
note('%6d revisions are missing inventory_sha1',
124
99
self.missing_inventory_sha_cnt)
138
113
note(' %s should be in the ancestry for:', link)
139
114
for linker in linkers:
140
115
note(' * %s', linker)
142
for file_id, revision_id in self.unreferenced_versions:
143
log_error('unreferenced version: {%s} in %s', revision_id,
145
if len(self.inconsistent_parents):
146
note('%6d inconsistent parents', len(self.inconsistent_parents))
148
for info in self.inconsistent_parents:
149
revision_id, file_id, found_parents, correct_parents = info
150
note(' * %s version %s has parents %r '
152
% (file_id, revision_id, found_parents,
154
if self.revs_with_bad_parents_in_index:
155
note('%6d revisions have incorrect parents in the revision index',
156
len(self.revs_with_bad_parents_in_index))
158
for item in self.revs_with_bad_parents_in_index:
159
revision_id, index_parents, actual_parents = item
161
' %s has wrong parents in index: '
163
revision_id, index_parents, actual_parents)
165
117
def check_one_rev(self, rev_id):
166
118
"""Check one revision.
206
152
def check_weaves(self):
207
153
"""Check all the weaves we can get our hands on.
210
self.progress.update('checking inventory', 0, 2)
157
if self.repository.weave_store.listable():
158
weave_ids = list(self.repository.weave_store)
159
n_weaves = len(weave_ids)
160
self.progress.update('checking weave', 0, n_weaves)
211
161
self.inventory_weave.check(progress_bar=self.progress)
212
self.progress.update('checking text storage', 1, 2)
213
self.repository.texts.check(progress_bar=self.progress)
214
weave_checker = self.repository._get_versioned_file_checker(
215
text_key_references=self.text_key_references)
216
result = weave_checker.check_file_version_parents(
217
self.repository.texts, progress_bar=self.progress)
218
self.checked_weaves = weave_checker.file_ids
219
bad_parents, unused_versions = result
220
bad_parents = bad_parents.items()
221
for text_key, (stored_parents, correct_parents) in bad_parents:
222
# XXX not ready for id join/split operations.
223
weave_id = text_key[0]
224
revision_id = text_key[-1]
225
weave_parents = tuple([parent[-1] for parent in stored_parents])
226
correct_parents = tuple([parent[-1] for parent in correct_parents])
227
self.inconsistent_parents.append(
228
(revision_id, weave_id, weave_parents, correct_parents))
229
self.unreferenced_versions.update(unused_versions)
162
for i, weave_id in enumerate(weave_ids):
163
self.progress.update('checking weave', i, n_weaves)
164
w = self.repository.weave_store.get_weave(weave_id,
165
self.repository.get_transaction())
166
# No progress here, because it looks ugly.
168
self.checked_weaves[weave_id] = True
231
170
def _check_revision_tree(self, rev_id):
232
171
tree = self.repository.revision_tree(rev_id)
233
172
inv = tree.inventory
236
for path, ie in inv.iter_entries():
237
self._add_entry_to_text_key_references(inv, ie)
239
175
if file_id in seen_ids:
240
176
raise BzrCheckError('duplicated file_id {%s} '
241
177
'in inventory for revision {%s}'
242
178
% (file_id, rev_id))
243
seen_ids.add(file_id)
179
seen_ids[file_id] = True
244
182
ie.check(self, rev_id, inv, tree)
184
for path, ie in inv.iter_entries():
245
185
if path in seen_names:
246
186
raise BzrCheckError('duplicated path %s '
247
187
'in inventory for revision {%s}'
248
188
% (path, rev_id))
251
def _add_entry_to_text_key_references(self, inv, entry):
252
if not self.rich_roots and entry == inv.root:
254
key = (entry.file_id, entry.revision)
255
self.text_key_references.setdefault(key, False)
256
if entry.revision == inv.revision_id:
257
self.text_key_references[key] = True
260
@deprecated_function(deprecated_in((1,6,0)))
189
seen_names[path] = True
261
192
def check(branch, verbose):
262
193
"""Run consistency checks on a branch.
264
Results are reported through logging.
266
Deprecated in 1.6. Please use check_branch instead.
268
:raise BzrCheckError: if there's a consistency error.
270
check_branch(branch, verbose)
273
def check_branch(branch, verbose):
274
"""Run consistency checks on a branch.
276
Results are reported through logging.
195
Results are reported through logging.
278
197
:raise BzrCheckError: if there's a consistency error.
280
199
branch.lock_read()
282
201
branch_result = branch.check()
202
repo_result = branch.repository.check([branch.last_revision()])
285
205
branch_result.report_results(verbose)
288
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
290
tree, branch, repo, relpath = \
291
BzrDir.open_containing_tree_branch_or_repository(path)
292
except errors.NotBranchError:
293
tree = branch = repo = None
297
note("Checking working tree at '%s'."
298
% (tree.bzrdir.root_transport.base,))
301
log_error("No working tree found at specified location.")
303
if branch is not None:
306
# The branch is in a shared repository
307
repo = branch.repository
309
elif repo is not None:
310
branches = repo.find_branches(using=True)
316
note("Checking repository at '%s'."
317
% (repo.bzrdir.root_transport.base,))
318
result = repo.check()
319
result.report_results(verbose)
322
log_error("No branch found at specified location.")
324
for branch in branches:
325
note("Checking branch at '%s'."
326
% (branch.bzrdir.root_transport.base,))
327
check_branch(branch, verbose)
332
log_error("No branch found at specified location.")
334
log_error("No repository found at specified location.")
206
repo_result.report_results(verbose)