~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/hashcache.py

• browse files at revision 1668.1.15
• compare with another revision
• download diff
• download tarball
• view history from revision 1668.1.15

• reverse the comparison (1668.1.15 to 1711.2.114)
• stop comparing with revision 1711.2.114

Show diffs side-by-side

added

removed

bzrlib/hashcache.py

1

1

# Copyright (C) 2005, 2006 by 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

5

5

# the Free Software Foundation; either version 2 of the License, or

6

6

# (at your option) any later version.

7

 

#

 

7

 

8

8

# This program is distributed in the hope that it will be useful,

9

9

# but WITHOUT ANY WARRANTY; without even the implied warranty of

10

10

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

11

11

# GNU General Public License for more details.

12

 

#

 

12

 

13

13

# You should have received a copy of the GNU General Public License

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

42

42

FP_CTIME_COLUMN = 2

43

43

FP_MODE_COLUMN = 5

44

44

 

 

45

def _fingerprint(abspath):

 

46

    try:

 

47

        fs = os.lstat(abspath)

 

48

    except OSError:

 

49

        # might be missing, etc

 

50

        return None

 

51

 

 

52

    if stat.S_ISDIR(fs.st_mode):

 

53

        return None

 

54

 

 

55

    # we discard any high precision because it's not reliable; perhaps we

 

56

    # could do better on some systems?

 

57

    return (fs.st_size, long(fs.st_mtime),

 

58

            long(fs.st_ctime), fs.st_ino, fs.st_dev, fs.st_mode)

45

59

 

46

60

 

47

61

class HashCache(object):

117

131

        

118

132

        for inum, path, cache_entry in prep:

119

133

            abspath = pathjoin(self.root, path)

120

 

            fp = self._fingerprint(abspath)

 

134

            fp = _fingerprint(abspath)

121

135

            self.stat_count += 1

122

136

            

123

137

            cache_fp = cache_entry[1]

128

142

                self.needs_write = True

129

143

                del self._cache[path]

130

144

 

 

145

 

131

146

    def get_sha1(self, path):

132

147

        """Return the sha1 of a file.

133

148

        """

134

149

        abspath = pathjoin(self.root, path)

135

150

        self.stat_count += 1

136

 

        file_fp = self._fingerprint(abspath)

 

151

        file_fp = _fingerprint(abspath)

137

152

        

138

153

        if not file_fp:

139

154

            # not a regular file or not existing

149

164

            cache_sha1, cache_fp = None, None

150

165

 

151

166

        if cache_fp == file_fp:

152

 

            ## mutter("hashcache hit for %s %r -> %s", path, file_fp, cache_sha1)

153

 

            ## mutter("now = %s", time.time())

154

167

            self.hit_count += 1

155

168

            return cache_sha1

156

169

        

157

170

        self.miss_count += 1

158

171

 

 

172

 

159

173

        mode = file_fp[FP_MODE_COLUMN]

160

174

        if stat.S_ISREG(mode):

161

 

            digest = self._really_sha1_file(abspath)

 

175

            digest = sha_file(file(abspath, 'rb', buffering=65000))

162

176

        elif stat.S_ISLNK(mode):

163

177

            digest = sha.new(os.readlink(abspath)).hexdigest()

164

178

        else:

165

179

            raise BzrError("file %r: unknown file stat mode: %o"%(abspath,mode))

166

180

 

167

 

        # window of 3 seconds to allow for 2s resolution on windows,

168

 

        # unsynchronized file servers, etc.

169

 

        cutoff = self._cutoff_time()

170

 

        if file_fp[FP_MTIME_COLUMN] >= cutoff \

171

 

                or file_fp[FP_CTIME_COLUMN] >= cutoff:

 

181

        now = int(time.time())

 

182

        if file_fp[FP_MTIME_COLUMN] >= now or file_fp[FP_CTIME_COLUMN] >= now:

172

183

            # changed too recently; can't be cached.  we can

173

184

            # return the result and it could possibly be cached

174

185

            # next time.

180

191

            # need to let sufficient time elapse before we may cache this entry

181

192

            # again.  If we didn't do this, then, for example, a very quick 1

182

193

            # byte replacement in the file might go undetected.

183

 

            ## mutter('%r modified too recently; not caching', path)

184

 

            self.danger_count += 1

 

194

            self.danger_count += 1 

185

195

            if cache_fp:

186

196

                self.removed_count += 1

187

197

                self.needs_write = True

188

198

                del self._cache[path]

189

199

        else:

190

 

            ## mutter('%r added to cache: now=%f, mtime=%d, ctime=%d',

191

 

            ##        path, time.time(), file_fp[FP_MTIME_COLUMN],

192

 

            ##        file_fp[FP_CTIME_COLUMN])

193

200

            self.update_count += 1

194

201

            self.needs_write = True

195

202

            self._cache[path] = (digest, file_fp)

196

203

        return digest

197

 

 

198

 

    def _really_sha1_file(self, abspath):

199

 

        """Calculate the SHA1 of a file by reading the full text"""

200

 

        return sha_file(file(abspath, 'rb', buffering=65000))

201

204

        

202

205

    def write(self):

203

206

        """Write contents of cache to file."""

204

207

        outf = AtomicFile(self.cache_file_name(), 'wb', new_mode=self._mode)

205

208

        try:

206

 

            outf.write(CACHE_HEADER)

 

209

            print >>outf, CACHE_HEADER,

207

210

 

208

211

            for path, c  in self._cache.iteritems():

209

212

                assert '//' not in path, path

210

 

                line_info = [path.encode('utf-8'), '// ', c[0], ' ']

211

 

                line_info.append(' '.join([str(fld) for fld in c[1]]))

212

 

                line_info.append('\n')

213

 

                outf.write(''.join(line_info))

 

213

                outf.write(path.encode('utf-8'))

 

214

                outf.write('// ')

 

215

                print >>outf, c[0],     # hex sha1

 

216

                for fld in c[1]:

 

217

                    print >>outf, "%d" % fld,

 

218

                print >>outf

214

219

            outf.commit()

215

220

            self.needs_write = False

216

 

            ## mutter("write hash cache: %s hits=%d misses=%d stat=%d recent=%d updates=%d",

217

 

            ##        self.cache_file_name(), self.hit_count, self.miss_count,

218

 

            ##        self.stat_count,

219

 

            ##        self.danger_count, self.update_count)

 

221

            mutter("write hash cache: %s hits=%d misses=%d stat=%d recent=%d updates=%d",

 

222

                   self.cache_file_name(), self.hit_count, self.miss_count,

 

223

                   self.stat_count,

 

224

                   self.danger_count, self.update_count)

220

225

        finally:

221

 

            outf.close()

 

226

            if not outf.closed:

 

227

                outf.abort()

222

228

 

223

229

    def read(self):

224

230

        """Reinstate cache from file.

238

244

            self.needs_write = True

239

245

            return

240

246

 

 

247

 

241

248

        hdr = inf.readline()

242

249

        if hdr != CACHE_HEADER:

243

250

            mutter('cache header marker not found at top of %s;'

268

275

            self._cache[path] = (sha1, fp)

269

276

 

270

277

        self.needs_write = False

271

 

 

272

 

    def _cutoff_time(self):

273

 

        """Return cutoff time.

274

 

 

275

 

        Files modified more recently than this time are at risk of being

276

 

        undetectably modified and so can't be cached.

277

 

        """

278

 

        return int(time.time()) - 3

279

278

           

280

 

    def _fingerprint(self, abspath):

281

 

        try:

282

 

            fs = os.lstat(abspath)

283

 

        except OSError:

284

 

            # might be missing, etc

285

 

            return None

286

 

        if stat.S_ISDIR(fs.st_mode):

287

 

            return None

288

 

        # we discard any high precision because it's not reliable; perhaps we

289

 

        # could do better on some systems?

290

 

        return (fs.st_size, long(fs.st_mtime),

291

 

                long(fs.st_ctime), fs.st_ino, fs.st_dev, fs.st_mode)

 

279

 

 

280

 

 

281

        

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1