/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: 2020-02-07 02:14:30 UTC
  • mto: This revision was merged to the branch mainline in revision 7492.
  • Revision ID: jelmer@jelmer.uk-20200207021430-m49iq3x4x8xlib6x
Drop python2 support.

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
import contextlib
 
40
 
 
41
from . import (
 
42
    errors,
 
43
    )
 
44
from .controldir import ControlDir
 
45
from .trace import note
 
46
from .i18n import gettext
 
47
 
 
48
 
 
49
class Check(object):
 
50
    """Check a repository"""
 
51
 
 
52
    def __init__(self, repository, check_repo=True):
 
53
        self.repository = repository
 
54
 
 
55
    def report_results(self, verbose):
 
56
        raise NotImplementedError(self.report_results)
 
57
 
 
58
 
 
59
def scan_branch(branch, needed_refs, exit_stack):
 
60
    """Scan a branch for refs.
 
61
 
 
62
    :param branch:  The branch to schedule for checking.
 
63
    :param needed_refs: Refs we are accumulating.
 
64
    :param exit_stack: The exit stack accumulating.
 
65
    """
 
66
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
67
    exit_stack.enter_context(branch.lock_read())
 
68
    branch_refs = branch._get_check_refs()
 
69
    for ref in branch_refs:
 
70
        reflist = needed_refs.setdefault(ref, [])
 
71
        reflist.append(branch)
 
72
 
 
73
 
 
74
def scan_tree(base_tree, tree, needed_refs, exit_stack):
 
75
    """Scan a tree for refs.
 
76
 
 
77
    :param base_tree: The original tree check opened, used to detect duplicate
 
78
        tree checks.
 
79
    :param tree:  The tree to schedule for checking.
 
80
    :param needed_refs: Refs we are accumulating.
 
81
    :param exit_stack: The exit stack accumulating.
 
82
    """
 
83
    if base_tree is not None and tree.basedir == base_tree.basedir:
 
84
        return
 
85
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
86
    exit_stack.enter_context(tree.lock_read())
 
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
    with contextlib.ExitStack() as exit_stack:
 
106
        needed_refs = {}
 
107
        if base_tree is not None:
 
108
            # If the tree is a lightweight checkout we won't see it in
 
109
            # repo.find_branches - add now.
 
110
            if do_tree:
 
111
                scan_tree(None, base_tree, needed_refs, exit_stack)
 
112
            branch = base_tree.branch
 
113
        if branch is not None:
 
114
            # We have a branch
 
115
            if repo is None:
 
116
                # The branch is in a shared repository
 
117
                repo = branch.repository
 
118
        if repo is not None:
 
119
            exit_stack.enter_context(repo.lock_read())
 
120
            branches = list(repo.find_branches(using=True))
 
121
            saw_tree = False
 
122
            if do_branch or do_tree:
 
123
                for branch in branches:
 
124
                    if do_tree:
 
125
                        try:
 
126
                            tree = branch.controldir.open_workingtree()
 
127
                            saw_tree = True
 
128
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
129
                            pass
 
130
                        else:
 
131
                            scan_tree(base_tree, tree, needed_refs, exit_stack)
 
132
                    if do_branch:
 
133
                        scan_branch(branch, needed_refs, exit_stack)
 
134
            if do_branch and not branches:
 
135
                note(gettext("No branch found at specified location."))
 
136
            if do_tree and base_tree is None and not saw_tree:
 
137
                note(gettext("No working tree found at specified location."))
 
138
            if do_repo or do_branch or do_tree:
 
139
                if do_repo:
 
140
                    note(gettext("Checking repository at '%s'.")
 
141
                         % (repo.user_url,))
 
142
                result = repo.check(None, callback_refs=needed_refs,
 
143
                                    check_repo=do_repo)
 
144
                result.report_results(verbose)
 
145
        else:
 
146
            if do_tree:
 
147
                note(gettext("No working tree found at specified location."))
 
148
            if do_branch:
 
149
                note(gettext("No branch found at specified location."))
 
150
            if do_repo:
 
151
                note(gettext("No repository found at specified location."))