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.
 
+import os
+
+def IsDevServer():
+  return os.environ.get('SERVER_SOFTWARE', '').find('Development') == 0
+
 # 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 11 matching lines @@
         return v
     return None
 
   class _RPC(object):
     def __init__(self, result=None):
       self.result = result
 
     def get_result(self):
       return self.result
 
+    def wait(self):
+      pass
+
   class FakeUrlFetch(object):
     """A fake urlfetch module that uses the current
     |FAKE_URL_FETCHER_CONFIGURATION| to map urls to fake fetchers.
     """
     class DownloadError(Exception):
       pass
 
     class _Response(object):
       def __init__(self, content):
         self.content = content
@@ skipping 62 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=''):
+      self._GetNamespace(namespace).pop(key, None)
+
+    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
         self.response.status = 200
 
       def redirect(self, path, permanent=False):
         self.response.status = 301 if permanent else 302
         self.response.headers['Location'] = path
 
   class _Db_Result(object):
     def __init__(self, data):
       self._data = data
 
     class _Result(object):
       def __init__(self, value):
         self.value = value
 
     def get(self):
       return self._Result(self._data)
 
   class db(object):
     _store = {}
+
     class StringProperty(object):
       pass
 
+    class BlobProperty(object):
+      pass
+
+    class Key(object):
+      def __init__(self, key):
+        self._key = key
+
+      @staticmethod
+      def from_path(model_name, path):
+        return db.Key('%s/%s' % (model_name, path))
+
+      def __eq__(self, obj):
+        return self.__class__ == obj.__class__ and self._key == obj._key
+
+      def __hash__(self):
+        return hash(self._key)
+
+      def __str__(self):
+        return str(self._key)
+
     class Model(object):
-      def __init__(self, key_='', value=''):
-        self._key = key_
-        self._value = value
+      key = None
+
+      def __init__(self, **optargs):
+        cls = self.__class__
+        for k, v in optargs.iteritems():
+          assert hasattr(cls, k), '%s does not define property %s' % (
+              cls.__name__, k)
+          setattr(self, k, v)
 
       @staticmethod
       def gql(query, key):
-        return _Db_Result(db._store.get(key, None))
+        return _Db_Result(db._store.get(key))
 
       def put(self):
-        db._store[self._key] = self._value
+        db._store[self.key_] = self.value
+
+    @staticmethod
+    def get_async(key):
+      return _RPC(result=db._store.get(key))
+
+    @staticmethod
+    def delete_async(key):
+      db._store.pop(key, None)
+      return _RPC()
+
+    @staticmethod
+    def put_async(value):
+      db._store[value.key] = value
+      return _RPC()
 
   class BlobReferenceProperty(object):
     pass