~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-25 06:51:31 UTC
  • mfrom: (5016.3.4 502076-dirty-patches)
  • Revision ID: pqm@pqm.ubuntu.com-20100225065131-kk37qbxhedr2oyzy
(mbp, for toshio) handle noise at the start of patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
# TODO: Check ancestries are correct for every revision: includes
19
18
# every committed so far, and in a reasonable order.
22
21
 
23
22
# TODO: Check for extra files in the control directory.
24
23
 
25
 
# TODO: Check revision, inventory and entry objects have all 
 
24
# TODO: Check revision, inventory and entry objects have all
26
25
# required fields.
27
26
 
28
27
# TODO: Get every revision in the revision-store even if they're not
29
28
# referenced by history and make sure they're all valid.
30
29
 
 
30
# TODO: Perhaps have a way to record errors other than by raising exceptions;
 
31
# would perhaps be enough to accumulate exception objects in a list without
 
32
# raising them.  If there's more than one exception it'd be good to see them
 
33
# all.
 
34
 
 
35
"""Checking of bzr objects.
 
36
 
 
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:
 
42
* 'trees', where value is a revid and the looked up objects are revision trees.
 
43
* 'lefthand-distance', where value is a revid and the looked up objects are the
 
44
  distance along the lefthand path to NULL for that revid.
 
45
* 'revision-existence', where value is a revid, and the result is True or False
 
46
  indicating that the revision was found/not found.
 
47
"""
 
48
 
 
49
from bzrlib import errors, osutils
 
50
from bzrlib import repository as _mod_repository
 
51
from bzrlib import revision
 
52
from bzrlib.branch import Branch
 
53
from bzrlib.bzrdir import BzrDir
 
54
from bzrlib.errors import BzrCheckError
 
55
from bzrlib.repository import Repository
 
56
from bzrlib.revision import NULL_REVISION
 
57
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
 
58
from bzrlib.trace import note
31
59
import bzrlib.ui
32
 
from bzrlib.trace import note, warning
33
 
from bzrlib.osutils import rename, sha_string, fingerprint_file
34
 
from bzrlib.trace import mutter
35
 
from bzrlib.errors import BzrCheckError, NoSuchRevision
36
 
from bzrlib.inventory import ROOT_ID
37
 
 
 
60
from bzrlib.workingtree import WorkingTree
38
61
 
39
62
class Check(object):
40
 
    """Check a branch"""
41
 
 
42
 
    def __init__(self, branch):
43
 
        self.branch = branch
44
 
        self.repository = branch.repository
45
 
        self.checked_text_cnt = 0
 
63
    """Check a repository"""
 
64
 
 
65
    # The Check object interacts with InventoryEntry.check, etc.
 
66
 
 
67
    def __init__(self, repository, check_repo=True):
 
68
        self.repository = repository
46
69
        self.checked_rev_cnt = 0
47
 
        self.ghosts = []
48
 
        self.repeated_text_cnt = 0
 
70
        self.ghosts = set()
49
71
        self.missing_parent_links = {}
50
72
        self.missing_inventory_sha_cnt = 0
51
73
        self.missing_revision_cnt = 0
52
 
        # maps (file-id, version) -> sha1
53
 
        self.checked_texts = {}
54
 
        self.checked_weaves = {}
 
74
        self.checked_weaves = set()
 
75
        self.unreferenced_versions = set()
 
76
        self.inconsistent_parents = []
 
77
        self.rich_roots = repository.supports_rich_root()
 
78
        self.text_key_references = {}
 
79
        self.check_repo = check_repo
 
80
        self.other_results = []
 
81
        # Plain text lines to include in the report
 
82
        self._report_items = []
 
83
        # Keys we are looking for; may be large and need spilling to disk.
 
84
        # key->(type(revision/inventory/text/signature/map), sha1, first-referer)
 
85
        self.pending_keys = {}
 
86
        # Ancestors map for all of revisions being checked; while large helper
 
87
        # functions we call would create it anyway, so better to have once and
 
88
        # keep.
 
89
        self.ancestors = {}
55
90
 
56
 
    def check(self):
57
 
        self.branch.lock_read()
58
 
        self.progress = bzrlib.ui.ui_factory.progress_bar()
 
91
    def check(self, callback_refs=None, check_repo=True):
 
92
        if callback_refs is None:
 
93
            callback_refs = {}
 
94
        self.repository.lock_read()
 
95
        self.progress = bzrlib.ui.ui_factory.nested_progress_bar()
59
96
        try:
60
 
            self.progress.update('retrieving inventory', 0, 0)
61
 
            # do not put in init, as it should be done with progess,
62
 
            # and inside the lock.
63
 
            self.inventory_weave = self.branch.repository.get_inventory_weave()
64
 
            self.history = self.branch.revision_history()
65
 
            if not len(self.history):
66
 
                # nothing to see here
67
 
                return
68
 
            self.plan_revisions()
69
 
            revno = 0
70
 
            self.check_weaves()
71
 
            while revno < len(self.planned_revisions):
72
 
                rev_id = self.planned_revisions[revno]
73
 
                self.progress.update('checking revision', revno,
74
 
                                     len(self.planned_revisions))
75
 
                revno += 1
76
 
                self.check_one_rev(rev_id)
 
97
            self.progress.update('check', 0, 4)
 
98
            if self.check_repo:
 
99
                self.progress.update('checking revisions', 0)
 
100
                self.check_revisions()
 
101
                self.progress.update('checking commit contents', 1)
 
102
                self.repository._check_inventories(self)
 
103
                self.progress.update('checking file graphs', 2)
 
104
                # check_weaves is done after the revision scan so that
 
105
                # revision index is known to be valid.
 
106
                self.check_weaves()
 
107
            self.progress.update('checking branches and trees', 3)
 
108
            if callback_refs:
 
109
                repo = self.repository
 
110
                # calculate all refs, and callback the objects requesting them.
 
111
                refs = {}
 
112
                wanting_items = set()
 
113
                # Current crude version calculates everything and calls
 
114
                # everything at once. Doing a queue and popping as things are
 
115
                # satisfied would be cheaper on memory [but few people have
 
116
                # huge numbers of working trees today. TODO: fix before
 
117
                # landing].
 
118
                distances = set()
 
119
                existences = set()
 
120
                for ref, wantlist in callback_refs.iteritems():
 
121
                    wanting_items.update(wantlist)
 
122
                    kind, value = ref
 
123
                    if kind == 'trees':
 
124
                        refs[ref] = repo.revision_tree(value)
 
125
                    elif kind == 'lefthand-distance':
 
126
                        distances.add(value)
 
127
                    elif kind == 'revision-existence':
 
128
                        existences.add(value)
 
129
                    else:
 
130
                        raise AssertionError(
 
131
                            'unknown ref kind for ref %s' % ref)
 
132
                node_distances = repo.get_graph().find_lefthand_distances(distances)
 
133
                for key, distance in node_distances.iteritems():
 
134
                    refs[('lefthand-distance', key)] = distance
 
135
                    if key in existences and distance > 0:
 
136
                        refs[('revision-existence', key)] = True
 
137
                        existences.remove(key)
 
138
                parent_map = repo.get_graph().get_parent_map(existences)
 
139
                for key in parent_map:
 
140
                    refs[('revision-existence', key)] = True
 
141
                    existences.remove(key)
 
142
                for key in existences:
 
143
                    refs[('revision-existence', key)] = False
 
144
                for item in wanting_items:
 
145
                    if isinstance(item, WorkingTree):
 
146
                        item._check(refs)
 
147
                    if isinstance(item, Branch):
 
148
                        self.other_results.append(item.check(refs))
77
149
        finally:
78
 
            self.progress.clear()
79
 
            self.branch.unlock()
80
 
 
81
 
    def plan_revisions(self):
82
 
        repository = self.branch.repository
83
 
        if not repository.revision_store.listable():
84
 
            self.planned_revisions = repository.get_ancestry(self.history[-1])
85
 
            self.planned_revisions.remove(None)
86
 
            # FIXME progress bars should support this more nicely.
87
 
            self.progress.clear()
88
 
            print ("Checking reachable history -"
89
 
                   " for a complete check use a local branch.")
90
 
            return
91
 
        
92
 
        self.planned_revisions = set(repository.revision_store)
93
 
        inventoried = set(self.inventory_weave.names())
94
 
        awol = self.planned_revisions - inventoried
95
 
        if len(awol) > 0:
96
 
            raise BzrCheckError('Stored revisions missing from inventory'
97
 
                '{%s}' % ','.join([f for f in awol]))
 
150
            self.progress.finished()
 
151
            self.repository.unlock()
 
152
 
 
153
    def _check_revisions(self, revisions_iterator):
 
154
        """Check revision objects by decorating a generator.
 
155
 
 
156
        :param revisions_iterator: An iterator of(revid, Revision-or-None).
 
157
        :return: A generator of the contents of revisions_iterator.
 
158
        """
 
159
        self.planned_revisions = set()
 
160
        for revid, revision in revisions_iterator:
 
161
            yield revid, revision
 
162
            self._check_one_rev(revid, revision)
 
163
        # Flatten the revisions we found to guarantee consistent later
 
164
        # iteration.
98
165
        self.planned_revisions = list(self.planned_revisions)
 
166
        # TODO: extract digital signatures as items to callback on too.
 
167
 
 
168
    def check_revisions(self):
 
169
        """Scan revisions, checking data directly available as we go."""
 
170
        revision_iterator = self.repository._iter_revisions(None)
 
171
        revision_iterator = self._check_revisions(revision_iterator)
 
172
        # We read the all revisions here:
 
173
        # - doing this allows later code to depend on the revision index.
 
174
        # - we can fill out existence flags at this point
 
175
        # - we can read the revision inventory sha at this point
 
176
        # - we can check properties and serialisers etc.
 
177
        if not self.repository.revision_graph_can_have_wrong_parents():
 
178
            # The check against the index isn't needed.
 
179
            self.revs_with_bad_parents_in_index = None
 
180
            for thing in revision_iterator:
 
181
                pass
 
182
        else:
 
183
            bad_revisions = self.repository._find_inconsistent_revision_parents(
 
184
                revision_iterator)
 
185
            self.revs_with_bad_parents_in_index = list(bad_revisions)
99
186
 
100
187
    def report_results(self, verbose):
101
 
        note('checked branch %s format %d',
102
 
             self.branch.base, 
103
 
             self.branch._branch_format)
 
188
        if self.check_repo:
 
189
            self._report_repo_results(verbose)
 
190
        for result in self.other_results:
 
191
            result.report_results(verbose)
104
192
 
 
193
    def _report_repo_results(self, verbose):
 
194
        note('checked repository %s format %s',
 
195
             self.repository.bzrdir.root_transport,
 
196
             self.repository._format)
105
197
        note('%6d revisions', self.checked_rev_cnt)
106
 
        note('%6d unique file texts', self.checked_text_cnt)
107
 
        note('%6d repeated file texts', self.repeated_text_cnt)
108
 
        note('%6d weaves', len(self.checked_weaves))
 
198
        note('%6d file-ids', len(self.checked_weaves))
 
199
        if verbose:
 
200
            note('%6d unreferenced text versions',
 
201
                len(self.unreferenced_versions))
 
202
        if verbose and len(self.unreferenced_versions):
 
203
                for file_id, revision_id in self.unreferenced_versions:
 
204
                    note('unreferenced version: {%s} in %s', revision_id,
 
205
                        file_id)
109
206
        if self.missing_inventory_sha_cnt:
110
207
            note('%6d revisions are missing inventory_sha1',
111
208
                 self.missing_inventory_sha_cnt)
118
215
                for ghost in self.ghosts:
119
216
                    note('      %s', ghost)
120
217
        if len(self.missing_parent_links):
121
 
            note('%6d revisions missing parents in ancestry', 
 
218
            note('%6d revisions missing parents in ancestry',
122
219
                 len(self.missing_parent_links))
123
220
            if verbose:
124
221
                for link, linkers in self.missing_parent_links.items():
125
222
                    note('      %s should be in the ancestry for:', link)
126
223
                    for linker in linkers:
127
224
                        note('       * %s', linker)
128
 
 
129
 
    def check_one_rev(self, rev_id):
130
 
        """Check one revision.
131
 
 
132
 
        rev_id - the one to check
133
 
 
134
 
        last_rev_id - the previous one on the mainline, if any.
 
225
        if len(self.inconsistent_parents):
 
226
            note('%6d inconsistent parents', len(self.inconsistent_parents))
 
227
            if verbose:
 
228
                for info in self.inconsistent_parents:
 
229
                    revision_id, file_id, found_parents, correct_parents = info
 
230
                    note('      * %s version %s has parents %r '
 
231
                         'but should have %r'
 
232
                         % (file_id, revision_id, found_parents,
 
233
                             correct_parents))
 
234
        if self.revs_with_bad_parents_in_index:
 
235
            note('%6d revisions have incorrect parents in the revision index',
 
236
                 len(self.revs_with_bad_parents_in_index))
 
237
            if verbose:
 
238
                for item in self.revs_with_bad_parents_in_index:
 
239
                    revision_id, index_parents, actual_parents = item
 
240
                    note(
 
241
                        '       %s has wrong parents in index: '
 
242
                        '%r should be %r',
 
243
                        revision_id, index_parents, actual_parents)
 
244
        for item in self._report_items:
 
245
            note(item)
 
246
 
 
247
    def _check_one_rev(self, rev_id, rev):
 
248
        """Cross-check one revision.
 
249
 
 
250
        :param rev_id: A revision id to check.
 
251
        :param rev: A revision or None to indicate a missing revision.
135
252
        """
136
 
 
137
 
        # mutter('    revision {%s}', rev_id)
138
 
        branch = self.branch
139
 
        try:
140
 
            rev_history_position = self.history.index(rev_id)
141
 
        except ValueError:
142
 
            rev_history_position = None
143
 
        last_rev_id = None
144
 
        if rev_history_position:
145
 
            rev = branch.repository.get_revision(rev_id)
146
 
            if rev_history_position > 0:
147
 
                last_rev_id = self.history[rev_history_position - 1]
148
 
        else:
149
 
            rev = branch.repository.get_revision(rev_id)
150
 
                
151
253
        if rev.revision_id != rev_id:
152
 
            raise BzrCheckError('wrong internal revision id in revision {%s}'
153
 
                                % rev_id)
154
 
 
155
 
        # check the previous history entry is a parent of this entry
156
 
        if rev.parent_ids:
157
 
            if last_rev_id is not None:
158
 
                for parent_id in rev.parent_ids:
159
 
                    if parent_id == last_rev_id:
160
 
                        break
161
 
                else:
162
 
                    raise BzrCheckError("previous revision {%s} not listed among "
163
 
                                        "parents of {%s}"
164
 
                                        % (last_rev_id, rev_id))
165
 
            for parent in rev.parent_ids:
166
 
                if not parent in self.planned_revisions:
167
 
                    missing_links = self.missing_parent_links.get(parent, [])
168
 
                    missing_links.append(rev_id)
169
 
                    self.missing_parent_links[parent] = missing_links
170
 
                    # list based so somewhat slow,
171
 
                    # TODO have a planned_revisions list and set.
172
 
                    if self.branch.has_revision(parent):
173
 
                        missing_ancestry = self.repository.get_ancestry(parent)
174
 
                        for missing in missing_ancestry:
175
 
                            if (missing is not None 
176
 
                                and missing not in self.planned_revisions):
177
 
                                self.planned_revisions.append(missing)
178
 
                    else:
179
 
                        self.ghosts.append(rev_id)
180
 
        elif last_rev_id:
181
 
            raise BzrCheckError("revision {%s} has no parents listed "
182
 
                                "but preceded by {%s}"
183
 
                                % (rev_id, last_rev_id))
184
 
 
185
 
        if rev.inventory_sha1:
186
 
            inv_sha1 = branch.repository.get_inventory_sha1(rev_id)
187
 
            if inv_sha1 != rev.inventory_sha1:
188
 
                raise BzrCheckError('Inventory sha1 hash doesn\'t match'
189
 
                    ' value in revision {%s}' % rev_id)
190
 
        else:
191
 
            missing_inventory_sha_cnt += 1
192
 
            mutter("no inventory_sha1 on revision {%s}", rev_id)
193
 
        self._check_revision_tree(rev_id)
 
254
            self._report_items.append(
 
255
                'Mismatched internal revid {%s} and index revid {%s}' % (
 
256
                rev.revision_id, rev_id))
 
257
            rev_id = rev.revision_id
 
258
        # Check this revision tree etc, and count as seen when we encounter a
 
259
        # reference to it.
 
260
        self.planned_revisions.add(rev_id)
 
261
        # It is not a ghost
 
262
        self.ghosts.discard(rev_id)
 
263
        # Count all parents as ghosts if we haven't seen them yet.
 
264
        for parent in rev.parent_ids:
 
265
            if not parent in self.planned_revisions:
 
266
                self.ghosts.add(parent)
 
267
        
 
268
        self.ancestors[rev_id] = tuple(rev.parent_ids) or (NULL_REVISION,)
 
269
        self.add_pending_item(rev_id, ('inventories', rev_id), 'inventory',
 
270
            rev.inventory_sha1)
194
271
        self.checked_rev_cnt += 1
195
272
 
 
273
    def add_pending_item(self, referer, key, kind, sha1):
 
274
        """Add a reference to a sha1 to be cross checked against a key.
 
275
 
 
276
        :param referer: The referer that expects key to have sha1.
 
277
        :param key: A storage key e.g. ('texts', 'foo@bar-20040504-1234')
 
278
        :param kind: revision/inventory/text/map/signature
 
279
        :param sha1: A hex sha1 or None if no sha1 is known.
 
280
        """
 
281
        existing = self.pending_keys.get(key)
 
282
        if existing:
 
283
            if sha1 != existing[1]:
 
284
                self._report_items.append('Multiple expected sha1s for %s. {%s}'
 
285
                    ' expects {%s}, {%s} expects {%s}', (
 
286
                    key, referer, sha1, existing[1], existing[0]))
 
287
        else:
 
288
            self.pending_keys[key] = (kind, sha1, referer)
 
289
 
196
290
    def check_weaves(self):
197
291
        """Check all the weaves we can get our hands on.
198
292
        """
199
 
        n_weaves = 1
200
293
        weave_ids = []
201
 
        if self.branch.repository.weave_store.listable():
202
 
            weave_ids = list(self.branch.repository.weave_store)
203
 
            n_weaves = len(weave_ids)
204
 
        self.progress.update('checking weave', 0, n_weaves)
205
 
        self.inventory_weave.check(progress_bar=self.progress)
206
 
        for i, weave_id in enumerate(weave_ids):
207
 
            self.progress.update('checking weave', i, n_weaves)
208
 
            w = self.branch.repository.weave_store.get_weave(weave_id,
209
 
                    self.branch.repository.get_transaction())
210
 
            # No progress here, because it looks ugly.
211
 
            w.check()
212
 
            self.checked_weaves[weave_id] = True
213
 
 
214
 
    def _check_revision_tree(self, rev_id):
215
 
        tree = self.branch.repository.revision_tree(rev_id)
216
 
        inv = tree.inventory
217
 
        seen_ids = {}
218
 
        for file_id in inv:
219
 
            if file_id in seen_ids:
220
 
                raise BzrCheckError('duplicated file_id {%s} '
221
 
                                    'in inventory for revision {%s}'
222
 
                                    % (file_id, rev_id))
223
 
            seen_ids[file_id] = True
224
 
        for file_id in inv:
225
 
            ie = inv[file_id]
226
 
            ie.check(self, rev_id, inv, tree)
227
 
        seen_names = {}
228
 
        for path, ie in inv.iter_entries():
229
 
            if path in seen_names:
230
 
                raise BzrCheckError('duplicated path %s '
231
 
                                    'in inventory for revision {%s}'
232
 
                                    % (path, rev_id))
233
 
            seen_names[path] = True
234
 
 
235
 
 
 
294
        storebar = bzrlib.ui.ui_factory.nested_progress_bar()
 
295
        try:
 
296
            self._check_weaves(storebar)
 
297
        finally:
 
298
            storebar.finished()
 
299
 
 
300
    def _check_weaves(self, storebar):
 
301
        storebar.update('text-index', 0, 2)
 
302
        if self.repository._format.fast_deltas:
 
303
            # We haven't considered every fileid instance so far.
 
304
            weave_checker = self.repository._get_versioned_file_checker(
 
305
                ancestors=self.ancestors)
 
306
        else:
 
307
            weave_checker = self.repository._get_versioned_file_checker(
 
308
                text_key_references=self.text_key_references,
 
309
                ancestors=self.ancestors)
 
310
        storebar.update('file-graph', 1)
 
311
        result = weave_checker.check_file_version_parents(
 
312
            self.repository.texts)
 
313
        self.checked_weaves = weave_checker.file_ids
 
314
        bad_parents, unused_versions = result
 
315
        bad_parents = bad_parents.items()
 
316
        for text_key, (stored_parents, correct_parents) in bad_parents:
 
317
            # XXX not ready for id join/split operations.
 
318
            weave_id = text_key[0]
 
319
            revision_id = text_key[-1]
 
320
            weave_parents = tuple([parent[-1] for parent in stored_parents])
 
321
            correct_parents = tuple([parent[-1] for parent in correct_parents])
 
322
            self.inconsistent_parents.append(
 
323
                (revision_id, weave_id, weave_parents, correct_parents))
 
324
        self.unreferenced_versions.update(unused_versions)
 
325
 
 
326
    def _add_entry_to_text_key_references(self, inv, entry):
 
327
        if not self.rich_roots and entry.name == '':
 
328
            return
 
329
        key = (entry.file_id, entry.revision)
 
330
        self.text_key_references.setdefault(key, False)
 
331
        if entry.revision == inv.revision_id:
 
332
            self.text_key_references[key] = True
 
333
 
 
334
 
 
335
@deprecated_function(deprecated_in((1,6,0)))
236
336
def check(branch, verbose):
237
 
    """Run consistency checks on a branch."""
238
 
    checker = Check(branch)
239
 
    checker.check()
240
 
    checker.report_results(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
 
 
368
def scan_branch(branch, needed_refs, to_unlock):
 
369
    """Scan a branch for refs.
 
370
 
 
371
    :param branch:  The branch to schedule for checking.
 
372
    :param needed_refs: Refs we are accumulating.
 
373
    :param to_unlock: The unlock list accumulating.
 
374
    """
 
375
    note("Checking branch at '%s'." % (branch.base,))
 
376
    branch.lock_read()
 
377
    to_unlock.append(branch)
 
378
    branch_refs = branch._get_check_refs()
 
379
    for ref in branch_refs:
 
380
        reflist = needed_refs.setdefault(ref, [])
 
381
        reflist.append(branch)
 
382
 
 
383
 
 
384
def scan_tree(base_tree, tree, needed_refs, to_unlock):
 
385
    """Scan a tree for refs.
 
386
 
 
387
    :param base_tree: The original tree check opened, used to detect duplicate
 
388
        tree checks.
 
389
    :param tree:  The tree to schedule for checking.
 
390
    :param needed_refs: Refs we are accumulating.
 
391
    :param to_unlock: The unlock list accumulating.
 
392
    """
 
393
    if base_tree is not None and tree.basedir == base_tree.basedir:
 
394
        return
 
395
    note("Checking working tree at '%s'." % (tree.basedir,))
 
396
    tree.lock_read()
 
397
    to_unlock.append(tree)
 
398
    tree_refs = tree._get_check_refs()
 
399
    for ref in tree_refs:
 
400
        reflist = needed_refs.setdefault(ref, [])
 
401
        reflist.append(tree)
 
402
 
 
403
 
 
404
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
 
405
    """Check multiple objects.
 
406
 
 
407
    If errors occur they are accumulated and reported as far as possible, and
 
408
    an exception raised at the end of the process.
 
409
    """
 
410
    try:
 
411
        base_tree, branch, repo, relpath = \
 
412
                        BzrDir.open_containing_tree_branch_or_repository(path)
 
413
    except errors.NotBranchError:
 
414
        base_tree = branch = repo = None
 
415
 
 
416
    to_unlock = []
 
417
    needed_refs= {}
 
418
    try:
 
419
        if base_tree is not None:
 
420
            # If the tree is a lightweight checkout we won't see it in
 
421
            # repo.find_branches - add now.
 
422
            if do_tree:
 
423
                scan_tree(None, base_tree, needed_refs, to_unlock)
 
424
            branch = base_tree.branch
 
425
        if branch is not None:
 
426
            # We have a branch
 
427
            if repo is None:
 
428
                # The branch is in a shared repository
 
429
                repo = branch.repository
 
430
        if repo is not None:
 
431
            repo.lock_read()
 
432
            to_unlock.append(repo)
 
433
            branches = repo.find_branches(using=True)
 
434
            saw_tree = False
 
435
            if do_branch or do_tree:
 
436
                for branch in branches:
 
437
                    if do_tree:
 
438
                        try:
 
439
                            tree = branch.bzrdir.open_workingtree()
 
440
                            saw_tree = True
 
441
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
442
                            pass
 
443
                        else:
 
444
                            scan_tree(base_tree, tree, needed_refs, to_unlock)
 
445
                    if do_branch:
 
446
                        scan_branch(branch, needed_refs, to_unlock)
 
447
            if do_branch and not branches:
 
448
                note("No branch found at specified location.")
 
449
            if do_tree and base_tree is None and not saw_tree:
 
450
                note("No working tree found at specified location.")
 
451
            if do_repo or do_branch or do_tree:
 
452
                if do_repo:
 
453
                    note("Checking repository at '%s'."
 
454
                         % (repo.bzrdir.root_transport.base,))
 
455
                result = repo.check(None, callback_refs=needed_refs,
 
456
                    check_repo=do_repo)
 
457
                result.report_results(verbose)
 
458
        else:
 
459
            if do_tree:
 
460
                note("No working tree found at specified location.")
 
461
            if do_branch:
 
462
                note("No branch found at specified location.")
 
463
            if do_repo:
 
464
                note("No repository found at specified location.")
 
465
    finally:
 
466
        for thing in to_unlock:
 
467
            thing.unlock()