Docserver: refactor Servlet, ObjectStore, and ServerInstance architecture to

chrome/common/extensions/docs/server2/caching_file_system.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from file_system import FileSystem, StatInfo, FileNotFoundError
 from future import Future
+from object_store_creator import ObjectStoreCreator
 
 class _AsyncUncachedFuture(object):
   def __init__(self,
                uncached_read_futures,
                stats_for_uncached,
                current_results,
                file_system,
                object_store):
     self._uncached_read_futures = uncached_read_futures
     self._stats_for_uncached = stats_for_uncached
     self._current_results = current_results
     self._file_system = file_system
     self._object_store = object_store
 
   def Get(self):
     new_results = self._uncached_read_futures.Get()
     # Update the cached data in the object store. This is a path -> (read,
     # version) mapping.
     self._object_store.SetMulti(dict(
         (path, (new_result, self._stats_for_uncached[path].version))
         for path, new_result in new_results.iteritems()))
     new_results.update(self._current_results)
     return new_results
 
 class CachingFileSystem(FileSystem):
   '''FileSystem which implements a caching layer on top of |file_system|. It's
   smart, using Stat() to decided whether to skip Read()ing from |file_system|,
   and only Stat()ing directories never files.
-
-  Specify |use_existing_values| to continue using whatever has been cached in
-  the object stores. By default, the data in the stores is assumed to be stale
-  (althought consistent). Using existing values is useful for live instances
-  that don't want to touch the file system; not using them is good for the
-  cron jobs, where we want to refresh the data.
   '''
-  def __init__(self,
-               file_system,
-               object_store_creator_factory,
-               use_existing_values=False):
+  def __init__(self, file_system, object_store_creator):
     self._file_system = file_system
-    def create_object_store(category):
-      return (object_store_creator_factory.Create(CachingFileSystem)
-          .Create(category='%s/%s' % (file_system.GetName(), category),
-                  # By Stat()ing from scratch we'll end up not using the
-                  # existing values, but also not doing unnecessary Read()s if
-                  # the files haven't changed from last time.
-                  start_empty=(not use_existing_values and category == 'stat')))
+    def create_object_store(category, **optargs):
+      return object_store_creator.Create(
+          CachingFileSystem,
+          category='%s/%s' % (file_system.GetIdentity(), category),
+          **optargs)
     self._stat_object_store = create_object_store('stat')
-    self._read_object_store = create_object_store('read')
-    self._read_binary_object_store = create_object_store('read-binary')
+    # Force the read stores to start populated, even if |object_store_creator|
+    # is configured to start empty, because the result from Stat entirely
+    # determines how we end up (re)Read-ing data. This is a core optimisation.
+    self._read_object_store = create_object_store(
+        'read', start_empty=False)
+    self._read_binary_object_store = create_object_store(
+        'read-binary', start_empty=False)
 
   def Stat(self, path):
     '''Stats the directory given, or if a file is given, stats the file's parent
     directory to get info about the file.
     '''
     # Always stat the parent directory, since it will have the stat of the child
     # anyway, and this gives us an entire directory's stat info at once.
     if path.endswith('/'):
       dir_path = path
     else:
@@ skipping 44 matching lines @@
 
     if not uncached:
       return Future(value=results)
 
     return Future(delegate=_AsyncUncachedFuture(
         self._file_system.Read(uncached.keys(), binary=binary),
         uncached,
         results,
         self,
         read_object_store))