Docserver: Serve docs out of src/ not src/chrome/common/extensions. This allows

chrome/common/extensions/docs/server2/cron_servlet.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 traceback
 
 from app_yaml_helper import AppYamlHelper
 from appengine_wrappers import (
     GetAppVersion, IsDeadlineExceededError, logservice)
 from branch_utility import BranchUtility
 from compiled_file_system import CompiledFileSystem
 from data_source_registry import CreateDataSources
 from empty_dir_file_system import EmptyDirFileSystem
 from environment import IsDevServer
+from extensions_paths import EXAMPLES, PUBLIC_TEMPLATES, SERVER2, STATIC_DOCS
 from file_system_util import CreateURLsFromPaths
 from future import Gettable, Future
 from github_file_system_provider import GithubFileSystemProvider
 from host_file_system_provider import HostFileSystemProvider
 from object_store_creator import ObjectStoreCreator
 from render_servlet import RenderServlet
 from server_instance import ServerInstance
 from servlet import Servlet, Request, Response
-import svn_constants
 from timer import Timer, TimerClosure
 
+
 class _SingletonRenderServletDelegate(RenderServlet.Delegate):
   def __init__(self, server_instance):
     self._server_instance = server_instance
 
   def CreateServerInstance(self):
     return self._server_instance
 
 class _CronLogger(object):
   '''Wraps the logging.* methods to prefix them with 'cron' and flush
   immediately. The flushing is important because often these cron runs time
@@ skipping 144 matching lines @@
       title = 'initializing %s parallel Cron targets' % len(targets)
       _cronlog.info(title)
       timer = Timer()
       try:
         cron_futures = [run_cron_for_future(target) for target in targets]
       finally:
         _cronlog.info('%s took %s' % (title, timer.Stop().FormatElapsed()))
 
       # Rendering the public templates will also pull in all of the private
       # templates.
-      results.append(request_files_in_dir(svn_constants.PUBLIC_TEMPLATE_PATH))
+      results.append(request_files_in_dir(PUBLIC_TEMPLATES))
 
       # Rendering the public templates will have pulled in the .js and
       # manifest.json files (for listing examples on the API reference pages),
       # but there are still images, CSS, etc.
-      results.append(request_files_in_dir(svn_constants.STATIC_PATH,
-                                          prefix='static/'))
+      results.append(request_files_in_dir(STATIC_DOCS, prefix='static'))
 
       # Samples are too expensive to run on the dev server, where there is no
       # parallel fetch.
       if not IsDevServer():
         # Fetch each individual sample file.
-        results.append(request_files_in_dir(svn_constants.EXAMPLES_PATH,
-                                            prefix='extensions/examples/'))
+        results.append(request_files_in_dir(EXAMPLES,
+                                            prefix='extensions/examples'))
 
         # Fetch the zip file of each example (contains all the individual
         # files).
         example_zips = []
-        for root, _, files in trunk_fs.Walk(svn_constants.EXAMPLES_PATH):
+        for root, _, files in trunk_fs.Walk(EXAMPLES):
           example_zips.extend(
               root + '.zip' for name in files if name == 'manifest.json')
         results.append(_RequestEachItem(
             'example zips',
             example_zips,
             lambda path: render('extensions/examples/' + path)))
 
       # Resolve the hand-written Cron method futures.
       title = 'resolving %s parallel Cron targets' % len(targets)
       _cronlog.info(title)
@@ skipping 25 matching lines @@
 
     # IMPORTANT: Get a ServerInstance pinned to the most recent revision, not
     # HEAD. These cron jobs take a while and run very frequently such that
     # there is usually one running at any given time, and eventually a file
     # that we're dealing with will change underneath it, putting the server in
     # an undefined state.
     server_instance_near_head = self._CreateServerInstance(
         self._GetMostRecentRevision())
 
     app_yaml_handler = AppYamlHelper(
-        svn_constants.APP_YAML_PATH,
         server_instance_near_head.object_store_creator,
         server_instance_near_head.host_file_system_provider)
 
     if app_yaml_handler.IsUpToDate(delegate.GetAppVersion()):
       return server_instance_near_head
 
     # The version in app.yaml is greater than the currently running app's.
     # The safe version is the one before it changed.
     safe_revision = app_yaml_handler.GetFirstRevisionGreaterThan(
         delegate.GetAppVersion()) - 1
 
     _cronlog.info('app version %s is out of date, safe is %s',
         delegate.GetAppVersion(), safe_revision)
 
     return self._CreateServerInstance(safe_revision)
 
   def _GetMostRecentRevision(self):
     '''Gets the revision of the most recent patch submitted to the host file
     system. This is similar to HEAD but it's a concrete revision so won't
     change as the cron runs.
     '''
     head_fs = (
         self._CreateServerInstance(None).host_file_system_provider.GetTrunk())
-    return head_fs.Stat('/').version
+    return head_fs.Stat('').version
 
   def _CreateServerInstance(self, revision):
     '''Creates a ServerInstance pinned to |revision|, or HEAD if None.
     NOTE: If passed None it's likely that during the cron run patches will be
     submitted at HEAD, which may change data underneath the cron run.
     '''
     object_store_creator = ObjectStoreCreator(start_empty=True)
     branch_utility = self._delegate.CreateBranchUtility(object_store_creator)
     host_file_system_provider = self._delegate.CreateHostFileSystemProvider(
         object_store_creator, max_trunk_revision=revision)
     github_file_system_provider = self._delegate.CreateGithubFileSystemProvider(
         object_store_creator)
     return ServerInstance(object_store_creator,
                           CompiledFileSystem.Factory(object_store_creator),
                           branch_utility,
                           host_file_system_provider,
                           github_file_system_provider)