Extensions Docs Server: Fix samples page and ExampleZipper

chrome/common/extensions/docs/server2/memcache_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
 import object_store
 
 class _AsyncUncachedFuture(object):
-  def __init__(self, uncached, current_result, file_system, object_store):
+  def __init__(self,
+               uncached,
+               current_result,
+               file_system,
+               object_store,
+               namespace):
     self._uncached = uncached
     self._current_result = current_result
     self._file_system = file_system
     self._object_store = object_store
+    self._namespace = namespace
 
   def Get(self):
     mapping = {}
     new_items = self._uncached.Get()
     for item in new_items:
       version = self._file_system.Stat(item).version
       mapping[item] = (new_items[item], version)
       self._current_result[item] = new_items[item]
-    self._object_store.SetMulti(mapping, object_store.FILE_SYSTEM_READ, time=0)
+    self._object_store.SetMulti(mapping, self._namespace, time=0)
     return self._current_result
 
 class MemcacheFileSystem(FileSystem):
   """FileSystem implementation which memcaches the results of Read.
   """
   def __init__(self, file_system, object_store):
     self._file_system = file_system
     self._object_store = object_store
 
   def Stat(self, path, stats=None):
@@ skipping 26 matching lines @@
       mapping[child_path] = child_version
     self._object_store.SetMulti(mapping, object_store.FILE_SYSTEM_STAT)
     return StatInfo(version)
 
   def Read(self, paths, binary=False):
     """Reads a list of files. If a file is in memcache and it is not out of
     date, it is returned. Otherwise, the file is retrieved from the file system.
     """
     result = {}
     uncached = []
-    results = self._object_store.GetMulti(paths,
-                                          object_store.FILE_SYSTEM_READ,
-                                          time=0).Get()
+    namespace = object_store.FILE_SYSTEM_READ
+    if binary:
+      namespace = '%s.binary' % namespace

[not at google - send to devlin, 2012/08/27 04:31:48]

is this actually a problem? do we ever read the same path sometimes in binary
and sometimes not? That seems very strange.

[cduvall, 2012/08/27 18:04:34]

Yeah we do, this is why I was getting an error when I tried to download some of
the samples zips. The JSON files for the samples are cached as unicode (because
they are read with binary=False in samples_data_source), and then they are read
with binary=True for the example_zipper. The example_zipper was giving unicode
errors because of this.

[not at google - send to devlin, 2012/08/28 01:39:09]

Ok. I would prefer to see a solution which just cached things in binary then
converted to non-binary as needed, but it's a yak that isn't worth shaving yet.

+    results = self._object_store.GetMulti(paths, namespace, time=0).Get()
     result_values = [x[1] for x in sorted(results.iteritems())]
     stats = self._object_store.GetMulti(paths,
                                         object_store.FILE_SYSTEM_STAT).Get()
     stat_values = [x[1] for x in sorted(stats.iteritems())]
     for path, cached_result, stat in zip(sorted(paths),
                                          result_values,
                                          stat_values):
       if cached_result is None:
         uncached.append(path)
         continue
       data, version = cached_result
       # TODO(cduvall): Make this use a multi stat.
       if stat is None:
         stat = self.Stat(path).version
       if stat != version:
-        self._object_store.Delete(path, object_store.FILE_SYSTEM_READ)
+        self._object_store.Delete(path, namespace)

[not at google - send to devlin, 2012/08/27 04:31:48]

Is it necessary to delete this? It will be overridden later anyway, and it seems
safer to just leave the old data in there until it gets overridden.

Also it's much fewer operations; we SetMulti in the future, but we're deleting
individually here.

[cduvall, 2012/08/27 18:04:34]

Done.

         uncached.append(path)
         continue
       result[path] = data
 
     if not uncached:
       return Future(value=result)
     return Future(delegate=_AsyncUncachedFuture(
         self._file_system.Read(uncached, binary=binary),
         result,
         self,
-        self._object_store))
+        self._object_store,
+        namespace))