← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/hashcache.py

  • Committer: Martin Pool
  • Date: 2005-07-11 02:02:58 UTC
  • Revision ID: mbp@sourcefrog.net-20050711020258-2281af27e5af39d2
- more weave.py command line options

- better error when invalid version is given

- weave help and weave mash commands

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/hashcache.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
# TODO: Up-front, stat all files in order and remove those which are deleted or 
18
 
# out-of-date.  Don't actually re-read them until they're needed.  That ought 
19
 
# to bring all the inodes into core so that future stats to them are fast, and 
20
 
# it preserves the nice property that any caller will always get up-to-date
21
 
# data except in unavoidable cases.
 
17
 
 
18
 
 
19
# TODO: Perhaps have a way to stat all the files in inode order, and
 
20
# then remember that they're all fresh for the lifetime of the object?
 
21
 
 
22
# TODO: Keep track of whether there are in-memory updates that need to
 
23
# be flushed.
22
24
 
23
25
# TODO: Perhaps return more details on the file to avoid statting it
24
26
# again: nonexistent, file type, size, etc
25
27
 
26
 
# TODO: Perhaps use a Python pickle instead of a text file; might be faster.
27
28
 
28
29
 
29
30
 
30
31
CACHE_HEADER = "### bzr hashcache v5\n"
31
32
 
32
 
import os, stat, time
33
 
import sha
34
 
 
35
 
from bzrlib.osutils import sha_file
36
 
from bzrlib.trace import mutter, warning
37
 
from bzrlib.atomicfile import AtomicFile
38
 
 
39
 
 
40
 
FP_MODE_COLUMN = 5
41
33
 
42
34
def _fingerprint(abspath):
 
35
    import os, stat
 
36
 
43
37
    try:
44
38
        fs = os.lstat(abspath)
45
39
    except OSError:
52
46
    # we discard any high precision because it's not reliable; perhaps we
53
47
    # could do better on some systems?
54
48
    return (fs.st_size, long(fs.st_mtime),
55
 
            long(fs.st_ctime), fs.st_ino, fs.st_dev, fs.st_mode)
 
49
            long(fs.st_ctime), fs.st_ino, fs.st_dev)
56
50
 
57
51
 
58
52
class HashCache(object):
97
91
        self.miss_count = 0
98
92
        self.stat_count = 0
99
93
        self.danger_count = 0
100
 
        self.removed_count = 0
101
 
        self.update_count = 0
102
94
        self._cache = {}
103
95
 
 
96
 
 
97
 
104
98
    def cache_file_name(self):
105
 
        # FIXME: duplicate path logic here, this should be 
106
 
        # something like 'branch.controlfile'.
107
 
        return os.sep.join([self.basedir, '.bzr', 'stat-cache'])
 
99
        import os.path
 
100
        return os.path.join(self.basedir, '.bzr', 'stat-cache')
 
101
 
 
102
 
 
103
 
108
104
 
109
105
    def clear(self):
110
106
        """Discard all cached information.
115
111
            self._cache = {}
116
112
 
117
113
 
118
 
    def scan(self):
119
 
        """Scan all files and remove entries where the cache entry is obsolete.
120
 
        
121
 
        Obsolete entries are those where the file has been modified or deleted
122
 
        since the entry was inserted.        
123
 
        """
124
 
        prep = [(ce[1][3], path, ce) for (path, ce) in self._cache.iteritems()]
125
 
        prep.sort()
126
 
        
127
 
        for inum, path, cache_entry in prep:
128
 
            abspath = os.sep.join([self.basedir, path])
129
 
            fp = _fingerprint(abspath)
130
 
            self.stat_count += 1
131
 
            
132
 
            cache_fp = cache_entry[1]
133
 
    
134
 
            if (not fp) or (cache_fp != fp):
135
 
                # not here or not a regular file anymore
136
 
                self.removed_count += 1
137
 
                self.needs_write = True
138
 
                del self._cache[path]
139
 
 
140
 
 
141
114
    def get_sha1(self, path):
142
 
        """Return the sha1 of a file.
 
115
        """Return the hex SHA-1 of the contents of the file at path.
 
116
 
 
117
        XXX: If the file does not exist or is not a plain file???
143
118
        """
144
 
        abspath = os.sep.join([self.basedir, path])
 
119
 
 
120
        import os, time
 
121
        from bzrlib.osutils import sha_file
 
122
        from bzrlib.trace import mutter
 
123
        
 
124
        abspath = os.path.join(self.basedir, path)
 
125
        fp = _fingerprint(abspath)
 
126
        c = self._cache.get(path)
 
127
        if c:
 
128
            cache_sha1, cache_fp = c
 
129
        else:
 
130
            cache_sha1, cache_fp = None, None
 
131
 
145
132
        self.stat_count += 1
146
 
        file_fp = _fingerprint(abspath)
147
 
        
148
 
        if not file_fp:
149
 
            # not a regular file or not existing
150
 
            if path in self._cache:
151
 
                self.removed_count += 1
152
 
                self.needs_write = True
153
 
                del self._cache[path]
154
 
            return None        
155
 
 
156
 
        if path in self._cache:
157
 
            cache_sha1, cache_fp = self._cache[path]
158
 
        else:
159
 
            cache_sha1, cache_fp = None, None
160
 
 
161
 
        if cache_fp == file_fp:
 
133
 
 
134
        if not fp:
 
135
            # not a regular file
 
136
            return None
 
137
        elif cache_fp and (cache_fp == fp):
162
138
            self.hit_count += 1
163
139
            return cache_sha1
164
 
        
165
 
        self.miss_count += 1
166
 
 
167
 
 
168
 
        mode = file_fp[FP_MODE_COLUMN]
169
 
        if stat.S_ISREG(mode):
170
 
            digest = sha_file(file(abspath, 'rb', buffering=65000))
171
 
        elif stat.S_ISLNK(mode):
172
 
            link_target = os.readlink(abspath)
173
 
            digest = sha.new(os.readlink(abspath)).hexdigest()
174
140
        else:
175
 
            raise BzrError("file %r: unknown file stat mode: %o"%(abspath,mode))
 
141
            self.miss_count += 1
 
142
            digest = sha_file(file(abspath, 'rb'))
176
143
 
177
 
        now = int(time.time())
178
 
        if file_fp[1] >= now or file_fp[2] >= now:
179
 
            # changed too recently; can't be cached.  we can
180
 
            # return the result and it could possibly be cached
181
 
            # next time.
182
 
            self.danger_count += 1 
183
 
            if cache_fp:
184
 
                self.removed_count += 1
 
144
            now = int(time.time())
 
145
            if fp[1] >= now or fp[2] >= now:
 
146
                # changed too recently; can't be cached.  we can
 
147
                # return the result and it could possibly be cached
 
148
                # next time.
 
149
                self.danger_count += 1 
 
150
                if cache_fp:
 
151
                    mutter("remove outdated entry for %s" % path)
 
152
                    self.needs_write = True
 
153
                    del self._cache[path]
 
154
            elif (fp != cache_fp) or (digest != cache_sha1):
 
155
                mutter("update entry for %s" % path)
 
156
                mutter("  %r" % (fp,))
 
157
                mutter("  %r" % (cache_fp,))
185
158
                self.needs_write = True
186
 
                del self._cache[path]
187
 
        else:
188
 
            self.update_count += 1
189
 
            self.needs_write = True
190
 
            self._cache[path] = (digest, file_fp)
191
 
        return digest
192
 
        
 
159
                self._cache[path] = (digest, fp)
 
160
 
 
161
            return digest
 
162
 
 
163
 
 
164
 
193
165
    def write(self):
194
166
        """Write contents of cache to file."""
 
167
        from atomicfile import AtomicFile
 
168
 
195
169
        outf = AtomicFile(self.cache_file_name(), 'wb')
196
170
        try:
197
171
            print >>outf, CACHE_HEADER,
210
184
        finally:
211
185
            if not outf.closed:
212
186
                outf.abort()
 
187
        
 
188
 
213
189
 
214
190
    def read(self):
215
191
        """Reinstate cache from file.
218
194
 
219
195
        If the cache file has the wrong version marker, this just clears 
220
196
        the cache."""
 
197
        from bzrlib.trace import mutter, warning
 
198
 
221
199
        self._cache = {}
222
200
 
223
201
        fn = self.cache_file_name()
224
202
        try:
225
 
            inf = file(fn, 'rb', buffering=65000)
 
203
            inf = file(fn, 'rb')
226
204
        except IOError, e:
227
 
            mutter("failed to open %s: %s", fn, e)
228
 
            # better write it now so it is valid
229
 
            self.needs_write = True
 
205
            mutter("failed to open %s: %s" % (fn, e))
230
206
            return
231
207
 
232
208
 
233
209
        hdr = inf.readline()
234
210
        if hdr != CACHE_HEADER:
235
 
            mutter('cache header marker not found at top of %s;'
236
 
                   ' discarding cache', fn)
237
 
            self.needs_write = True
 
211
            mutter('cache header marker not found at top of %s; discarding cache'
 
212
                   % cachefn)
238
213
            return
239
214
 
240
215
        for l in inf:
246
221
 
247
222
            pos += 3
248
223
            fields = l[pos:].split(' ')
249
 
            if len(fields) != 7:
 
224
            if len(fields) != 6:
250
225
                warning("bad line in hashcache: %r" % l)
251
226
                continue
252
227