← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/hashcache.py

  • Committer: Robert J. Tanner
  • Date: 2009-04-20 08:37:32 UTC
  • mfrom: (4299 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4300.
  • Revision ID: tanner@real-time.com-20090420083732-bzx919oo7wpmqc2u
[merge] 1.14rc2 back into bzr.dev (Bob Tanner)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/hashcache.py
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
            digest = osutils.sha_string(os.readlink(abspath))
180
184
        else:
181
 
            raise BzrError("file %r: unknown file stat mode: %o"%(abspath,mode))
 
185
            raise errors.BzrError("file %r: unknown file stat mode: %o"
 
186
                                  % (abspath, mode))
182
187
 
183
188
        # window of 3 seconds to allow for 2s resolution on windows,
184
189
        # unsynchronized file servers, etc.
213
218
 
214
219
    def _really_sha1_file(self, abspath, filters):
215
220
        """Calculate the SHA1 of a file by reading the full text"""
216
 
        return internal_size_sha_file_byname(abspath, filters)[1]
 
221
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
217
222
 
218
223
    def write(self):
219
224
        """Write contents of cache to file."""
220
 
        outf = AtomicFile(self.cache_file_name(), 'wb', new_mode=self._mode)
 
225
        outf = atomicfile.AtomicFile(self.cache_file_name(), 'wb',
 
226
                                     new_mode=self._mode)
221
227
        try:
222
228
            outf.write(CACHE_HEADER)
223
229
 
248
254
        try:
249
255
            inf = file(fn, 'rb', buffering=65000)
250
256
        except IOError, e:
251
 
            mutter("failed to open %s: %s", fn, e)
 
257
            trace.mutter("failed to open %s: %s", fn, e)
252
258
            # better write it now so it is valid
253
259
            self.needs_write = True
254
260
            return
255
261
 
256
262
        hdr = inf.readline()
257
263
        if hdr != CACHE_HEADER:
258
 
            mutter('cache header marker not found at top of %s;'
259
 
                   ' discarding cache', fn)
 
264
            trace.mutter('cache header marker not found at top of %s;'
 
265
                         ' discarding cache', fn)
260
266
            self.needs_write = True
261
267
            return
262
268
 
264
270
            pos = l.index('// ')
265
271
            path = l[:pos].decode('utf-8')
266
272
            if path in self._cache:
267
 
                warning('duplicated path %r in cache' % path)
 
273
                trace.warning('duplicated path %r in cache' % path)
268
274
                continue
269
275
 
270
276
            pos += 3
271
277
            fields = l[pos:].split(' ')
272
278
            if len(fields) != 7:
273
 
                warning("bad line in hashcache: %r" % l)
 
279
                trace.warning("bad line in hashcache: %r" % l)
274
280
                continue
275
281
 
276
282
            sha1 = fields[0]
277
283
            if len(sha1) != 40:
278
 
                warning("bad sha1 in hashcache: %r" % sha1)
 
284
                trace.warning("bad sha1 in hashcache: %r" % sha1)
279
285
                continue
280
286
 
281
287
            fp = tuple(map(long, fields[1:]))