/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-01-12 13:56:10 UTC
  • mto: This revision was merged to the branch mainline in revision 7443.
  • Revision ID: jelmer@jelmer.uk-20200112135610-0a9bct6x4cw7he6y
Add strip_segment_parameters function.

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