Docserver: Persist stat cache for versioned file systems

chrome/common/extensions/docs/server2/appengine_url_fetcher.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 base64
 import logging
 import posixpath
 import time
 
 from appengine_wrappers import urlfetch
@@ skipping 24 matching lines @@
   """
   def __init__(self, base_path=None):
     assert base_path is None or not base_path.endswith('/'), base_path
     self._base_path = base_path
     self._retries_left = _MAX_RETRIES
 
   def Fetch(self, url, username=None, password=None, access_token=None):
     """Fetches a file synchronously.
     """
     return urlfetch.fetch(self._FromBasePath(url),
-                          deadline=20,
+                          deadline=40,

[not at google - send to devlin, 2014/10/20 21:06:57]

Do we know this is failing?

[Ken Rockot(use gerrit already), 2014/10/22 03:19:54]

Yes. I was seeing timeouts occurring at the 20 second mark. I don't know how
consistent it is, but really I also don't see any harm in letting tasks block
for a while on requests.

Alternatively we can turn this way down and let tasks fail when remote services
are unresponsive. This frees up the task queue for other stuff.

If the gitiles delays are really sporadic per request, that might make sense.
Otherwise it would probably just cause the queue to churn a lot.

[not at google - send to devlin, 2014/10/22 16:51:57]

I have a TODO somewhere to retry failed fetches, but obviously I never
implemented it. The deadline parameter should really be passed into Fetch but
20s always seemed like a safe. I think having it "low" like this might have
occasionally failed on the subversion fs as well.

Anyway - happy to increase this, though it'd be nice get some metrics on how
long these fetches take. Like, 90% complete in under 5s, 10% under 10s, etc etc.

                           headers=_MakeHeaders(username,
                                                password,
                                                access_token))
 
   def FetchAsync(self, url, username=None, password=None, access_token=None):
     """Fetches a file asynchronously, and returns a Future with the result.
     """
     def process_result(result):
       if result.status_code == 429:
         if self._retries_left == 0:
           logging.error('Still throttled. Giving up.')
           return result
         self._retries_left -= 1
         logging.info('Throttled. Trying again in %s seconds.' %
                      _RETRY_DELAY_SECONDS)
         time.sleep(_RETRY_DELAY_SECONDS)
         return self.FetchAsync(url, username, password, access_token).Get()
       return result
 
-    rpc = urlfetch.create_rpc(deadline=20)
+    rpc = urlfetch.create_rpc(deadline=40)
     urlfetch.make_fetch_call(rpc,
                              self._FromBasePath(url),
                              headers=_MakeHeaders(username,
                                                   password,
                                                   access_token))
     return Future(callback=lambda: process_result(rpc.get_result()))
 
   def _FromBasePath(self, url):
     assert not url.startswith('/'), url
     if self._base_path is not None:
       url = posixpath.join(self._base_path, url) if url else self._base_path
     return url