Docserver: Pull knowledge of host file systems into a single

chrome/common/extensions/docs/server2/patch_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.
 
 from fnmatch import fnmatch
 import logging
 from urlparse import urlparse
 
 from appengine_url_fetcher import AppEngineUrlFetcher
 from appengine_wrappers import IsDevServer
 from caching_file_system import CachingFileSystem
 from caching_rietveld_patcher import CachingRietveldPatcher
 from chained_compiled_file_system import ChainedCompiledFileSystem
 from compiled_file_system import  CompiledFileSystem
-from host_file_system_creator import HostFileSystemCreator
+from host_file_system_provider import HostFileSystemProvider
 from instance_servlet import InstanceServlet
 from render_servlet import RenderServlet
 from rietveld_patcher import RietveldPatcher, RietveldPatcherError
 from object_store_creator import ObjectStoreCreator
 from patched_file_system import PatchedFileSystem
 from server_instance import ServerInstance
 from servlet import Request, Response, Servlet
 import svn_constants
 import url_constants
 
 class _PatchServletDelegate(RenderServlet.Delegate):
   def __init__(self, issue, delegate):
     self._issue = issue
     self._delegate = delegate
 
   def CreateServerInstance(self):
+    # start_empty=False because a patch can rely on files that are already in
+    # SVN repository but not yet pulled into data store by cron jobs (a typical
+    # example is to add documentation for an existing API).
     object_store_creator = ObjectStoreCreator(start_empty=False)
-    branch_utility = self._delegate.CreateBranchUtility(object_store_creator)
-    host_file_system_creator = self._delegate.CreateHostFileSystemCreator(
+
+    unpatched_host_file_system_provider = (
+        self._delegate.CreateHostFileSystemProvider(object_store_creator))
+    unpatched_trunk_host_file_system = (
+        unpatched_host_file_system_provider.GetTrunk())
+    unpatched_compiled_fs_factory = CompiledFileSystem.Factory(
+        unpatched_trunk_host_file_system,
         object_store_creator)
-    # offline=False because a patch can rely on files that are already in SVN
-    # repository but not yet pulled into data store by cron jobs (a typical
-    # example is to add documentation for an existing API).
-    base_file_system = CachingFileSystem(
-        host_file_system_creator.Create(offline=False),
-        object_store_creator)
-    base_compiled_fs_factory = CompiledFileSystem.Factory(base_file_system,
-                                                          object_store_creator)
 
     rietveld_patcher = CachingRietveldPatcher(
         RietveldPatcher(svn_constants.EXTENSIONS_PATH,
                         self._issue,
                         AppEngineUrlFetcher(url_constants.CODEREVIEW_SERVER)),
         object_store_creator)
-    patched_file_system = PatchedFileSystem(base_file_system,
+
+    patched_file_system = PatchedFileSystem(unpatched_trunk_host_file_system,
                                             rietveld_patcher)
+    patched_host_file_system_provider = (
+        self._delegate.CreateHostFileSystemProvider(
+            object_store_creator,
+            # The patched file system needs to be online otherwise it'd be
+            # impossible to add files in the patches.
+            offline=False,
+            # The trunk file system for this creator should be the patched one.
+            default_trunk_instance=patched_file_system))
     patched_compiled_fs_factory = CompiledFileSystem.Factory(
-        patched_file_system, object_store_creator)
+        patched_file_system,
+        object_store_creator)
 
-    compiled_fs_factory = ChainedCompiledFileSystem.Factory(
+    combined_compiled_fs_factory = ChainedCompiledFileSystem.Factory(
         [(patched_compiled_fs_factory, patched_file_system),
-         (base_compiled_fs_factory, base_file_system)])
+         (unpatched_compiled_fs_factory, unpatched_trunk_host_file_system)])
+
+    branch_utility = self._delegate.CreateBranchUtility(object_store_creator)
 
     return ServerInstance(object_store_creator,
-                          patched_file_system,
                           self._delegate.CreateAppSamplesFileSystem(
                               object_store_creator),
-                          compiled_fs_factory,
+                          combined_compiled_fs_factory,
                           branch_utility,
-                          host_file_system_creator,
+                          patched_host_file_system_provider,
                           base_path='/_patch/%s/' % self._issue)
 
 class PatchServlet(Servlet):
   '''Servlet which renders patched docs.
   '''
   def __init__(self, request, delegate=None):
     self._request = request
     self._delegate = delegate or InstanceServlet.Delegate()
 
   def Get(self):
@@ skipping 23 matching lines @@
       # Disable cache for patched content.
       response.headers.pop('cache-control', None)
     except RietveldPatcherError as e:
       response = Response.NotFound(e.message, {'Content-Type': 'text/plain'})
 
     redirect_url, permanent = response.GetRedirect()
     if redirect_url is not None:
       response = Response.Redirect('/_patch/%s%s' % (issue, redirect_url),
                                    permanent)
     return response