1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
# (C) 2005 Canonical Ltd
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# TODO: Perhaps have a way to stat all the files in inode order, and
# then remember that they're all fresh for the lifetime of the object?
# TODO: Keep track of whether there are in-memory updates that need to
# be flushed.
# TODO: Perhaps return more details on the file to avoid statting it
# again: nonexistent, file type, size, etc
CACHE_HEADER = "### bzr hashcache v5\n"
def _fingerprint(abspath):
import os, stat
try:
fs = os.lstat(abspath)
except OSError:
# might be missing, etc
return None
if stat.S_ISDIR(fs.st_mode):
return None
# we discard any high precision because it's not reliable; perhaps we
# could do better on some systems?
return (fs.st_size, long(fs.st_mtime),
long(fs.st_ctime), fs.st_ino, fs.st_dev)
class HashCache(object):
"""Cache for looking up file SHA-1.
Files are considered to match the cached value if the fingerprint
of the file has not changed. This includes its mtime, ctime,
device number, inode number, and size. This should catch
modifications or replacement of the file by a new one.
This may not catch modifications that do not change the file's
size and that occur within the resolution window of the
timestamps. To handle this we specifically do not cache files
which have changed since the start of the present second, since
they could undetectably change again.
This scheme may fail if the machine's clock steps backwards.
Don't do that.
This does not canonicalize the paths passed in; that should be
done by the caller.
_cache
Indexed by path, points to a two-tuple of the SHA-1 of the file.
and its fingerprint.
stat_count
number of times files have been statted
hit_count
number of times files have been retrieved from the cache, avoiding a
re-read
miss_count
number of misses (times files have been completely re-read)
"""
needs_write = False
def __init__(self, basedir):
self.basedir = basedir
self.hit_count = 0
self.miss_count = 0
self.stat_count = 0
self.danger_count = 0
self._cache = {}
def cache_file_name(self):
import os.path
return os.path.join(self.basedir, '.bzr', 'stat-cache')
def clear(self):
"""Discard all cached information.
This does not reset the counters."""
if self._cache:
self.needs_write = True
self._cache = {}
def get_sha1(self, path):
"""Return the hex SHA-1 of the contents of the file at path.
XXX: If the file does not exist or is not a plain file???
"""
import os, time
from bzrlib.osutils import sha_file
from bzrlib.trace import mutter
abspath = os.path.join(self.basedir, path)
fp = _fingerprint(abspath)
c = self._cache.get(path)
if c:
cache_sha1, cache_fp = c
else:
cache_sha1, cache_fp = None, None
self.stat_count += 1
if not fp:
# not a regular file
return None
elif cache_fp and (cache_fp == fp):
self.hit_count += 1
return cache_sha1
else:
self.miss_count += 1
digest = sha_file(file(abspath, 'rb'))
now = int(time.time())
if fp[1] >= now or fp[2] >= now:
# changed too recently; can't be cached. we can
# return the result and it could possibly be cached
# next time.
self.danger_count += 1
if cache_fp:
mutter("remove outdated entry for %s" % path)
self.needs_write = True
del self._cache[path]
elif (fp != cache_fp) or (digest != cache_sha1):
mutter("update entry for %s" % path)
mutter(" %r" % (fp,))
mutter(" %r" % (cache_fp,))
self.needs_write = True
self._cache[path] = (digest, fp)
return digest
def write(self):
"""Write contents of cache to file."""
from atomicfile import AtomicFile
outf = AtomicFile(self.cache_file_name(), 'wb')
try:
print >>outf, CACHE_HEADER,
for path, c in self._cache.iteritems():
assert '//' not in path, path
outf.write(path.encode('utf-8'))
outf.write('// ')
print >>outf, c[0], # hex sha1
for fld in c[1]:
print >>outf, "%d" % fld,
print >>outf
outf.commit()
self.needs_write = False
finally:
if not outf.closed:
outf.abort()
def read(self):
"""Reinstate cache from file.
Overwrites existing cache.
If the cache file has the wrong version marker, this just clears
the cache."""
from bzrlib.trace import mutter, warning
self._cache = {}
fn = self.cache_file_name()
try:
inf = file(fn, 'rb')
except IOError, e:
mutter("failed to open %s: %s" % (fn, e))
return
hdr = inf.readline()
if hdr != CACHE_HEADER:
mutter('cache header marker not found at top of %s; discarding cache'
% fn)
return
for l in inf:
pos = l.index('// ')
path = l[:pos].decode('utf-8')
if path in self._cache:
warning('duplicated path %r in cache' % path)
continue
pos += 3
fields = l[pos:].split(' ')
if len(fields) != 6:
warning("bad line in hashcache: %r" % l)
continue
sha1 = fields[0]
if len(sha1) != 40:
warning("bad sha1 in hashcache: %r" % sha1)
continue
fp = tuple(map(long, fields[1:]))
self._cache[path] = (sha1, fp)
self.needs_write = False
|