← Back to branch summary

~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: 2008-06-05 04:05:05 UTC
  • mfrom: (3473.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080605040505-i9kqxg2fps2qjdi0
Add the 'alias' command (Tim Penhey)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/check.py
32
32
# raising them.  If there's more than one exception it'd be good to see them
33
33
# all.
34
34
 
35
 
from bzrlib import errors, osutils
 
35
from bzrlib import errors
36
36
from bzrlib import repository as _mod_repository
37
37
from bzrlib import revision
38
 
from bzrlib.branch import Branch
39
 
from bzrlib.bzrdir import BzrDir
40
38
from bzrlib.errors import BzrCheckError
41
 
from bzrlib.repository import Repository
42
 
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
 
39
import bzrlib.ui
43
40
from bzrlib.trace import log_error, note
44
 
import bzrlib.ui
45
 
from bzrlib.workingtree import WorkingTree
46
41
 
47
42
class Check(object):
48
43
    """Check a repository"""
60
55
        self.missing_revision_cnt = 0
61
56
        # maps (file-id, version) -> sha1; used by InventoryFile._check
62
57
        self.checked_texts = {}
63
 
        self.checked_weaves = set()
 
58
        self.checked_weaves = {}
64
59
        self.unreferenced_versions = set()
65
60
        self.inconsistent_parents = []
66
61
 
71
66
            self.progress.update('retrieving inventory', 0, 2)
72
67
            # do not put in init, as it should be done with progess,
73
68
            # and inside the lock.
74
 
            self.inventory_weave = self.repository.inventories
 
69
            self.inventory_weave = self.repository.get_inventory_weave()
75
70
            self.progress.update('checking revision graph', 1)
76
71
            self.check_revision_graph()
77
72
            self.plan_revisions()
101
96
        repository = self.repository
102
97
        self.planned_revisions = repository.all_revision_ids()
103
98
        self.progress.clear()
104
 
        inventoried = set(key[-1] for key in self.inventory_weave.keys())
 
99
        inventoried = set(self.inventory_weave.versions())
105
100
        awol = set(self.planned_revisions) - inventoried
106
101
        if len(awol) > 0:
107
102
            raise BzrCheckError('Stored revisions missing from inventory'
198
193
    def check_weaves(self):
199
194
        """Check all the weaves we can get our hands on.
200
195
        """
 
196
        n_weaves = 1
201
197
        weave_ids = []
202
 
        self.progress.update('checking inventory', 0, 2)
 
198
        if self.repository.weave_store.listable():
 
199
            weave_ids = list(self.repository.weave_store)
 
200
            n_weaves = len(weave_ids) + 1
 
201
        self.progress.update('checking versionedfile', 0, n_weaves)
203
202
        self.inventory_weave.check(progress_bar=self.progress)
204
 
        self.progress.update('checking text storage', 1, 2)
205
 
        self.repository.texts.check(progress_bar=self.progress)
 
203
        files_in_revisions = {}
 
204
        revisions_of_files = {}
206
205
        weave_checker = self.repository._get_versioned_file_checker()
207
 
        result = weave_checker.check_file_version_parents(
208
 
            self.repository.texts, progress_bar=self.progress)
209
 
        self.checked_weaves = weave_checker.file_ids
210
 
        bad_parents, unused_versions = result
211
 
        bad_parents = bad_parents.items()
212
 
        for text_key, (stored_parents, correct_parents) in bad_parents:
213
 
            # XXX not ready for id join/split operations.
214
 
            weave_id = text_key[0]
215
 
            revision_id = text_key[-1]
216
 
            weave_parents = tuple([parent[-1] for parent in stored_parents])
217
 
            correct_parents = tuple([parent[-1] for parent in correct_parents])
218
 
            self.inconsistent_parents.append(
219
 
                (revision_id, weave_id, weave_parents, correct_parents))
220
 
        self.unreferenced_versions.update(unused_versions)
 
206
        for i, weave_id in enumerate(weave_ids):
 
207
            self.progress.update('checking versionedfile', i, n_weaves)
 
208
            w = self.repository.weave_store.get_weave(weave_id,
 
209
                    self.repository.get_transaction())
 
210
            # No progress here, because it looks ugly.
 
211
            w.check()
 
212
            result = weave_checker.check_file_version_parents(w, weave_id)
 
213
            bad_parents, unused_versions = result
 
214
            bad_parents = bad_parents.items()
 
215
            for revision_id, (weave_parents, correct_parents) in bad_parents:
 
216
                self.inconsistent_parents.append(
 
217
                    (revision_id, weave_id, weave_parents, correct_parents))
 
218
            for revision_id in unused_versions:
 
219
                self.unreferenced_versions.add((weave_id, revision_id))
 
220
            self.checked_weaves[weave_id] = True
221
221
 
222
222
    def _check_revision_tree(self, rev_id):
223
223
        tree = self.repository.revision_tree(rev_id)
241
241
            seen_names[path] = True
242
242
 
243
243
 
244
 
@deprecated_function(deprecated_in((1,6,0)))
245
244
def check(branch, verbose):
246
245
    """Run consistency checks on a branch.
247
246
    
248
247
    Results are reported through logging.
249
248
    
250
 
    Deprecated in 1.6.  Please use check_branch instead.
251
 
 
252
 
    :raise BzrCheckError: if there's a consistency error.
253
 
    """
254
 
    check_branch(branch, verbose)
255
 
 
256
 
 
257
 
def check_branch(branch, verbose):
258
 
    """Run consistency checks on a branch.
259
 
 
260
 
    Results are reported through logging.
261
 
 
262
249
    :raise BzrCheckError: if there's a consistency error.
263
250
    """
264
251
    branch.lock_read()
265
252
    try:
266
253
        branch_result = branch.check()
 
254
        repo_result = branch.repository.check([branch.last_revision()])
267
255
    finally:
268
256
        branch.unlock()
269
257
    branch_result.report_results(verbose)
270
 
 
271
 
 
272
 
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
273
 
    try:
274
 
        tree, branch, repo, relpath = \
275
 
                        BzrDir.open_containing_tree_branch_or_repository(path)
276
 
    except errors.NotBranchError:
277
 
        tree = branch = repo = None
278
 
 
279
 
    if do_tree:
280
 
        if tree is not None:
281
 
            note("Checking working tree at '%s'." 
282
 
                 % (tree.bzrdir.root_transport.base,))
283
 
            tree._check()
284
 
        else:
285
 
            log_error("No working tree found at specified location.")
286
 
 
287
 
    if branch is not None:
288
 
        # We have a branch
289
 
        if repo is None:
290
 
            # The branch is in a shared repository
291
 
            repo = branch.repository
292
 
        branches = [branch]
293
 
    elif repo is not None:
294
 
        branches = repo.find_branches(using=True)
295
 
 
296
 
    if repo is not None:
297
 
        repo.lock_read()
298
 
        try:
299
 
            if do_repo:
300
 
                note("Checking repository at '%s'."
301
 
                     % (repo.bzrdir.root_transport.base,))
302
 
                result = repo.check()
303
 
                result.report_results(verbose)
304
 
            if do_branch:
305
 
                if branches == []:
306
 
                    log_error("No branch found at specified location.")
307
 
                else:
308
 
                    for branch in branches:
309
 
                        note("Checking branch at '%s'."
310
 
                             % (branch.bzrdir.root_transport.base,))
311
 
                        check_branch(branch, verbose)
312
 
        finally:
313
 
            repo.unlock()
314
 
    else:
315
 
        if do_branch:
316
 
            log_error("No branch found at specified location.")
317
 
        if do_repo:
318
 
            log_error("No repository found at specified location.")
 
258
    repo_result.report_results(verbose)
 
259
 
 
260
 
 
261