~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-28 04:08:13 UTC
  • Revision ID: mbp@sourcefrog.net-20050328040812-f6852e38fba0ad5f
- reactivate basic check command

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
 
19
 
def _update_store_entry(obj, obj_id, branch, store_name, store):
20
 
    """This is just a meta-function, which handles both revision entries
21
 
    and inventory entries.
22
 
    """
23
 
    from bzrlib.trace import mutter
24
 
    import tempfile, os, errno
25
 
    from osutils import rename
26
 
    obj_tmp = tempfile.TemporaryFile()
27
 
    obj.write_xml(obj_tmp)
28
 
    obj_tmp.seek(0)
29
 
 
30
 
    tmpfd, tmp_path = tempfile.mkstemp(prefix=obj_id, suffix='.gz',
31
 
        dir=branch.controlfilename(store_name))
32
 
    os.close(tmpfd)
33
 
    try:
34
 
        orig_obj_path = branch.controlfilename([store_name, obj_id+'.gz'])
35
 
        # Remove the old entry out of the way
36
 
        rename(orig_obj_path, tmp_path)
37
 
        try:
38
 
            # TODO: We may need to handle the case where the old
39
 
            # entry was not compressed (and thus did not end with .gz)
40
 
 
41
 
            store.add(obj_tmp, obj_id) # Add the new one
42
 
            os.remove(tmp_path) # Remove the old name
43
 
            mutter('    Updated %s entry {%s}' % (store_name, obj_id))
44
 
        except:
45
 
            # On any exception, restore the old entry
46
 
            rename(tmp_path, orig_obj_path)
47
 
            raise
48
 
    finally:
49
 
        if os.path.exists(tmp_path):
50
 
            # Unfortunately, the next command might throw
51
 
            # an exception, which will mask a previous exception.
52
 
            os.remove(tmp_path)
53
 
        obj_tmp.close()
54
 
 
55
 
def _update_revision_entry(rev, branch):
56
 
    """After updating the values in a revision, make sure to
57
 
    write out the data, but try to do it in an atomic manner.
58
 
 
59
 
    :param rev:    The Revision object to store
60
 
    :param branch: The Branch object where this Revision is to be stored.
61
 
    """
62
 
    _update_store_entry(rev, rev.revision_id, branch,
63
 
            'revision-store', branch.revision_store)
64
 
 
65
 
def _update_inventory_entry(inv, inv_id, branch):
66
 
    """When an inventory has been modified (such as by adding a unique tree root)
67
 
    this atomically re-generates the file.
68
 
 
69
 
    :param inv:     The Inventory
70
 
    :param inv_id:  The inventory id for this inventory
71
 
    :param branch:  The Branch where this entry will be stored.
72
 
    """
73
 
    _update_store_entry(inv, inv_id, branch,
74
 
            'inventory-store', branch.inventory_store)
75
 
 
76
 
def check(branch):
77
 
    """Run consistency checks on a branch.
78
 
 
79
 
    TODO: Also check non-mainline revisions mentioned as parents.
80
 
 
81
 
    TODO: Check for extra files in the control directory.
82
 
    """
83
 
    from bzrlib.trace import mutter
84
 
    from bzrlib.errors import BzrCheckError
85
 
    from bzrlib.osutils import fingerprint_file
86
 
    from bzrlib.progress import ProgressBar
87
 
    from bzrlib.inventory import ROOT_ID
88
 
    from bzrlib.branch import gen_root_id
89
 
 
90
 
    branch.lock_read()
91
 
 
92
 
    try:
93
 
        pb = ProgressBar(show_spinner=True)
94
 
        last_rev_id = None
95
 
 
96
 
        missing_inventory_sha_cnt = 0
97
 
        missing_revision_sha_cnt = 0
98
 
 
99
 
        history = branch.revision_history()
100
 
        revno = 0
101
 
        revcount = len(history)
102
 
        mismatch_inv_id = []
103
 
 
104
 
        # for all texts checked, text_id -> sha1
105
 
        checked_texts = {}
106
 
 
107
 
        for rev_id in history:
108
 
            revno += 1
109
 
            pb.update('checking revision', revno, revcount)
110
 
            mutter('    revision {%s}' % rev_id)
111
 
            rev = branch.get_revision(rev_id)
112
 
            if rev.revision_id != rev_id:
113
 
                raise BzrCheckError('wrong internal revision id in revision {%s}'
114
 
                                    % rev_id)
115
 
 
116
 
            # check the previous history entry is a parent of this entry
117
 
            if rev.parents:
118
 
                if last_rev_id is None:
119
 
                    raise BzrCheckError("revision {%s} has %d parents, but is the "
120
 
                                        "start of the branch"
121
 
                                        % (rev_id, len(rev.parents)))
122
 
                for prr in rev.parents:
123
 
                    if prr.revision_id == last_rev_id:
124
 
                        break
125
 
                else:
126
 
                    raise BzrCheckError("previous revision {%s} not listed among "
127
 
                                        "parents of {%s}"
128
 
                                        % (last_rev_id, rev_id))
129
 
 
130
 
                for prr in rev.parents:
131
 
                    if prr.revision_sha1 is None:
132
 
                        missing_revision_sha_cnt += 1
133
 
                        continue
134
 
                    prid = prr.revision_id
135
 
                    actual_sha = branch.get_revision_sha1(prid)
136
 
                    if prr.revision_sha1 != actual_sha:
137
 
                        raise BzrCheckError("mismatched revision sha1 for "
138
 
                                            "parent {%s} of {%s}: %s vs %s"
139
 
                                            % (prid, rev_id,
140
 
                                               prr.revision_sha1, actual_sha))
141
 
            elif last_rev_id:
142
 
                raise BzrCheckError("revision {%s} has no parents listed but preceded "
143
 
                                    "by {%s}"
144
 
                                    % (rev_id, last_rev_id))
145
 
 
146
 
            if rev.inventory_id != rev_id:
147
 
                mismatch_inv_id.append(rev_id)
148
 
 
149
 
            ## TODO: Check all the required fields are present on the revision.
150
 
 
151
 
            if rev.inventory_sha1:
152
 
                inv_sha1 = branch.get_inventory_sha1(rev.inventory_id)
153
 
                if inv_sha1 != rev.inventory_sha1:
154
 
                    raise BzrCheckError('Inventory sha1 hash doesn\'t match'
155
 
                        ' value in revision {%s}' % rev_id)
156
 
            else:
157
 
                missing_inventory_sha_cnt += 1
158
 
                mutter("no inventory_sha1 on revision {%s}" % rev_id)
159
 
 
160
 
            inv = branch.get_inventory(rev.inventory_id)
161
 
            seen_ids = {}
162
 
            seen_names = {}
163
 
 
164
 
            ## p('revision %d/%d file ids' % (revno, revcount))
165
 
            for file_id in inv:
166
 
                if file_id in seen_ids:
167
 
                    raise BzrCheckError('duplicated file_id {%s} '
168
 
                                        'in inventory for revision {%s}'
169
 
                                        % (file_id, rev_id))
170
 
                seen_ids[file_id] = True
171
 
 
172
 
            i = 0
173
 
            for file_id in inv:
174
 
                i += 1
175
 
                if i & 31 == 0:
176
 
                    pb.tick()
177
 
 
178
 
                ie = inv[file_id]
179
 
 
180
 
                if ie.parent_id != None:
181
 
                    if ie.parent_id not in seen_ids:
182
 
                        raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
183
 
                                % (ie.parent_id, rev_id))
184
 
 
185
 
                if ie.kind == 'file':
186
 
                    if ie.text_id in checked_texts:
187
 
                        fp = checked_texts[ie.text_id]
188
 
                    else:
189
 
                        if not ie.text_id in branch.text_store:
190
 
                            raise BzrCheckError('text {%s} not in text_store' % ie.text_id)
191
 
 
192
 
                        tf = branch.text_store[ie.text_id]
193
 
                        fp = fingerprint_file(tf)
194
 
                        checked_texts[ie.text_id] = fp
195
 
 
196
 
                    if ie.text_size != fp['size']:
197
 
                        raise BzrCheckError('text {%s} wrong size' % ie.text_id)
198
 
                    if ie.text_sha1 != fp['sha1']:
199
 
                        raise BzrCheckError('text {%s} wrong sha1' % ie.text_id)
200
 
                elif ie.kind == 'directory':
201
 
                    if ie.text_sha1 != None or ie.text_size != None or ie.text_id != None:
202
 
                        raise BzrCheckError('directory {%s} has text in revision {%s}'
203
 
                                % (file_id, rev_id))
204
 
 
205
 
            pb.tick()
206
 
            for path, ie in inv.iter_entries():
207
 
                if path in seen_names:
208
 
                    raise BzrCheckError('duplicated path %s '
209
 
                                        'in inventory for revision {%s}'
210
 
                                        % (path, rev_id))
211
 
            seen_names[path] = True
212
 
            last_rev_id = rev_id
213
 
 
214
 
    finally:
215
 
        branch.unlock()
216
 
 
217
 
    pb.clear()
218
 
 
219
 
    print 'checked %d revisions, %d file texts' % (revcount, len(checked_texts))
 
19
 
 
20
######################################################################
 
21
# consistency checks
 
22
 
 
23
 
 
24
import bzrlib
 
25
 
 
26
 
 
27
def _ass(a, b):
 
28
    if a != b:
 
29
        bzrlib.errors.bailout("check failed: %r != %r" % (a, b))
 
30
 
 
31
def check(branch, verbose=True):
 
32
    print 'checking tree %r' % branch.base
 
33
 
 
34
    print 'checking entire revision history is present'
 
35
    last_ptr = None
 
36
    for rid in branch.revision_history():
 
37
        print '    revision {%s}' % rid
 
38
        rev = branch.get_revision(rid)
 
39
        _ass(rev.revision_id, rid)
 
40
        _ass(rev.precursor, last_ptr)
 
41
        last_ptr = rid
 
42
 
 
43
    #mutter("checking tree")
 
44
    #check_patches_exist()
 
45
    #check_patch_chaining()
 
46
    #check_patch_uniqueness()
 
47
    #check_inventory()
 
48
    print ("tree looks OK")
 
49
    ## TODO: Check that previous-inventory and previous-manifest
 
50
    ## are the same as those stored in the previous changeset.
 
51
 
 
52
    ## TODO: Check all patches present in patch directory are
 
53
    ## mentioned in patch history; having an orphaned patch only gives
 
54
    ## a warning.
 
55
 
 
56
    ## TODO: Check cached data is consistent with data reconstructed
 
57
    ## from scratch.
 
58
 
 
59
    ## TODO: Check no control files are versioned.
 
60
 
 
61
    ## TODO: Check that the before-hash of each file in a later
 
62
    ## revision matches the after-hash in the previous revision to
 
63
    ## touch it.
 
64
 
 
65
 
 
66
def check_inventory():
 
67
    mutter("checking inventory file and ids...")
 
68
    seen_ids = Set()
 
69
    seen_names = Set()
220
70
    
221
 
    if missing_inventory_sha_cnt:
222
 
        print '%d revisions are missing inventory_sha1' % missing_inventory_sha_cnt
223
 
 
224
 
    if missing_revision_sha_cnt:
225
 
        print '%d parent links are missing revision_sha1' % missing_revision_sha_cnt
226
 
 
227
 
    if (missing_inventory_sha_cnt
228
 
        or missing_revision_sha_cnt):
229
 
        print '  (use "bzr upgrade" to fix them)'
230
 
 
231
 
    if mismatch_inv_id:
232
 
        print '%d revisions have mismatched inventory ids:' % len(mismatch_inv_id)
233
 
        for rev_id in mismatch_inv_id:
234
 
            print '  ', rev_id
 
71
    for l in controlfile('inventory').readlines():
 
72
        parts = l.split()
 
73
        if len(parts) != 2:
 
74
            bailout("malformed inventory line: " + `l`)
 
75
        file_id, name = parts
 
76
        
 
77
        if file_id in seen_ids:
 
78
            bailout("duplicated file id " + file_id)
 
79
        seen_ids.add(file_id)
 
80
 
 
81
        if name in seen_names:
 
82
            bailout("duplicated file name in inventory: " + quotefn(name))
 
83
        seen_names.add(name)
 
84
        
 
85
        if is_control_file(name):
 
86
            raise BzrError("control file %s present in inventory" % quotefn(name))
 
87
 
 
88
 
 
89
def check_patches_exist():
 
90
    """Check constraint of current version: all patches exist"""
 
91
    mutter("checking all patches are present...")
 
92
    for pid in revision_history():
 
93
        read_patch_header(pid)
 
94
 
 
95
 
 
96
def check_patch_chaining():
 
97
    """Check ancestry of patches and history file is consistent"""
 
98
    mutter("checking patch chaining...")
 
99
    prev = None
 
100
    for pid in revision_history():
 
101
        log_prev = read_patch_header(pid).precursor
 
102
        if log_prev != prev:
 
103
            bailout("inconsistent precursor links on " + pid)
 
104
        prev = pid
 
105
 
 
106
 
 
107
def check_patch_uniqueness():
 
108
    """Make sure no patch is listed twice in the history.
 
109
 
 
110
    This should be implied by having correct ancestry but I'll check it
 
111
    anyhow."""
 
112
    mutter("checking history for duplicates...")
 
113
    seen = Set()
 
114
    for pid in revision_history():
 
115
        if pid in seen:
 
116
            bailout("patch " + pid + " appears twice in history")
 
117
        seen.add(pid)
 
118
        
 
119