← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/hashcache.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/hashcache.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
29
29
 
30
30
CACHE_HEADER = "### bzr hashcache v5\n"
31
31
 
32
 
import os, stat, time
 
32
import os
 
33
import stat
 
34
import time
33
35
 
34
 
from bzrlib.filters import internal_size_sha_file_byname
35
 
from bzrlib.osutils import sha_file, sha_string, pathjoin, safe_unicode
36
 
from bzrlib.trace import mutter, warning
37
 
from bzrlib.atomicfile import AtomicFile
38
 
from bzrlib.errors import BzrError
 
36
from bzrlib import (
 
37
    atomicfile,
 
38
    errors,
 
39
    filters as _mod_filters,
 
40
    osutils,
 
41
    trace,
 
42
    )
39
43
 
40
44
 
41
45
FP_MTIME_COLUMN = 1
89
93
            parameters and returns a stack of ContentFilters.
90
94
            If None, no content filtering is performed.
91
95
        """
92
 
        self.root = safe_unicode(root)
 
96
        self.root = osutils.safe_unicode(root)
93
97
        self.root_utf8 = self.root.encode('utf8') # where is the filesystem encoding ?
94
98
        self.hit_count = 0
95
99
        self.miss_count = 0
99
103
        self.update_count = 0
100
104
        self._cache = {}
101
105
        self._mode = mode
102
 
        self._cache_file_name = safe_unicode(cache_file_name)
 
106
        self._cache_file_name = osutils.safe_unicode(cache_file_name)
103
107
        self._filter_provider = content_filter_stack_provider
104
108
 
105
109
    def cache_file_name(self):
125
129
        prep.sort()
126
130
 
127
131
        for inum, path, cache_entry in prep:
128
 
            abspath = pathjoin(self.root, path)
 
132
            abspath = osutils.pathjoin(self.root, path)
129
133
            fp = self._fingerprint(abspath)
130
134
            self.stat_count += 1
131
135
 
141
145
        """Return the sha1 of a file.
142
146
        """
143
147
        if path.__class__ is str:
144
 
            abspath = pathjoin(self.root_utf8, path)
 
148
            abspath = osutils.pathjoin(self.root_utf8, path)
145
149
        else:
146
 
            abspath = pathjoin(self.root, path)
 
150
            abspath = osutils.pathjoin(self.root, path)
147
151
        self.stat_count += 1
148
152
        file_fp = self._fingerprint(abspath, stat_value)
149
153
 
176
180
                filters = self._filter_provider(path=path, file_id=None)
177
181
            digest = self._really_sha1_file(abspath, filters)
178
182
        elif stat.S_ISLNK(mode):
179
 
            digest = sha_string(os.readlink(abspath))
 
183
            target = osutils.readlink(osutils.safe_unicode(abspath))
 
184
            digest = osutils.sha_string(target.encode('UTF-8'))
180
185
        else:
181
 
            raise BzrError("file %r: unknown file stat mode: %o"%(abspath,mode))
 
186
            raise errors.BzrError("file %r: unknown file stat mode: %o"
 
187
                                  % (abspath, mode))
182
188
 
183
189
        # window of 3 seconds to allow for 2s resolution on windows,
184
190
        # unsynchronized file servers, etc.
213
219
 
214
220
    def _really_sha1_file(self, abspath, filters):
215
221
        """Calculate the SHA1 of a file by reading the full text"""
216
 
        return internal_size_sha_file_byname(abspath, filters)[1]
 
222
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
217
223
 
218
224
    def write(self):
219
225
        """Write contents of cache to file."""
220
 
        outf = AtomicFile(self.cache_file_name(), 'wb', new_mode=self._mode)
 
226
        outf = atomicfile.AtomicFile(self.cache_file_name(), 'wb',
 
227
                                     new_mode=self._mode)
221
228
        try:
222
229
            outf.write(CACHE_HEADER)
223
230
 
248
255
        try:
249
256
            inf = file(fn, 'rb', buffering=65000)
250
257
        except IOError, e:
251
 
            mutter("failed to open %s: %s", fn, e)
 
258
            trace.mutter("failed to open %s: %s", fn, e)
252
259
            # better write it now so it is valid
253
260
            self.needs_write = True
254
261
            return
255
262
 
256
263
        hdr = inf.readline()
257
264
        if hdr != CACHE_HEADER:
258
 
            mutter('cache header marker not found at top of %s;'
259
 
                   ' discarding cache', fn)
 
265
            trace.mutter('cache header marker not found at top of %s;'
 
266
                         ' discarding cache', fn)
260
267
            self.needs_write = True
261
268
            return
262
269
 
264
271
            pos = l.index('// ')
265
272
            path = l[:pos].decode('utf-8')
266
273
            if path in self._cache:
267
 
                warning('duplicated path %r in cache' % path)
 
274
                trace.warning('duplicated path %r in cache' % path)
268
275
                continue
269
276
 
270
277
            pos += 3
271
278
            fields = l[pos:].split(' ')
272
279
            if len(fields) != 7:
273
 
                warning("bad line in hashcache: %r" % l)
 
280
                trace.warning("bad line in hashcache: %r" % l)
274
281
                continue
275
282
 
276
283
            sha1 = fields[0]
277
284
            if len(sha1) != 40:
278
 
                warning("bad sha1 in hashcache: %r" % sha1)
 
285
                trace.warning("bad sha1 in hashcache: %r" % sha1)
279
286
                continue
280
287
 
281
288
            fp = tuple(map(long, fields[1:]))
282
289
 
283
290
            self._cache[path] = (sha1, fp)
284
291
 
 
292
        # GZ 2009-09-20: Should really use a try/finally block to ensure close
 
293
        inf.close()
 
294
 
285
295
        self.needs_write = False
286
296
 
287
297
    def _cutoff_time(self):