/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: 2019-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

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
    )
 
42
from .controldir import ControlDir
 
43
from .trace import note
 
44
from .i18n import gettext
 
45
 
 
46
 
 
47
class Check(object):
 
48
    """Check a repository"""
 
49
 
 
50
    def __init__(self, repository, check_repo=True):
 
51
        self.repository = repository
 
52
 
 
53
    def report_results(self, verbose):
 
54
        raise NotImplementedError(self.report_results)
 
55
 
 
56
 
 
57
def scan_branch(branch, needed_refs, to_unlock):
 
58
    """Scan a branch for refs.
 
59
 
 
60
    :param branch:  The branch to schedule for checking.
 
61
    :param needed_refs: Refs we are accumulating.
 
62
    :param to_unlock: The unlock list accumulating.
 
63
    """
 
64
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
65
    branch.lock_read()
 
66
    to_unlock.append(branch)
 
67
    branch_refs = branch._get_check_refs()
 
68
    for ref in branch_refs:
 
69
        reflist = needed_refs.setdefault(ref, [])
 
70
        reflist.append(branch)
 
71
 
 
72
 
 
73
def scan_tree(base_tree, tree, needed_refs, to_unlock):
 
74
    """Scan a tree for refs.
 
75
 
 
76
    :param base_tree: The original tree check opened, used to detect duplicate
 
77
        tree checks.
 
78
    :param tree:  The tree to schedule for checking.
 
79
    :param needed_refs: Refs we are accumulating.
 
80
    :param to_unlock: The unlock list accumulating.
 
81
    """
 
82
    if base_tree is not None and tree.basedir == base_tree.basedir:
 
83
        return
 
84
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
85
    tree.lock_read()
 
86
    to_unlock.append(tree)
 
87
    tree_refs = tree._get_check_refs()
 
88
    for ref in tree_refs:
 
89
        reflist = needed_refs.setdefault(ref, [])
 
90
        reflist.append(tree)
 
91
 
 
92
 
 
93
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
 
94
    """Check multiple objects.
 
95
 
 
96
    If errors occur they are accumulated and reported as far as possible, and
 
97
    an exception raised at the end of the process.
 
98
    """
 
99
    try:
 
100
        base_tree, branch, repo, relpath = \
 
101
            ControlDir.open_containing_tree_branch_or_repository(path)
 
102
    except errors.NotBranchError:
 
103
        base_tree = branch = repo = None
 
104
 
 
105
    to_unlock = []
 
106
    needed_refs = {}
 
107
    try:
 
108
        if base_tree is not None:
 
109
            # If the tree is a lightweight checkout we won't see it in
 
110
            # repo.find_branches - add now.
 
111
            if do_tree:
 
112
                scan_tree(None, base_tree, needed_refs, to_unlock)
 
113
            branch = base_tree.branch
 
114
        if branch is not None:
 
115
            # We have a branch
 
116
            if repo is None:
 
117
                # The branch is in a shared repository
 
118
                repo = branch.repository
 
119
        if repo is not None:
 
120
            repo.lock_read()
 
121
            to_unlock.append(repo)
 
122
            branches = repo.find_branches(using=True)
 
123
            saw_tree = False
 
124
            if do_branch or do_tree:
 
125
                for branch in branches:
 
126
                    if do_tree:
 
127
                        try:
 
128
                            tree = branch.controldir.open_workingtree()
 
129
                            saw_tree = True
 
130
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
131
                            pass
 
132
                        else:
 
133
                            scan_tree(base_tree, tree, needed_refs, to_unlock)
 
134
                    if do_branch:
 
135
                        scan_branch(branch, needed_refs, to_unlock)
 
136
            if do_branch and not branches:
 
137
                note(gettext("No branch found at specified location."))
 
138
            if do_tree and base_tree is None and not saw_tree:
 
139
                note(gettext("No working tree found at specified location."))
 
140
            if do_repo or do_branch or do_tree:
 
141
                if do_repo:
 
142
                    note(gettext("Checking repository at '%s'.")
 
143
                         % (repo.user_url,))
 
144
                result = repo.check(None, callback_refs=needed_refs,
 
145
                                    check_repo=do_repo)
 
146
                result.report_results(verbose)
 
147
        else:
 
148
            if do_tree:
 
149
                note(gettext("No working tree found at specified location."))
 
150
            if do_branch:
 
151
                note(gettext("No branch found at specified location."))
 
152
            if do_repo:
 
153
                note(gettext("No repository found at specified location."))
 
154
    finally:
 
155
        for thing in to_unlock:
 
156
            thing.unlock()