Dynamically generate a heading for Extension Docs API pages

chrome/common/extensions/docs/server2/handler.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 logging
 import os
 from StringIO import StringIO
 import sys
 
 from appengine_wrappers import webapp
 from appengine_wrappers import memcache
 from appengine_wrappers import urlfetch
 
 from api_data_source import APIDataSource
 from api_list_data_source import APIListDataSource
 from appengine_blobstore import AppEngineBlobstore
-from in_memory_object_store import InMemoryObjectStore
 from appengine_url_fetcher import AppEngineUrlFetcher
+from availability_data_source import AvailabilityDataSource
 from branch_utility import BranchUtility
-from example_zipper import ExampleZipper
+from chrome_version_data_source import ChromeVersionDataSource
 from compiled_file_system import CompiledFileSystem
 import compiled_file_system as compiled_fs
+from example_zipper import ExampleZipper
 from github_file_system import GithubFileSystem
+from in_memory_object_store import InMemoryObjectStore
 from intro_data_source import IntroDataSource
 from known_issues_data_source import KnownIssuesDataSource
 from local_file_system import LocalFileSystem
 from memcache_file_system import MemcacheFileSystem
 from reference_resolver import ReferenceResolver
 from samples_data_source import SamplesDataSource
 from server_instance import ServerInstance
 from sidenav_data_source import SidenavDataSource
 from subversion_file_system import SubversionFileSystem
 from template_data_source import TemplateDataSource
 from third_party.json_schema_compiler.model import UnixName
 import url_constants
 
 # Increment this version to force the server to reload all pages in the first
 # cron job that is run.
-_VERSION = 1
+_VERSION = 2
 
 # The default channel to serve docs for if no channel is specified.
 _DEFAULT_CHANNEL = 'stable'
 
 BRANCH_UTILITY_MEMCACHE = InMemoryObjectStore('branch_utility')
 BRANCH_UTILITY = BranchUtility(url_constants.OMAHA_PROXY_URL,
                                AppEngineUrlFetcher(None),
                                BRANCH_UTILITY_MEMCACHE)
 
+AVAILABILITY_DATA_SOURCE_MEMCACHE = InMemoryObjectStore(
+    'availability_data_source')
+
+
 GITHUB_MEMCACHE = InMemoryObjectStore('github')
 GITHUB_FILE_SYSTEM = GithubFileSystem(
     AppEngineUrlFetcher(url_constants.GITHUB_URL),
     GITHUB_MEMCACHE,
     AppEngineBlobstore())
 GITHUB_COMPILED_FILE_SYSTEM = CompiledFileSystem.Factory(GITHUB_FILE_SYSTEM,
                                                          GITHUB_MEMCACHE)
 
 EXTENSIONS_PATH = 'chrome/common/extensions'
 DOCS_PATH = 'docs'
@@ skipping 18 matching lines @@
   return [UnixName(os.path.splitext(f.split('/')[-1])[0]) for f in files]
 
 def _CreateMemcacheFileSystem(branch, branch_memcache):
   svn_url = _GetURLFromBranch(branch) + '/' + EXTENSIONS_PATH
   stat_fetcher = AppEngineUrlFetcher(
       svn_url.replace(url_constants.SVN_URL, url_constants.VIEWVC_URL))
   fetcher = AppEngineUrlFetcher(svn_url)
   return MemcacheFileSystem(SubversionFileSystem(fetcher, stat_fetcher),
                             branch_memcache)
 
-_default_branch = BRANCH_UTILITY.GetBranchNumberForChannelName(_DEFAULT_CHANNEL)
+def _CreateMemcacheForBranch(branch_number):

[epeterson, 2013/03/25 19:48:02]

  This is now a global method, which is passed to the global
chrome_version_data_source. 
  This method can't really be used for both _GetInstanceForBranch and in
chrome_version_data_source, as the former requires more objects that depend on
the ones generated here, and the latter doesn't need access to those extra
objects at all.

[cduvall, 2013/03/25 22:59:43]

Which objects does it depend on? Can you just pass them in as extra parameters
to this function?

+  """Passed to the global instance of chromeVersionDataSource. Allows for
+  the creation of api_data_sources linked to |branch_number|, which is the
+  maximum branch number from a given version of chrome.
+  """
+  branch_memcache = InMemoryObjectStore(branch_number)
+  file_system = _CreateMemcacheFileSystem(branch_number, branch_memcache)
+  cache_factory = CompiledFileSystem.Factory(file_system, branch_memcache)
+  api_list_data_source_factory = APIListDataSource.Factory(
+      cache_factory,
+      file_system,
+      API_PATH,
+      PUBLIC_TEMPLATE_PATH)
+  api_data_source_factory = APIDataSource.Factory(cache_factory, API_PATH)
+  ref_resolver_factory = ReferenceResolver.Factory(
+      api_data_source_factory,
+      api_list_data_source_factory,
+      branch_memcache)
+  api_data_source_factory.SetReferenceResolverFactory(ref_resolver_factory)
+  samples_data_source_factory = SamplesDataSource.Factory(
+      #channel_name,
+      'trunk',

[epeterson, 2013/03/25 19:48:02]

  This is really the only part that prevents this method from standing alone
from the _GetInstanceForbranch method.
  Previously, the channel_name was grabbed from the branch instance, but the
samples_data_source isn't really an integral part of finding availability.
  So I stuck 'trunk' in there. 

[cduvall, 2013/03/25 22:59:43]

Can you just pass the channel name in as a function parameter?

Also you can do something like:
lambda x: _CreateMemcacheForBranch(x, arg1, arg2,...)

if you don't want to have to supply all the extra args in
ChromeVersionDataSource

+      file_system,
+      GITHUB_FILE_SYSTEM,
+      cache_factory,
+      GITHUB_COMPILED_FILE_SYSTEM,
+      ref_resolver_factory,
+      EXAMPLES_PATH)
+  api_data_source_factory.SetSamplesDataSourceFactory(
+     samples_data_source_factory)
+  return api_data_source_factory.Create(None)
+
+_default_branch = BRANCH_UTILITY.GetChannelInfoForChannelName(
+    _DEFAULT_CHANNEL)['branch']
 APPS_MEMCACHE = InMemoryObjectStore(_default_branch)
 APPS_FILE_SYSTEM = _CreateMemcacheFileSystem(_default_branch, APPS_MEMCACHE)
 APPS_COMPILED_FILE_SYSTEM = CompiledFileSystem.Factory(
     APPS_FILE_SYSTEM,
     APPS_MEMCACHE).Create(_SplitFilenameUnix, compiled_fs.APPS_FS)
 
 EXTENSIONS_MEMCACHE = InMemoryObjectStore(_default_branch)
 EXTENSIONS_FILE_SYSTEM = _CreateMemcacheFileSystem(_default_branch,
                                                    EXTENSIONS_MEMCACHE)
 EXTENSIONS_COMPILED_FILE_SYSTEM = CompiledFileSystem.Factory(
     EXTENSIONS_FILE_SYSTEM,
     EXTENSIONS_MEMCACHE).Create(_SplitFilenameUnix, compiled_fs.EXTENSIONS_FS)
 
 KNOWN_ISSUES_DATA_SOURCE = KnownIssuesDataSource(
     InMemoryObjectStore('KnownIssues'),
     AppEngineUrlFetcher(None))
 
+CHROME_VERSION_DATA_SOURCE_MEMCACHE = InMemoryObjectStore(
+    'chrome_version_data_source')
+CHROME_VERSION_DATA_SOURCE = ChromeVersionDataSource(
+                               url_constants.OMAHA_BETA_HISTORY,
+                               AppEngineUrlFetcher(None),
+                               CHROME_VERSION_DATA_SOURCE_MEMCACHE,
+                               _CreateMemcacheForBranch)
+
 def _MakeInstanceKey(branch, number):
   return '%s/%s' % (branch, number)
 
 def _GetInstanceForBranch(channel_name, local_path):
-  branch = BRANCH_UTILITY.GetBranchNumberForChannelName(channel_name)
+  channel_info = BRANCH_UTILITY.GetChannelInfoForChannelName(
+      channel_name)
+  branch = channel_info['branch']
+  version = channel_info['version']
 
   # The key for the server is a tuple of |channel_name| with |branch|, since
   # sometimes stable and beta point to the same branch.
   instance_key = _MakeInstanceKey(channel_name, branch)
   instance = SERVER_INSTANCES.get(instance_key, None)
   if instance is not None:
     return instance
-
   branch_memcache = InMemoryObjectStore(branch)
   file_system = _CreateMemcacheFileSystem(branch, branch_memcache)
   cache_factory = CompiledFileSystem.Factory(file_system, branch_memcache)
   api_list_data_source_factory = APIListDataSource.Factory(cache_factory,
                                                            file_system,
                                                            API_PATH,
                                                            PUBLIC_TEMPLATE_PATH)
+  availability_data_source = AvailabilityDataSource(
+      CHROME_VERSION_DATA_SOURCE,
+      version,
+      AVAILABILITY_DATA_SOURCE_MEMCACHE)
   api_data_source_factory = APIDataSource.Factory(
       cache_factory,
-      API_PATH)
+      API_PATH,
+      availability_data_source)
 
   # Give the ReferenceResolver a memcache, to speed up the lookup of
   # duplicate $refs.
   ref_resolver_factory = ReferenceResolver.Factory(
       api_data_source_factory,
       api_list_data_source_factory,
       branch_memcache)
   api_data_source_factory.SetReferenceResolverFactory(ref_resolver_factory)
   samples_data_source_factory = SamplesDataSource.Factory(
       channel_name,
       file_system,
       GITHUB_FILE_SYSTEM,
       cache_factory,
       GITHUB_COMPILED_FILE_SYSTEM,
       ref_resolver_factory,
       EXAMPLES_PATH)
   api_data_source_factory.SetSamplesDataSourceFactory(
       samples_data_source_factory)
   intro_data_source_factory = IntroDataSource.Factory(
       cache_factory,
       ref_resolver_factory,
       [INTRO_PATH, ARTICLE_PATH])
   sidenav_data_source_factory = SidenavDataSource.Factory(cache_factory,
-                                                          JSON_PATH)
+                                                            JSON_PATH)

[cduvall, 2013/03/25 22:59:43]

revert

[epeterson, 2013/03/27 22:36:09]

Done, in the new global method.

   template_data_source_factory = TemplateDataSource.Factory(
       channel_name,
       api_data_source_factory,
       api_list_data_source_factory,
       intro_data_source_factory,
       samples_data_source_factory,
       KNOWN_ISSUES_DATA_SOURCE,
       sidenav_data_source_factory,
       cache_factory,
       ref_resolver_factory,
       PUBLIC_TEMPLATE_PATH,
-      PRIVATE_TEMPLATE_PATH)
+      PRIVATE_TEMPLATE_PATH,
+      BRANCH_UTILITY.GetChannelInfoForAllChannels())
   example_zipper = ExampleZipper(file_system,
                                  cache_factory,
                                  DOCS_PATH)
-
   instance = ServerInstance(template_data_source_factory,
                             example_zipper,
                             cache_factory)
   SERVER_INSTANCES[instance_key] = instance
   return instance
 
 def _CleanBranches():
   keys = [_MakeInstanceKey(branch, number)
           for branch, number in BRANCH_UTILITY.GetAllBranchNumbers()]
   for key in SERVER_INSTANCES.keys():
@@ skipping 41 matching lines @@
 
     _CleanBranches()
 
     # Yes, do this after it's passed to RedirectBadPaths. That needs to know
     # whether or not a branch was specified.
     if channel_name is None:
       channel_name = _DEFAULT_CHANNEL
     _GetInstanceForBranch(channel_name, self._local_path).Get(real_path,
                                                               self.request,
                                                               self.response)
-
   def _Render(self, files, channel):
     original_response = self.response
     for f in files:
       if f.endswith('404.html'):
         continue
       path = channel + f.split(PUBLIC_TEMPLATE_PATH)[-1]
       self.request = _MockRequest(path)
       self.response = _MockResponse()
       try:
         self._HandleGet(path)
@@ skipping 19 matching lines @@
     # We could list all files in PUBLIC_TEMPLATE_PATH then render them. However,
     # this would be inefficient in the common case where files haven't changed
     # since the last cron.
     #
     # Instead, let the CompiledFileSystem give us clues when to re-render: we
     # use the CFS to check whether the templates, examples, or API folders have
     # been changed. If there has been a change, the compilation function will
     # be called. The same is then done separately with the apps samples page,
     # since it pulls its data from Github.
     channel = path.split('/')[-1]
-    branch = BRANCH_UTILITY.GetBranchNumberForChannelName(channel)
+    branch = BRANCH_UTILITY.GetChannelInfoForChannelName(channel)['branch']
     logging.info('Running cron job for %s.' % branch)
     branch_memcache = InMemoryObjectStore(branch)
     file_system = _CreateMemcacheFileSystem(branch, branch_memcache)
     factory = CompiledFileSystem.Factory(file_system, branch_memcache)
 
     needs_render = self._ValueHolder(False)
     invalidation_cache = factory.Create(lambda _, __: needs_render.Set(True),
                                         compiled_fs.CRON_INVALIDATION,
                                         version=_VERSION)
     for path in [TEMPLATE_PATH, EXAMPLES_PATH, API_PATH]:
@@ skipping 87 matching lines @@
 
     # Redirect paths like "directory" to "directory/". This is so relative
     # file paths will know to treat this as a directory.
     if os.path.splitext(path)[1] == '' and path[-1] != '/':
       self.redirect(path + '/')
       return
 
     path = path.strip('/')
     if not self._RedirectFromCodeDotGoogleDotCom(path):
       self._HandleGet(path)