Devserver: only populate data during cron jobs, meaning all data from instances

chrome/common/extensions/docs/server2/appengine_wrappers.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.
 
 # This will attempt to import the actual App Engine modules, and if it fails,
 # they will be replaced with fake modules. This is useful during testing.
 try:
   import google.appengine.ext.blobstore as blobstore
   from google.appengine.ext.blobstore.blobstore import BlobReferenceProperty
   import google.appengine.ext.db as db
   import google.appengine.ext.webapp as webapp
   import google.appengine.api.files as files
   import google.appengine.api.memcache as memcache
   import google.appengine.api.urlfetch as urlfetch
-  # Default to a 5 minute cache timeout.
-  CACHE_TIMEOUT = 300
 except ImportError:
-  # Cache for one second because zero means cache forever.
-  CACHE_TIMEOUT = 1
   import re
   from StringIO import StringIO
 
   FAKE_URL_FETCHER_CONFIGURATION = None
 
   def ConfigureFakeUrlFetch(configuration):
     """|configuration| is a dictionary mapping strings to fake urlfetch classes.
     A fake urlfetch class just needs to have a fetch method. The keys of the
     dictionary are treated as regex, and they are matched with the URL to
     determine which fake urlfetch is used.
@@ skipping 93 matching lines @@
 
     def GetBlobKeys(self):
       return _BLOBS.keys()
 
     def finalize(self, filename):
       pass
 
   files = FakeFiles()
 
   class InMemoryMemcache(object):
-    """A fake memcache that does nothing.
+    """An in-memory memcache implementation.
     """
+    def __init__(self):
+      self._namespaces = {}
+
     class Client(object):
       def set_multi_async(self, mapping, namespace='', time=0):
-        return
+        for k, v in mapping.iteritems():
+          memcache.set(k, v, namespace=namespace, time=time)
 
       def get_multi_async(self, keys, namespace='', time=0):
-        return _RPC(result=dict((k, None) for k in keys))
+        return _RPC(result=dict(
+          (k, memcache.get(k, namespace=namespace, time=time)) for k in keys))
 
     def set(self, key, value, namespace='', time=0):
-      return
+      self._GetNamespace(namespace)[key] = value
 
     def get(self, key, namespace='', time=0):
-      return None
+      return self._GetNamespace(namespace).get(key)
 
-    def delete(self, key, namespace):
-      return
+    def delete(self, key, namespace=''):
+      del self._GetNamespace(namespace)[key]
+
+    def delete_multi(self, keys, namespace=''):
+      for k in keys:
+        self.delete(k, namespace=namespace)
+
+    def _GetNamespace(self, namespace):
+      if namespace not in self._namespaces:
+        self._namespaces[namespace] = {}
+      return self._namespaces[namespace]
 
   memcache = InMemoryMemcache()
 
   class webapp(object):
     class RequestHandler(object):
       """A fake webapp.RequestHandler class for Handler to extend.
       """
       def __init__(self, request, response):
         self.request = request
         self.response = response
@@ skipping 26 matching lines @@
 
       @staticmethod
       def gql(query, key):
         return _Db_Result(db._store.get(key, None))
 
       def put(self):
         db._store[self._key] = self._value
 
   class BlobReferenceProperty(object):
     pass