add GCS support to docs server

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

 # Copyright 2013 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 logging
+import os
 import traceback
 
 from chroot_file_system import ChrootFileSystem
 from content_provider import ContentProvider
-from extensions_paths import CONTENT_PROVIDERS
+import environment
+from extensions_paths import CONTENT_PROVIDERS, LOCAL_DEBUG_DIR
 from future import Gettable, Future
+from local_file_system import LocalFileSystem
 from third_party.json_schema_compiler.memoize import memoize
 
 
 _IGNORE_MISSING_CONTENT_PROVIDERS = [False]
 
 
 def IgnoreMissingContentProviders(fn):
   '''Decorates |fn| to ignore missing content providers during its run.
   '''
   def run(*args, **optargs):
@@ skipping 10 matching lines @@
   '''Implements the content_providers.json configuration; see
   chrome/common/extensions/docs/templates/json/content_providers.json for its
   current state and a description of the format.
 
   Returns ContentProvider instances based on how they're configured there.
   '''
 
   def __init__(self,
                compiled_fs_factory,
                host_file_system,
-               github_file_system_provider):
+               github_file_system_provider,
+               gcs_file_system_provider):
     self._compiled_fs_factory = compiled_fs_factory
     self._host_file_system = host_file_system
     self._github_file_system_provider = github_file_system_provider
-    self._cache = compiled_fs_factory.ForJson(host_file_system)
+    self._gcs_file_system_provider = gcs_file_system_provider
+    self._cache = None
+
+    # If running the devserver and there is a LOCAL_DEBUG_DIR, we
+    # will read the content_provider configuration from there instead
+    # of fetching it from SVN trunk or patch.
+    if environment.IsDevServer() and os.path.exists(LOCAL_DEBUG_DIR):
+      local_fs = LocalFileSystem(LOCAL_DEBUG_DIR)
+      conf_stat = None
+      try:
+        conf_stat = local_fs.Stat(CONTENT_PROVIDERS)
+      except:
+        pass
+
+      if conf_stat:
+        logging.warn(("Using local debug folder (%s) for "
+                      "content_provider.json configuration") % LOCAL_DEBUG_DIR)
+        self._cache = compiled_fs_factory.ForJson(local_fs)
+
+    if not self._cache:
+      self._cache = compiled_fs_factory.ForJson(host_file_system)
 
   @memoize
   def GetByName(self, name):
     '''Gets the ContentProvider keyed by |name| in content_providers.json, or
     None of there is no such content provider.
     '''
     config = self._GetConfig().get(name)
     if config is None:
       logging.error('No content provider found with name "%s"' % name)
       return None
@@ skipping 30 matching lines @@
     supports_templates = config.get('supportsTemplates', False)
     supports_zip = config.get('supportsZip', False)
 
     if 'chromium' in config:
       chromium_config = config['chromium']
       if 'dir' not in chromium_config:
         logging.error('%s: "chromium" must have a "dir" property' % name)
         return None
       file_system = ChrootFileSystem(self._host_file_system,
                                      chromium_config['dir'])
+    elif 'gcs' in config:
+      gcs_config = config['gcs']
+      if 'bucket' not in gcs_config:
+        logging.error('%s: "gcs" must have a "bucket" property' % name)
+        return None
+      bucket = gcs_config['bucket']
+      if not bucket.startswith('gs://'):
+        logging.error('%s: bucket %s should start with gs://' % (name, bucket))
+        return None
+      bucket = bucket[len('gs://'):]
+      file_system = self._gcs_file_system_provider.Create(bucket)
+      if 'dir' in gcs_config:
+        file_system = ChrootFileSystem(file_system, gcs_config['dir'])
+
     elif 'github' in config:
       github_config = config['github']
       if 'owner' not in github_config or 'repo' not in github_config:
         logging.error('%s: "github" must provide an "owner" and "repo"' % name)
         return None
       file_system = self._github_file_system_provider.Create(
           github_config['owner'], github_config['repo'])
       if 'dir' in github_config:
         file_system = ChrootFileSystem(file_system, github_config['dir'])
+
     else:
-      logging.error(
-          '%s: content provider type "%s" not supported' % (name, type_))
+      logging.error('%s: content provider type not supported' % name)
       return None
 
     return ContentProvider(name,
                            self._compiled_fs_factory,
                            file_system,
                            supports_templates=supports_templates,
                            supports_zip=supports_zip)
 
   def Cron(self):
     def safe(name, action, callback):
       '''Safely runs |callback| for a ContentProvider called |name| by
       swallowing exceptions and turning them into a None return value. It's
       important to run all ContentProvider Crons even if some of them fail.
       '''
       try:
         return callback()
       except:
         if not _IGNORE_MISSING_CONTENT_PROVIDERS[0]:
           logging.error('Error %s Cron for ContentProvider "%s":\n%s' %
                         (action, name, traceback.format_exc()))
         return None
 
     futures = [(name, safe(name,
                            'initializing',
                            self._CreateContentProvider(name, config).Cron))
                for name, config in self._GetConfig().iteritems()]
     return Future(delegate=Gettable(
         lambda: [safe(name, 'resolving', f.Get) for name, f in futures if f]))