/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/check.py
1
 
# Copyright (C) 2004, 2005 by Martin Pool
2
 
# Copyright (C) 2005 by Canonical Ltd
3
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
import bzrlib.ui
19
 
from bzrlib.trace import note, warning
20
 
 
21
 
def _update_store_entry(obj, obj_id, branch, store_name, store):
22
 
    """This is just a meta-function, which handles both revision entries
23
 
    and inventory entries.
24
 
    """
25
 
    from bzrlib.trace import mutter
26
 
    import tempfile, os, errno
27
 
    from osutils import rename
28
 
    obj_tmp = tempfile.TemporaryFile()
29
 
    obj.write_xml(obj_tmp)
30
 
    obj_tmp.seek(0)
31
 
 
32
 
    tmpfd, tmp_path = tempfile.mkstemp(prefix=obj_id, suffix='.gz',
33
 
        dir=branch.controlfilename(store_name))
34
 
    os.close(tmpfd)
35
 
    try:
36
 
        orig_obj_path = branch.controlfilename([store_name, obj_id+'.gz'])
37
 
        # Remove the old entry out of the way
38
 
        rename(orig_obj_path, tmp_path)
39
 
        try:
40
 
            # TODO: We may need to handle the case where the old
41
 
            # entry was not compressed (and thus did not end with .gz)
42
 
 
43
 
            store.add(obj_tmp, obj_id) # Add the new one
44
 
            os.remove(tmp_path) # Remove the old name
45
 
            mutter('    Updated %s entry {%s}' % (store_name, obj_id))
46
 
        except:
47
 
            # On any exception, restore the old entry
48
 
            rename(tmp_path, orig_obj_path)
49
 
            raise
50
 
    finally:
51
 
        if os.path.exists(tmp_path):
52
 
            # Unfortunately, the next command might throw
53
 
            # an exception, which will mask a previous exception.
54
 
            os.remove(tmp_path)
55
 
        obj_tmp.close()
56
 
 
57
 
def _update_revision_entry(rev, branch):
58
 
    """After updating the values in a revision, make sure to
59
 
    write out the data, but try to do it in an atomic manner.
60
 
 
61
 
    :param rev:    The Revision object to store
62
 
    :param branch: The Branch object where this Revision is to be stored.
63
 
    """
64
 
    _update_store_entry(rev, rev.revision_id, branch,
65
 
            'revision-store', branch.revision_store)
66
 
 
67
 
def _update_inventory_entry(inv, inv_id, branch):
68
 
    """When an inventory has been modified (such as by adding a unique tree root)
69
 
    this atomically re-generates the file.
70
 
 
71
 
    :param inv:     The Inventory
72
 
    :param inv_id:  The inventory id for this inventory
73
 
    :param branch:  The Branch where this entry will be stored.
74
 
    """
75
 
    _update_store_entry(inv, inv_id, branch,
76
 
            'inventory-store', branch.inventory_store)
77
 
 
78
 
 
79
 
def check(branch):
80
 
    """Run consistency checks on a branch.
81
 
 
82
 
    TODO: Also check non-mainline revisions mentioned as parents.
83
 
 
84
 
    TODO: Check for extra files in the control directory.
85
 
    """
86
 
    from bzrlib.trace import mutter
87
 
    from bzrlib.errors import BzrCheckError, NoSuchRevision
88
 
    from bzrlib.osutils import fingerprint_file
89
 
    from bzrlib.inventory import ROOT_ID
90
 
    from bzrlib.branch import gen_root_id
91
 
 
92
 
    branch.lock_read()
93
 
 
94
 
    try:
95
 
        last_rev_id = None
96
 
 
97
 
        missing_inventory_sha_cnt = 0
98
 
        missing_revision_sha_cnt = 0
99
 
        missing_revision_cnt = 0
100
 
 
101
 
        history = branch.revision_history()
102
 
        revno = 0
103
 
        revcount = len(history)
104
 
        mismatch_inv_id = []
105
 
 
106
 
        # for all texts checked, text_id -> sha1
107
 
        checked_texts = {}
108
 
 
109
 
        progress = bzrlib.ui.ui_factory.progress_bar()
110
 
 
111
 
        for rev_id in history:
112
 
            revno += 1
113
 
            progress.update('checking revision', revno, revcount)
114
 
            # mutter('    revision {%s}' % rev_id)
115
 
            rev = branch.get_revision(rev_id)
116
 
            if rev.revision_id != rev_id:
117
 
                raise BzrCheckError('wrong internal revision id in revision {%s}'
118
 
                                    % rev_id)
119
 
 
120
 
            # check the previous history entry is a parent of this entry
121
 
            if rev.parents:
122
 
                if last_rev_id is None:
123
 
                    raise BzrCheckError("revision {%s} has %d parents, but is the "
124
 
                                        "start of the branch"
125
 
                                        % (rev_id, len(rev.parents)))
126
 
                for prr in rev.parents:
127
 
                    if prr.revision_id == last_rev_id:
128
 
                        break
129
 
                else:
130
 
                    raise BzrCheckError("previous revision {%s} not listed among "
131
 
                                        "parents of {%s}"
132
 
                                        % (last_rev_id, rev_id))
133
 
 
134
 
                for prr in rev.parents:
135
 
                    if prr.revision_sha1 is None:
136
 
                        missing_revision_sha_cnt += 1
137
 
                        continue
138
 
                    prid = prr.revision_id
139
 
                    
140
 
                    try:
141
 
                        actual_sha = branch.get_revision_sha1(prid)
142
 
                    except NoSuchRevision:
143
 
                        missing_revision_cnt += 1
144
 
                        mutter("parent {%s} of {%s} not present in store",
145
 
                               prid, rev_id)
146
 
                        continue
147
 
                        
148
 
                    if prr.revision_sha1 != actual_sha:
149
 
                        raise BzrCheckError("mismatched revision sha1 for "
150
 
                                            "parent {%s} of {%s}: %s vs %s"
151
 
                                            % (prid, rev_id,
152
 
                                               prr.revision_sha1, actual_sha))
153
 
            elif last_rev_id:
154
 
                raise BzrCheckError("revision {%s} has no parents listed but preceded "
155
 
                                    "by {%s}"
156
 
                                    % (rev_id, last_rev_id))
157
 
 
158
 
            if rev.inventory_id != rev_id:
159
 
                mismatch_inv_id.append(rev_id)
160
 
 
161
 
            ## TODO: Check all the required fields are present on the revision.
162
 
 
163
 
            if rev.inventory_sha1:
164
 
                inv_sha1 = branch.get_inventory_sha1(rev.inventory_id)
165
 
                if inv_sha1 != rev.inventory_sha1:
166
 
                    raise BzrCheckError('Inventory sha1 hash doesn\'t match'
167
 
                        ' value in revision {%s}' % rev_id)
168
 
            else:
169
 
                missing_inventory_sha_cnt += 1
170
 
                mutter("no inventory_sha1 on revision {%s}" % rev_id)
171
 
 
172
 
            inv = branch.get_inventory(rev.inventory_id)
173
 
            seen_ids = {}
174
 
            seen_names = {}
175
 
 
176
 
            ## p('revision %d/%d file ids' % (revno, revcount))
177
 
            for file_id in inv:
178
 
                if file_id in seen_ids:
179
 
                    raise BzrCheckError('duplicated file_id {%s} '
180
 
                                        'in inventory for revision {%s}'
181
 
                                        % (file_id, rev_id))
182
 
                seen_ids[file_id] = True
183
 
 
184
 
            i = 0
185
 
            for file_id in inv:
186
 
                i += 1
187
 
                if i & 31 == 0:
188
 
                    progress.tick()
189
 
 
190
 
                ie = inv[file_id]
191
 
 
192
 
                if ie.parent_id != None:
193
 
                    if ie.parent_id not in seen_ids:
194
 
                        raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
195
 
                                % (ie.parent_id, rev_id))
196
 
 
197
 
                if ie.kind == 'file':
198
 
                    if ie.text_id in checked_texts:
199
 
                        fp = checked_texts[ie.text_id]
200
 
                    else:
201
 
                        if not ie.text_id in branch.text_store:
202
 
                            raise BzrCheckError('text {%s} not in text_store' % ie.text_id)
203
 
 
204
 
                        tf = branch.text_store[ie.text_id]
205
 
                        fp = fingerprint_file(tf)
206
 
                        checked_texts[ie.text_id] = fp
207
 
 
208
 
                    if ie.text_size != fp['size']:
209
 
                        raise BzrCheckError('text {%s} wrong size' % ie.text_id)
210
 
                    if ie.text_sha1 != fp['sha1']:
211
 
                        raise BzrCheckError('text {%s} wrong sha1' % ie.text_id)
212
 
                elif ie.kind == 'directory':
213
 
                    if ie.text_sha1 != None or ie.text_size != None or ie.text_id != None:
214
 
                        raise BzrCheckError('directory {%s} has text in revision {%s}'
215
 
                                % (file_id, rev_id))
216
 
 
217
 
            progress.tick()
218
 
            for path, ie in inv.iter_entries():
219
 
                if path in seen_names:
220
 
                    raise BzrCheckError('duplicated path %s '
221
 
                                        'in inventory for revision {%s}'
222
 
                                        % (path, rev_id))
223
 
            seen_names[path] = True
224
 
            last_rev_id = rev_id
225
 
 
226
 
    finally:
227
 
        branch.unlock()
228
 
 
229
 
    progress.clear()
230
 
 
231
 
    note('checked %d revisions, %d file texts' % (revcount, len(checked_texts)))
232
 
    
233
 
    if missing_inventory_sha_cnt:
234
 
        note('%d revisions are missing inventory_sha1' % missing_inventory_sha_cnt)
235
 
 
236
 
    if missing_revision_sha_cnt:
237
 
        note('%d parent links are missing revision_sha1' % missing_revision_sha_cnt)
238
 
 
239
 
    if missing_revision_cnt:
240
 
        note('%d revisions are mentioned but not present' % missing_revision_cnt)
241
 
 
242
 
    if missing_revision_cnt:
243
 
        print '%d revisions are mentioned but not present' % missing_revision_cnt
244
 
 
245
 
    # stub this out for now because the main bzr branch has references
246
 
    # to revisions that aren't present in the store -- mbp 20050804
247
 
#    if (missing_inventory_sha_cnt
248
 
#        or missing_revision_sha_cnt):
249
 
#        print '  (use "bzr upgrade" to fix them)'
250
 
 
251
 
    if mismatch_inv_id:
252
 
        warning('%d revisions have mismatched inventory ids:' % len(mismatch_inv_id))
253
 
        for rev_id in mismatch_inv_id:
254
 
            warning('  %s', rev_id)
 
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
import contextlib
 
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, exit_stack):
 
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 exit_stack: The exit stack accumulating.
 
63
    """
 
64
    note(gettext("Checking branch at '%s'.") % (branch.base,))
 
65
    exit_stack.enter_context(branch.lock_read())
 
66
    branch_refs = branch._get_check_refs()
 
67
    for ref in branch_refs:
 
68
        reflist = needed_refs.setdefault(ref, [])
 
69
        reflist.append(branch)
 
70
 
 
71
 
 
72
def scan_tree(base_tree, tree, needed_refs, exit_stack):
 
73
    """Scan a tree for refs.
 
74
 
 
75
    :param base_tree: The original tree check opened, used to detect duplicate
 
76
        tree checks.
 
77
    :param tree:  The tree to schedule for checking.
 
78
    :param needed_refs: Refs we are accumulating.
 
79
    :param exit_stack: The exit stack accumulating.
 
80
    """
 
81
    if base_tree is not None and tree.basedir == base_tree.basedir:
 
82
        return
 
83
    note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
 
84
    exit_stack.enter_context(tree.lock_read())
 
85
    tree_refs = tree._get_check_refs()
 
86
    for ref in tree_refs:
 
87
        reflist = needed_refs.setdefault(ref, [])
 
88
        reflist.append(tree)
 
89
 
 
90
 
 
91
def check_dwim(path, verbose, do_branch=False, do_repo=False, do_tree=False):
 
92
    """Check multiple objects.
 
93
 
 
94
    If errors occur they are accumulated and reported as far as possible, and
 
95
    an exception raised at the end of the process.
 
96
    """
 
97
    try:
 
98
        base_tree, branch, repo, relpath = \
 
99
            ControlDir.open_containing_tree_branch_or_repository(path)
 
100
    except errors.NotBranchError:
 
101
        base_tree = branch = repo = None
 
102
 
 
103
    with contextlib.ExitStack() as exit_stack:
 
104
        needed_refs = {}
 
105
        if base_tree is not None:
 
106
            # If the tree is a lightweight checkout we won't see it in
 
107
            # repo.find_branches - add now.
 
108
            if do_tree:
 
109
                scan_tree(None, base_tree, needed_refs, exit_stack)
 
110
            branch = base_tree.branch
 
111
        if branch is not None:
 
112
            # We have a branch
 
113
            if repo is None:
 
114
                # The branch is in a shared repository
 
115
                repo = branch.repository
 
116
        if repo is not None:
 
117
            exit_stack.enter_context(repo.lock_read())
 
118
            branches = list(repo.find_branches(using=True))
 
119
            saw_tree = False
 
120
            if do_branch or do_tree:
 
121
                for branch in branches:
 
122
                    if do_tree:
 
123
                        try:
 
124
                            tree = branch.controldir.open_workingtree()
 
125
                            saw_tree = True
 
126
                        except (errors.NotLocalUrl, errors.NoWorkingTree):
 
127
                            pass
 
128
                        else:
 
129
                            scan_tree(base_tree, tree, needed_refs, exit_stack)
 
130
                    if do_branch:
 
131
                        scan_branch(branch, needed_refs, exit_stack)
 
132
            if do_branch and not branches:
 
133
                note(gettext("No branch found at specified location."))
 
134
            if do_tree and base_tree is None and not saw_tree:
 
135
                note(gettext("No working tree found at specified location."))
 
136
            if do_repo or do_branch or do_tree:
 
137
                if do_repo:
 
138
                    note(gettext("Checking repository at '%s'.")
 
139
                         % (repo.user_url,))
 
140
                result = repo.check(None, callback_refs=needed_refs,
 
141
                                    check_repo=do_repo)
 
142
                result.report_results(verbose)
 
143
        else:
 
144
            if do_tree:
 
145
                note(gettext("No working tree found at specified location."))
 
146
            if do_branch:
 
147
                note(gettext("No branch found at specified location."))
 
148
            if do_repo:
 
149
                note(gettext("No repository found at specified location."))