/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-05-07 15:27:39 UTC
  • mto: This revision was merged to the branch mainline in revision 6958.
  • Revision ID: jelmer@jelmer.uk-20180507152739-fuv9z9r0yzi7ln3t
Specify source in .coveragerc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/check.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
# TODO: Perhaps have a way to record errors other than by raising exceptions;
 
18
# would perhaps be enough to accumulate exception objects in a list without
 
19
# raising them.  If there's more than one exception it'd be good to see them
 
20
# all.
 
21
 
 
22
"""Checking of bzr objects.
 
23
 
 
24
check_refs is a concept used for optimising check. Objects that depend on other
 
25
objects (e.g. tree on repository) can list the objects they would be requesting
 
26
so that when the dependent object is checked, matches can be pulled out and
 
27
evaluated in-line rather than re-reading the same data many times.
 
28
check_refs are tuples (kind, value). Currently defined kinds are:
 
29
 
 
30
* 'trees', where value is a revid and the looked up objects are revision trees.
 
31
* 'lefthand-distance', where value is a revid and the looked up objects are the
 
32
  distance along the lefthand path to NULL for that revid.
 
33
* 'revision-existence', where value is a revid, and the result is True or False
 
34
  indicating that the revision was found/not found.
 
35
"""
 
36
 
 
37
from __future__ import absolute_import
 
38
 
 
39
from . import (
 
40
    errors,
 
41
    ui,
 
42
    )
 
43
from .branch import Branch
 
44
from .controldir import ControlDir
 
45
from .revision import NULL_REVISION
 
46
from .sixish import (
 
47
    viewitems,
 
48
    )
 
49
from .trace import note
 
50
from .workingtree import WorkingTree
 
51
from .i18n import gettext
 
52
 
 
53
class Check(object):
 
54
    """Check a repository"""
 
55
 
 
56
    def __init__(self, repository, check_repo=True):
 
57
        self.repository = repository
 
58
 
 
59
    def report_results(self, verbose):
 
60
        raise NotImplementedError(self.report_results)
 
61
 
 
62
 
 
63
def scan_branch(branch, needed_refs, to_unlock):
 
64
    """Scan a branch for refs.
 
65
 
 
66
    :param branch:  The branch to schedule for checking.
 
67
    :param needed_refs: Refs we are accumulating.
 
68
    :param to_unlock: The unlock list accumulating.
 
69
    """
 
70
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
71
    branch.lock_read()
 
72
    to_unlock.append(branch)
 
73
    branch_refs = branch._get_check_refs()
 
74
    for ref in branch_refs:
 
75
        reflist = needed_refs.setdefault(ref, [])
 
76
        reflist.append(branch)
 
77
 
 
78
 
 
79
def scan_tree(base_tree, tree, needed_refs, to_unlock):
 
80
    """Scan a tree for refs.
 
81
 
 
82
    :param base_tree: The original tree check opened, used to detect duplicate
 
83
        tree checks.
 
84
    :param tree:  The tree to schedule for checking.
 
85
    :param needed_refs: Refs we are accumulating.
 
86
    :param to_unlock: The unlock list accumulating.
 
87
    """
 
88
    if base_tree is not None and tree.basedir == base_tree.basedir:
 
89
        return
 
90
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
91
    tree.lock_read()
 
92
    to_unlock.append(tree)
 
93
    tree_refs = tree._get_check_refs()
 
94
    for ref in tree_refs:
 
95
        reflist = needed_refs.setdefault(ref, [])
 
96
        reflist.append(tree)
 
97
 
 
98
 
 
99
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
 
100
    """Check multiple objects.
 
101
 
 
102
    If errors occur they are accumulated and reported as far as possible, and
 
103
    an exception raised at the end of the process.
 
104
    """
 
105
    try:
 
106
        base_tree, branch, repo, relpath = \
 
107
                        ControlDir.open_containing_tree_branch_or_repository(path)
 
108
    except errors.NotBranchError:
 
109
        base_tree = branch = repo = None
 
110
 
 
111
    to_unlock = []
 
112
    needed_refs= {}
 
113
    try:
 
114
        if base_tree is not None:
 
115
            # If the tree is a lightweight checkout we won't see it in
 
116
            # repo.find_branches - add now.
 
117
            if do_tree:
 
118
                scan_tree(None, base_tree, needed_refs, to_unlock)
 
119
            branch = base_tree.branch
 
120
        if branch is not None:
 
121
            # We have a branch
 
122
            if repo is None:
 
123
                # The branch is in a shared repository
 
124
                repo = branch.repository
 
125
        if repo is not None:
 
126
            repo.lock_read()
 
127
            to_unlock.append(repo)
 
128
            branches = repo.find_branches(using=True)
 
129
            saw_tree = False
 
130
            if do_branch or do_tree:
 
131
                for branch in branches:
 
132
                    if do_tree:
 
133
                        try:
 
134
                            tree = branch.controldir.open_workingtree()
 
135
                            saw_tree = True
 
136
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
137
                            pass
 
138
                        else:
 
139
                            scan_tree(base_tree, tree, needed_refs, to_unlock)
 
140
                    if do_branch:
 
141
                        scan_branch(branch, needed_refs, to_unlock)
 
142
            if do_branch and not branches:
 
143
                note(gettext("No branch found at specified location."))
 
144
            if do_tree and base_tree is None and not saw_tree:
 
145
                note(gettext("No working tree found at specified location."))
 
146
            if do_repo or do_branch or do_tree:
 
147
                if do_repo:
 
148
                    note(gettext("Checking repository at '%s'.")
 
149
                         % (repo.user_url,))
 
150
                result = repo.check(None, callback_refs=needed_refs,
 
151
                    check_repo=do_repo)
 
152
                result.report_results(verbose)
 
153
        else:
 
154
            if do_tree:
 
155
                note(gettext("No working tree found at specified location."))
 
156
            if do_branch:
 
157
                note(gettext("No branch found at specified location."))
 
158
            if do_repo:
 
159
                note(gettext("No repository found at specified location."))
 
160
    finally:
 
161
        for thing in to_unlock:
 
162
            thing.unlock()