~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/check.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-06 05:02:09 UTC
  • Revision ID: mbp@sourcefrog.net-20050406050209-fa9f0c791a1bedd023281fd0
bzr 0.0.3 release!

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
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
 
    raise NotImplementedError("can't update existing inventory entry")
76
 
 
77
 
 
78
 
def check(branch):
79
 
    """Run consistency checks on a branch.
80
 
 
81
 
    TODO: Also check non-mainline revisions mentioned as parents.
82
 
 
83
 
    TODO: Check for extra files in the control directory.
84
 
    """
85
 
    from bzrlib.trace import mutter
86
 
    from bzrlib.errors import BzrCheckError, NoSuchRevision
87
 
    from bzrlib.osutils import fingerprint_file
88
 
    from bzrlib.inventory import ROOT_ID
89
 
    from bzrlib.branch import gen_root_id
90
 
 
91
 
    branch.lock_read()
92
 
 
93
 
    try:
94
 
        last_rev_id = None
95
 
 
96
 
        missing_inventory_sha_cnt = 0
97
 
        missing_revision_sha_cnt = 0
98
 
        missing_revision_cnt = 0
99
 
 
100
 
        history = branch.revision_history()
101
 
        revno = 0
102
 
        revcount = len(history)
103
 
        mismatch_inv_id = []
104
 
 
105
 
        # for all texts checked, text_id -> sha1
106
 
        checked_texts = {}
107
 
 
108
 
        progress = bzrlib.ui.ui_factory.progress_bar()
109
 
 
110
 
        for rev_id in history:
111
 
            revno += 1
112
 
            progress.update('checking revision', revno, revcount)
113
 
            # mutter('    revision {%s}' % rev_id)
114
 
            rev = branch.get_revision(rev_id)
115
 
            if rev.revision_id != rev_id:
116
 
                raise BzrCheckError('wrong internal revision id in revision {%s}'
117
 
                                    % rev_id)
118
 
 
119
 
            # check the previous history entry is a parent of this entry
120
 
            if rev.parents:
121
 
                if last_rev_id is None:
122
 
                    raise BzrCheckError("revision {%s} has %d parents, but is the "
123
 
                                        "start of the branch"
124
 
                                        % (rev_id, len(rev.parents)))
125
 
                for prr in rev.parents:
126
 
                    if prr.revision_id == last_rev_id:
127
 
                        break
 
18
 
 
19
 
 
20
######################################################################
 
21
# consistency checks
 
22
 
 
23
import sys
 
24
from sets import Set
 
25
 
 
26
import bzrlib
 
27
from trace import mutter
 
28
from errors import bailout
 
29
import osutils
 
30
 
 
31
def check(branch, progress=True):
 
32
    out = sys.stdout
 
33
 
 
34
    if progress:
 
35
        def p(m):
 
36
            mutter('checking ' + m)
 
37
            out.write('\rchecking: %-50.50s' % m)
 
38
            out.flush()
 
39
    else:
 
40
        def p(m):
 
41
            mutter('checking ' + m)
 
42
 
 
43
    p('history of %r' % branch.base)
 
44
    last_ptr = None
 
45
    checked_revs = Set()
 
46
    
 
47
    history = branch.revision_history()
 
48
    revno = 0
 
49
    revcount = len(history)
 
50
 
 
51
    checked_texts = {}
 
52
    
 
53
    for rid in history:
 
54
        revno += 1
 
55
        p('revision %d/%d' % (revno, revcount))
 
56
        mutter('    revision {%s}' % rid)
 
57
        rev = branch.get_revision(rid)
 
58
        if rev.revision_id != rid:
 
59
            bailout('wrong internal revision id in revision {%s}' % rid)
 
60
        if rev.precursor != last_ptr:
 
61
            bailout('mismatched precursor in revision {%s}' % rid)
 
62
        last_ptr = rid
 
63
        if rid in checked_revs:
 
64
            bailout('repeated revision {%s}' % rid)
 
65
        checked_revs.add(rid)
 
66
 
 
67
        ## TODO: Check all the required fields are present on the revision.
 
68
 
 
69
        inv = branch.get_inventory(rev.inventory_id)
 
70
        seen_ids = Set()
 
71
        seen_names = Set()
 
72
 
 
73
        p('revision %d/%d file ids' % (revno, revcount))
 
74
        for file_id in inv:
 
75
            if file_id in seen_ids:
 
76
                bailout('duplicated file_id {%s} in inventory for revision {%s}'
 
77
                        % (file_id, revid))
 
78
            seen_ids.add(file_id)
 
79
 
 
80
        i = 0
 
81
        len_inv = len(inv)
 
82
        for file_id in inv:
 
83
            i += 1
 
84
            if (i % 100) == 0:
 
85
                p('revision %d/%d file text %d/%d' % (revno, revcount, i, len_inv))
 
86
 
 
87
            ie = inv[file_id]
 
88
 
 
89
            if ie.parent_id != None:
 
90
                if ie.parent_id not in seen_ids:
 
91
                    bailout('missing parent {%s} in inventory for revision {%s}'
 
92
                            % (ie.parent_id, revid))
 
93
 
 
94
            if ie.kind == 'file':
 
95
                if ie.text_id in checked_texts:
 
96
                    fp = checked_texts[ie.text_id]
128
97
                else:
129
 
                    raise BzrCheckError("previous revision {%s} not listed among "
130
 
                                        "parents of {%s}"
131
 
                                        % (last_rev_id, rev_id))
132
 
 
133
 
                for prr in rev.parents:
134
 
                    if prr.revision_sha1 is None:
135
 
                        missing_revision_sha_cnt += 1
136
 
                        continue
137
 
                    prid = prr.revision_id
138
 
                    
139
 
                    try:
140
 
                        actual_sha = branch.get_revision_sha1(prid)
141
 
                    except NoSuchRevision:
142
 
                        missing_revision_cnt += 1
143
 
                        mutter("parent {%s} of {%s} not present in store",
144
 
                               prid, rev_id)
145
 
                        continue
146
 
                        
147
 
                    if prr.revision_sha1 != actual_sha:
148
 
                        raise BzrCheckError("mismatched revision sha1 for "
149
 
                                            "parent {%s} of {%s}: %s vs %s"
150
 
                                            % (prid, rev_id,
151
 
                                               prr.revision_sha1, actual_sha))
152
 
            elif last_rev_id:
153
 
                raise BzrCheckError("revision {%s} has no parents listed but preceded "
154
 
                                    "by {%s}"
155
 
                                    % (rev_id, last_rev_id))
156
 
 
157
 
            if hasattr(rev, 'inventory_id') and rev.inventory_id != rev_id:
158
 
                mismatch_inv_id.append(rev_id)
159
 
 
160
 
            ## TODO: Check all the required fields are present on the revision.
161
 
 
162
 
            if rev.inventory_sha1:
163
 
                inv_sha1 = branch.get_inventory_sha1(rev_id)
164
 
                if inv_sha1 != rev.inventory_sha1:
165
 
                    raise BzrCheckError('Inventory sha1 hash doesn\'t match'
166
 
                        ' value in revision {%s}' % rev_id)
167
 
            else:
168
 
                missing_inventory_sha_cnt += 1
169
 
                mutter("no inventory_sha1 on revision {%s}" % rev_id)
170
 
 
171
 
            inv = branch.get_inventory(rev_id)
172
 
            seen_ids = {}
173
 
            seen_names = {}
174
 
 
175
 
            ## p('revision %d/%d file ids' % (revno, revcount))
176
 
            for file_id in inv:
177
 
                if file_id in seen_ids:
178
 
                    raise BzrCheckError('duplicated file_id {%s} '
179
 
                                        'in inventory for revision {%s}'
180
 
                                        % (file_id, rev_id))
181
 
                seen_ids[file_id] = True
182
 
 
183
 
            i = 0
184
 
            for file_id in inv:
185
 
                i += 1
186
 
                if i & 31 == 0:
187
 
                    progress.tick()
188
 
 
189
 
                ie = inv[file_id]
190
 
 
191
 
                if ie.parent_id != None:
192
 
                    if ie.parent_id not in seen_ids:
193
 
                        raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
194
 
                                % (ie.parent_id, rev_id))
195
 
 
196
 
                if ie.kind == 'file':
197
 
                    if ie.text_id in checked_texts:
198
 
                        fp = checked_texts[ie.text_id]
199
 
                    else:
200
 
                        if not ie.text_id in branch.text_store:
201
 
                            raise BzrCheckError('text {%s} not in text_store' % ie.text_id)
202
 
 
203
 
                        tf = branch.text_store[ie.text_id]
204
 
                        fp = fingerprint_file(tf)
205
 
                        checked_texts[ie.text_id] = fp
206
 
 
207
 
                    if ie.text_size != fp['size']:
208
 
                        raise BzrCheckError('text {%s} wrong size' % ie.text_id)
209
 
                    if ie.text_sha1 != fp['sha1']:
210
 
                        raise BzrCheckError('text {%s} wrong sha1' % ie.text_id)
211
 
                elif ie.kind == 'directory':
212
 
                    if ie.text_sha1 != None or ie.text_size != None or ie.text_id != None:
213
 
                        raise BzrCheckError('directory {%s} has text in revision {%s}'
214
 
                                % (file_id, rev_id))
215
 
 
216
 
            progress.tick()
217
 
            for path, ie in inv.iter_entries():
218
 
                if path in seen_names:
219
 
                    raise BzrCheckError('duplicated path %s '
220
 
                                        'in inventory for revision {%s}'
221
 
                                        % (path, rev_id))
222
 
            seen_names[path] = True
223
 
            last_rev_id = rev_id
224
 
 
225
 
    finally:
226
 
        branch.unlock()
227
 
 
228
 
    progress.clear()
229
 
 
230
 
    note('checked %d revisions, %d file texts' % (revcount, len(checked_texts)))
231
 
    
232
 
    if missing_inventory_sha_cnt:
233
 
        note('%d revisions are missing inventory_sha1' % missing_inventory_sha_cnt)
234
 
 
235
 
    if missing_revision_sha_cnt:
236
 
        note('%d parent links are missing revision_sha1' % missing_revision_sha_cnt)
237
 
 
238
 
    if missing_revision_cnt:
239
 
        note('%d revisions are mentioned but not present' % missing_revision_cnt)
240
 
 
241
 
    if missing_revision_cnt:
242
 
        print '%d revisions are mentioned but not present' % missing_revision_cnt
243
 
 
244
 
    # stub this out for now because the main bzr branch has references
245
 
    # to revisions that aren't present in the store -- mbp 20050804
246
 
#    if (missing_inventory_sha_cnt
247
 
#        or missing_revision_sha_cnt):
248
 
#        print '  (use "bzr upgrade" to fix them)'
249
 
 
250
 
    if mismatch_inv_id:
251
 
        warning('%d revisions have mismatched inventory ids:' % len(mismatch_inv_id))
252
 
        for rev_id in mismatch_inv_id:
253
 
            warning('  %s', rev_id)
 
98
                    if not ie.text_id in branch.text_store:
 
99
                        bailout('text {%s} not in text_store' % ie.text_id)
 
100
 
 
101
                    tf = branch.text_store[ie.text_id]
 
102
                    fp = osutils.fingerprint_file(tf)
 
103
                    checked_texts[ie.text_id] = fp
 
104
 
 
105
                if ie.text_size != fp['size']:
 
106
                    bailout('text {%s} wrong size' % ie.text_id)
 
107
                if ie.text_sha1 != fp['sha1']:
 
108
                    bailout('text {%s} wrong sha1' % ie.text_id)
 
109
            elif ie.kind == 'directory':
 
110
                if ie.text_sha1 != None or ie.text_size != None or ie.text_id != None:
 
111
                    bailout('directory {%s} has text in revision {%s}'
 
112
                            % (file_id, revid))
 
113
 
 
114
        p('revision %d/%d file paths' % (revno, revcount))
 
115
        for path, ie in inv.iter_entries():
 
116
            if path in seen_names:
 
117
                bailout('duplicated path %r in inventory for revision {%s}' % (path, revid))
 
118
            seen_names.add(path)
 
119
 
 
120
 
 
121
    p('done')
 
122
    if progress:
 
123
        print 
 
124
 
 
125