Extract CacheStorage and renames.

pkg/analyzer/lib/src/summary/incremental_cache.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:convert' show UTF8;
 import 'dart:core' hide Resource;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:crypto/crypto.dart';
 
 /**
- * The cache of per-library [PackageBundle]s.
- *
- * Note that currently this class is not intended for interactive use.
+ * Storage for cache data.
  */
-class LibraryBundleCache {
+abstract class CacheStorage {
+  /**
+   * Return bytes for the given [key], `null` if [key] is not in the storage.
+   */
+  List<int> get(String key);
+
+  /**
+   * Associate the [key] with the given [bytes].
+   *
+   * If the [key] was already in the storage, its associated value is changed.
+   * Otherwise the key-value pair is added to the storage.
+   *
+   * This method does not guarantee that data will always be accessible using
+   * [get], in some implementations association may silently fail or become
+   * inaccessible after some time.
+   */
+  void put(String key, List<int> bytes);
+}
+
+/**
+ * A [Folder] based implementation of [CacheStorage].
+ */
+class FolderCacheStorage implements CacheStorage {
+  /**
+   * The folder to read and write files.
+   */
+  final Folder folder;
+
   /**
    * To ensure that operations of writing files are atomic we create a temporary
-   * file with this name in the [cacheFolder] and then rename it once we are
+   * file with this name in the [folder] and then rename it once we are
    * done writing.
    */
   final String tempFileName;
 
+  FolderCacheStorage(this.folder, this.tempFileName);
+
+  @override
+  List<int> get(String key) {
+    Resource file = folder.getChild(key);
+    if (file is File) {
+      try {
+        return file.readAsBytesSync();
+      } on FileSystemException {}
+    }
+    return null;
+  }
+
+  @override
+  void put(String key, List<int> bytes) {
+    try {

[Paul Berry, 2016/03/18 20:22:42]

The try/catch should only surround the call to renameSync.  Otherwise a failure
to write the tempFile would be silently ignored.

+      String absPath = folder.getChild(key).path;
+      File tempFile = folder.getChild(tempFileName);
+      tempFile.writeAsBytesSync(bytes);
+      tempFile.renameSync(absPath);
+    } catch (e) {}
+  }
+}
+
+/**
+ * Cache of information to support incremental analysis.
+ *
+ * Note that currently this class is not intended for interactive use.
+ */
+class IncrementalCache {
   /**
-   * The folder to read and write files.
+   * The storage for the cache data.
    */
-  final Folder cacheFolder;
+  final CacheStorage storage;
 
   /**
    * The context in which this cache is used.
    */
   final AnalysisContext context;
 
   /**
    * Opaque data that reflects the current configuration, such as the [context]
    * options, and is mixed into the hashes.
    */
   final List<int> configSalt;
 
   final Map<Source, CacheSourceContent> _sourceContentMap =
       <Source, CacheSourceContent>{};
   final Map<Source, List<Source>> _libraryClosureMap = <Source, List<Source>>{};
   final Map<Source, List<int>> _sourceContentHashMap = <Source, List<int>>{};
 
-  LibraryBundleCache(
-      this.tempFileName, this.cacheFolder, this.context, this.configSalt);
+  IncrementalCache(this.storage, this.context, this.configSalt);
 
   /**
    * Clear internal caches so that we read from file system again.
    */
   void clearInternalCaches() {
     _sourceContentMap.clear();
     _libraryClosureMap.clear();
     _sourceContentHashMap.clear();
   }
 
@@ skipping 19 matching lines @@
    * Write information about the [library] into the cache.
    */
   void putLibrary(LibraryElement library) {
     try {
       _writeCacheSourceContents(library);
       List<int> hash = _getLibraryClosureHash(library.source);
       String hashStr = CryptoUtils.bytesToHex(hash);
       PackageBundleAssembler assembler = new PackageBundleAssembler();
       assembler.serializeLibraryElement(library);
       List<int> bytes = assembler.assemble().toBuffer();
-      _safeWriteBytes('$hashStr.sum', bytes);
+      storage.put('$hashStr.sum', bytes);
     } catch (e) {}
   }
 
   /**
    * Read the [PackageBundle] for the library with the given [source] from
    * the cache. The returned bundle will correspond to the state when the set
    * of direct and indirect dependencies is resolved in the [context]. Return
    * `null` if such bundle does not exist.
    */
   PackageBundle readBundle(Source source) {
     try {
       List<int> hash = _getLibraryClosureHash(source);
       String hashStr = CryptoUtils.bytesToHex(hash);
-      List<int> bytes = _safeReadBytes('$hashStr.sum');
+      List<int> bytes = storage.get('$hashStr.sum');
       if (bytes == null) {
         return null;
       }
       return new PackageBundle.fromBuffer(bytes);
     } catch (e) {
       return null;
     }
   }
 
   /**
@@ skipping 30 matching lines @@
     }
   }
 
   /**
    * Get the content based information about the given [source], maybe `null`
    * if the information is not in the cache.
    */
   CacheSourceContent _getCacheSourceContent(Source source) {
     CacheSourceContent content = _sourceContentMap[source];
     if (content == null) {
-      String fileName = _getCacheSourceContentFileName(source);
-      List<int> bytes = _safeReadBytes(fileName);
+      String key = _getCacheSourceContentKey(source);
+      List<int> bytes = storage.get(key);
       if (bytes == null) {
         return null;
       }
       content = new CacheSourceContent.fromBuffer(bytes);
       _sourceContentMap[source] = content;
     }
     return content;
   }
 
   /**
-   * Return the name of the file with the content based [source] information.
+   * Return the key of the content based [source] information.
    */
-  String _getCacheSourceContentFileName(Source source) {
+  String _getCacheSourceContentKey(Source source) {
     List<int> hash = _getSourceContentHash(source);
     String hashStr = CryptoUtils.bytesToHex(hash);
     return '$hashStr.content';
   }
 
   /**
    * Return the whole source closure of the library with the given
    * [librarySource]. It includes defining units and parts of the library and
    * of all its directly or indirectly imported or exported libraries.
    */
@@ skipping 25 matching lines @@
    */
   List<int> _getSourceContentHash(Source source) {
     return _sourceContentHashMap.putIfAbsent(source, () {
       String sourceText = source.contents.data;
       List<int> sourceBytes = UTF8.encode(sourceText);
       return (new MD5()..add(sourceBytes)).close();
     });
   }
 
   /**
-   * Return bytes of the file with the given [relPath] in the cache, or `null`
-   * if the file does not exist.
-   */
-  List<int> _safeReadBytes(String relPath) {
-    Resource file = cacheFolder.getChild(relPath);
-    if (file is File) {
-      try {
-        return file.readAsBytesSync();
-      } on FileSystemException {}
-    }
-    return null;
-  }
-
-  /**
-   * Atomically write the given [bytes] into the file with the given [relPath].
-   * Silently ignores any errors.
-   */
-  void _safeWriteBytes(String relPath, List<int> bytes) {
-    try {
-      String absPath = cacheFolder.getChild(relPath).path;
-      File tempFile = cacheFolder.getChild(tempFileName);
-      tempFile.writeAsBytesSync(bytes);
-      tempFile.renameSync(absPath);
-    } catch (e) {}
-  }
-
-  /**
    * Write the content based information about the given [source].
    */
   void _writeCacheSourceContent(Source source, CacheSourceContentBuilder b) {
-    String fileName = _getCacheSourceContentFileName(source);
+    String key = _getCacheSourceContentKey(source);
     List<int> bytes = b.toBuffer();
-    _safeWriteBytes(fileName, bytes);
+    storage.put(key, bytes);
     // Put into the cache to avoid reading it later.
     _sourceContentMap[source] = new CacheSourceContent.fromBuffer(bytes);
   }
 
   /**
    * Write [CacheSourceContent] for every unit of the given [library] and its
    * direct and indirect imports/exports.
    */
   void _writeCacheSourceContents(LibraryElement library,
       [Set<LibraryElement> writtenLibraries]) {
@@ skipping 38 matching lines @@
     // Write the library.
     _writeCacheSourceContent(
         librarySource,
         new CacheSourceContentBuilder(
             kind: CacheSourceKind.library,
             importedUris: importUris,
             exportedUris: exportUris,
             partUris: partUris));
   }
 }