Docserver: Use GitilesFileSystem instead of SubversionFileSystem

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 posixpath
 import traceback
 
 from app_yaml_helper import AppYamlHelper
 from appengine_wrappers import IsDeadlineExceededError, logservice
@@ skipping 78 matching lines @@
     self._delegate = delegate_for_test or CronServlet.Delegate()
 
   class Delegate(object):
     '''CronServlet's runtime dependencies. Override for testing.
     '''
     def CreateBranchUtility(self, object_store_creator):
       return BranchUtility.Create(object_store_creator)
 
     def CreateHostFileSystemProvider(self,
                                      object_store_creator,
-                                     max_trunk_revision=None):
+                                     pinned_commit=None):
       return HostFileSystemProvider(object_store_creator,
-                                    max_trunk_revision=max_trunk_revision)
+                                    pinned_commit=pinned_commit)
 
     def CreateGithubFileSystemProvider(self, object_store_creator):
       return GithubFileSystemProvider(object_store_creator)
 
     def CreateGCSFileSystemProvider(self, object_store_creator):
       return CloudStorageFileSystemProvider(object_store_creator)
 
     def GetAppVersion(self):
       return GetAppVersion()
 
@@ skipping 21 matching lines @@
     # little wasteful, but hopefully rendering is really fast (if it isn't we
     # have a problem).
     _cronlog.info('starting')
 
     # This is returned every time RenderServlet wants to create a new
     # ServerInstance.
     #
     # TODO(kalman): IMPORTANT. This sometimes throws an exception, breaking
     # everything. Need retry logic at the fetcher level.
     server_instance = self._GetSafeServerInstance()
-    trunk_fs = server_instance.host_file_system_provider.GetTrunk()
+    master_fs = server_instance.host_file_system_provider.GetMaster()
 
     def render(path):
       request = Request(path, self._request.host, self._request.headers)
       delegate = _SingletonRenderServletDelegate(server_instance)
       return RenderServlet(request, delegate).Get()
 
     def request_files_in_dir(path, prefix='', strip_ext=None):
       '''Requests every file found under |path| in this host file system, with
       a request prefix of |prefix|. |strip_ext| is an optional list of file
       extensions that should be stripped from paths before requesting.
       '''
       def maybe_strip_ext(name):
         if name == SITE_VERIFICATION_FILE or not strip_ext:
           return name
         base, ext = posixpath.splitext(name)
         return base if ext in strip_ext else name
       files = [maybe_strip_ext(name)
-               for name, _ in CreateURLsFromPaths(trunk_fs, path, prefix)]
+               for name, _ in CreateURLsFromPaths(master_fs, path, prefix)]
       return _RequestEachItem(path, files, render)
 
     results = []
 
     try:
       # Start running the hand-written Cron methods first; they can be run in
       # parallel. They are resolved at the end.
       def run_cron_for_future(target):
         title = target.__class__.__name__
         future, init_timer = TimerClosure(target.Cron)
@@ skipping 54 matching lines @@
       # conservative error checking), so re-raise no matter what it is.
       _cronlog.error('uncaught error: %s' % traceback.format_exc())
       raise
     finally:
       success = all(results)
       _cronlog.info('finished (%s)', 'success' if success else 'FAILED')
       return (Response.Ok('Success') if success else
               Response.InternalError('Failure'))
 
   def _GetSafeServerInstance(self):
-    '''Returns a ServerInstance with a host file system at a safe revision,
-    meaning the last revision that the current running version of the server
+    '''Returns a ServerInstance with a host file system at a safe commit,
+    meaning the last commit that the current running version of the server
     existed.
     '''
     delegate = self._delegate
 
-    # IMPORTANT: Get a ServerInstance pinned to the most recent revision, not
+    # IMPORTANT: Get a ServerInstance pinned to the most recent commit, 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())
+        self._GetMostRecentCommit())
 
     app_yaml_handler = AppYamlHelper(
         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
+  def _GetMostRecentCommit(self):
+    '''Gets the commit of the most recent patch submitted to the host file
+    system. This is similar to HEAD but it's a concrete commit so won't
     change as the cron runs.
     '''
     head_fs = (
-        self._CreateServerInstance(None).host_file_system_provider.GetTrunk())
-    return head_fs.Stat('').version
+        self._CreateServerInstance(None).host_file_system_provider.GetMaster())
+    return head_fs.GetCommitID().Get()
 
-  def _CreateServerInstance(self, revision):
-    '''Creates a ServerInstance pinned to |revision|, or HEAD if None.
+  def _CreateServerInstance(self, commit):
+    '''Creates a ServerInstance pinned to |commit|, 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)
+        object_store_creator, pinned_commit=commit)
     github_file_system_provider = self._delegate.CreateGithubFileSystemProvider(
         object_store_creator)
     gcs_file_system_provider = self._delegate.CreateGCSFileSystemProvider(
         object_store_creator)
     return ServerInstance(object_store_creator,
                           CompiledFileSystem.Factory(object_store_creator),
                           branch_utility,
                           host_file_system_provider,
                           github_file_system_provider,
                           gcs_file_system_provider)