Merge branch 'stable' into beta

Conflicts:
	package.json

src/compile-cache.js

@@ -1,5 +1,10 @@
 'use strict'
 
+// For now, we're not using babel or ES6 features like `let` and `const` in
+// this file, because `apm` requires this file directly in order to pre-warm
+// Atom's compile-cache when installing or updating packages, using an older
+// version of node.js
+
 var path = require('path')
 var fs = require('fs-plus')
 var CSON = null
@@ -159,8 +164,7 @@ require('source-map-support').install({
 })
 
 var prepareStackTraceWithSourceMapping = Error.prepareStackTrace
-
-let prepareStackTrace = prepareStackTraceWithSourceMapping
+var prepareStackTrace = prepareStackTraceWithSourceMapping
 
 function prepareStackTraceWithRawStackAssignment (error, frames) {
   if (error.rawStack) { // avoid infinite recursion

src/file-system-blob-store.js

@@ -13,8 +13,10 @@ class FileSystemBlobStore {
 
   constructor (directory) {
     this.inMemoryBlobs = new Map()
+    this.invalidationKeys = {}
     this.blobFilename = path.join(directory, 'BLOB')
     this.blobMapFilename = path.join(directory, 'MAP')
+    this.invalidationKeysFilename = path.join(directory, 'INVKEYS')
     this.lockFilename = path.join(directory, 'LOCK')
     this.storedBlob = new Buffer(0)
     this.storedBlobMap = {}
@@ -27,14 +29,19 @@ class FileSystemBlobStore {
     if (!fs.existsSync(this.blobFilename)) {
       return
     }
+    if (!fs.existsSync(this.invalidationKeysFilename)) {
+      return
+    }
     this.storedBlob = fs.readFileSync(this.blobFilename)
     this.storedBlobMap = JSON.parse(fs.readFileSync(this.blobMapFilename))
+    this.invalidationKeys = JSON.parse(fs.readFileSync(this.invalidationKeysFilename))
   }
 
   save () {
     let dump = this.getDump()
     let blobToStore = Buffer.concat(dump[0])
     let mapToStore = JSON.stringify(dump[1])
+    let invalidationKeysToStore = JSON.stringify(this.invalidationKeys)
 
     let acquiredLock = false
     try {
@@ -43,6 +50,7 @@ class FileSystemBlobStore {
 
       fs.writeFileSync(this.blobFilename, blobToStore)
       fs.writeFileSync(this.blobMapFilename, mapToStore)
+      fs.writeFileSync(this.invalidationKeysFilename, invalidationKeysToStore)
     } catch (error) {
       // Swallow the exception silently only if we fail to acquire the lock.
       if (error.code !== 'EEXIST') {
@@ -55,15 +63,20 @@ class FileSystemBlobStore {
     }
   }
 
-  has (key) {
-    return this.inMemoryBlobs.hasOwnProperty(key) || this.storedBlobMap.hasOwnProperty(key)
+  has (key, invalidationKey) {
+    let containsKey = this.inMemoryBlobs.has(key) || this.storedBlobMap.hasOwnProperty(key)
+    let isValid = this.invalidationKeys[key] === invalidationKey
+    return containsKey && isValid
   }
 
-  get (key) {
-    return this.getFromMemory(key) || this.getFromStorage(key)
+  get (key, invalidationKey) {
+    if (this.has(key, invalidationKey)) {
+      return this.getFromMemory(key) || this.getFromStorage(key)
+    }
   }
 
-  set (key, buffer) {
+  set (key, invalidationKey, buffer) {
+    this.invalidationKeys[key] = invalidationKey
     return this.inMemoryBlobs.set(key, buffer)
   }
 

src/native-compile-cache.js

@@ -3,6 +3,11 @@
 const Module = require('module')
 const path = require('path')
 const cachedVm = require('cached-run-in-this-context')
+const crypto = require('crypto')
+
+function computeHash (contents) {
+  return crypto.createHash('sha1').update(contents, 'utf8').digest('hex')
+}
 
 class NativeCompileCache {
   constructor () {
@@ -14,6 +19,10 @@ class NativeCompileCache {
     this.cacheStore = store
   }
 
+  setV8Version (v8Version) {
+    this.v8Version = v8Version.toString()
+  }
+
   install () {
     this.savePreviousModuleCompile()
     this.overrideModuleCompile()
@@ -28,20 +37,20 @@ class NativeCompileCache {
   }
 
   overrideModuleCompile () {
-    let cacheStore = this.cacheStore
+    let self = this
     let resolvedArgv = null
     // Here we override Node's module.js
     // (https://github.com/atom/node/blob/atom/lib/module.js#L378), changing
     // only the bits that affect compilation in order to use the cached one.
     Module.prototype._compile = function (content, filename) {
-      let self = this
+      let moduleSelf = this
       // remove shebang
       content = content.replace(/^\#\!.*/, '')
       function require (path) {
-        return self.require(path)
+        return moduleSelf.require(path)
       }
       require.resolve = function (request) {
-        return Module._resolveFilename(request, self)
+        return Module._resolveFilename(request, moduleSelf)
       }
       require.main = process.mainModule
 
@@ -54,18 +63,20 @@ class NativeCompileCache {
       // create wrapper function
       let wrapper = Module.wrap(content)
 
+      let cacheKey = filename
+      let invalidationKey = computeHash(wrapper + self.v8Version)
       let compiledWrapper = null
-      if (cacheStore.has(filename)) {
-        let buffer = cacheStore.get(filename)
+      if (self.cacheStore.has(cacheKey, invalidationKey)) {
+        let buffer = self.cacheStore.get(cacheKey, invalidationKey)
         let compilationResult = cachedVm.runInThisContextCached(wrapper, filename, buffer)
         compiledWrapper = compilationResult.result
         if (compilationResult.wasRejected) {
-          cacheStore.delete(filename)
+          self.cacheStore.delete(cacheKey)
         }
       } else {
         let compilationResult = cachedVm.runInThisContext(wrapper, filename)
         if (compilationResult.cacheBuffer) {
-          cacheStore.set(filename, compilationResult.cacheBuffer)
+          self.cacheStore.set(cacheKey, invalidationKey, compilationResult.cacheBuffer)
         }
         compiledWrapper = compilationResult.result
       }
@@ -88,8 +99,8 @@ class NativeCompileCache {
           global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0)
         }
       }
-      let args = [self.exports, require, self, filename, dirname, process, global]
-      return compiledWrapper.apply(self.exports, args)
+      let args = [moduleSelf.exports, require, moduleSelf, filename, dirname, process, global]
+      return compiledWrapper.apply(moduleSelf.exports, args)
     }
   }