← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/statcache.py

  • Committer: Martin Pool
  • Date: 2005-05-10 06:34:41 UTC
  • Revision ID: mbp@sourcefrog.net-20050510063441-465de1f851add6a0
- Avoid dangerous files when writing out stat cache
- remove build_cache in favour of just update_cache with parameter
  to flush

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/statcache.py
57
57
"""
58
58
 
59
59
 
 
60
FP_SIZE  = 0
 
61
FP_MTIME = 1
 
62
FP_CTIME = 2
 
63
FP_INO   = 3
 
64
FP_DEV   = 4
 
65
 
60
66
 
61
67
def fingerprint(path, abspath):
62
68
    try:
72
78
            fs.st_ctime, fs.st_ino, fs.st_dev)
73
79
 
74
80
 
75
 
def _write_cache(branch, entry_iter):
 
81
def _write_cache(branch, entry_iter, dangerfiles):
76
82
    from atomicfile import AtomicFile
77
83
    
78
84
    outf = AtomicFile(branch.controlfilename('stat-cache'), 'wb', 'utf-8')
79
85
    try:
80
86
        for entry in entry_iter:
 
87
            if entry[0] in dangerfiles:
 
88
                continue
81
89
            outf.write(entry[0] + ' ' + entry[1] + ' ')
82
90
            outf.write(b2a_qp(entry[2], True))
83
91
            outf.write(' %d %d %d %d %d\n' % entry[3:])
114
122
        yield ie.file_id, path
115
123
    
116
124
 
117
 
def build_cache(branch):
118
 
    inv = branch.read_working_inventory()
119
 
 
120
 
    cache = {}
121
 
    _update_cache_from_list(branch, cache, _files_from_inventory(inv))
 
125
 
 
126
def update_cache(branch, flush=False):
 
127
    """Update and return the cache for the branch.
 
128
 
 
129
    The returned cache may contain entries that have not been written
 
130
    to disk for files recently touched.
 
131
 
 
132
    flush -- discard any previous cache and recalculate from scratch.
 
133
    """
 
134
 
122
135
    
123
 
 
124
 
 
125
 
def update_cache(branch, inv):
126
136
    # TODO: It's supposed to be faster to stat the files in order by inum.
127
137
    # We don't directly know the inum of the files of course but we do
128
138
    # know where they were last sighted, so we can sort by that.
129
139
 
130
 
    cache = load_cache(branch)
 
140
    if flush:
 
141
        cache = {}
 
142
    else:
 
143
        cache = load_cache(branch)
 
144
    inv = branch.read_working_inventory()
131
145
    return _update_cache_from_list(branch, cache, _files_from_inventory(inv))
132
146
 
133
147
 
134
148
 
135
149
def _update_cache_from_list(branch, cache, to_update):
136
 
    """Update the cache to have info on the named files.
137
 
 
138
 
    to_update is a sequence of (file_id, path) pairs.
 
150
    """Update and return the cache for given files.
 
151
 
 
152
    cache -- Previously cached values to be validated.
 
153
 
 
154
    to_update -- Sequence of (file_id, path) pairs to check.
139
155
    """
 
156
 
 
157
    from sets import Set
 
158
 
140
159
    hardcheck = dirty = 0
 
160
 
 
161
    # files that have been recently touched and can't be
 
162
    # committed to a persistent cache yet.
 
163
    
 
164
    dangerfiles = Set()
 
165
    now = int(time.time())
 
166
    
141
167
    for file_id, path in to_update:
142
168
        fap = branch.abspath(path)
143
169
        fp = fingerprint(fap, path)
149
175
                dirty += 1
150
176
            continue
151
177
 
 
178
        if (fp[FP_MTIME] >= now) or (fp[FP_CTIME] >= now):
 
179
            dangerfiles.add(file_id)
 
180
 
152
181
        if cacheentry and (cacheentry[3:] == fp):
153
182
            continue                    # all stat fields unchanged
154
183
 
163
192
            cache[file_id] = cacheentry
164
193
            dirty += 1
165
194
 
166
 
    mutter('statcache: read %d files, %d changed, %d in cache'
167
 
           % (hardcheck, dirty, len(cache)))
 
195
    mutter('statcache: read %d files, %d changed, %d dangerous, '
 
196
           '%d in cache'
 
197
           % (hardcheck, dirty, len(dangerfiles), len(cache)))
168
198
        
169
199
    if dirty:
170
 
        _write_cache(branch, cache.itervalues())
 
200
        mutter('updating on-disk statcache')
 
201
        _write_cache(branch, cache.itervalues(), dangerfiles)
171
202
 
172
203
    return cache