Devserver: allow SubversionFileSystem to be pinned to a specific rev on construction

chrome/common/extensions/docs/server2/subversion_file_system.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 re
 import posixpath
 import xml.dom.minidom as xml
 from xml.parsers.expat import ExpatError
 
 from appengine_url_fetcher import AppEngineUrlFetcher
 from docs_server_utils import StringIdentity
 from file_system import FileSystem, FileNotFoundError, StatInfo, ToUnicode
 from future import Future
 import svn_constants
 import url_constants
 
 class _AsyncFetchFuture(object):
-  def __init__(self, paths, fetcher, binary):
+  def __init__(self, paths, fetcher, binary, args=None):
+    def apply_args(path):
+      return path if args is None else '%s?%s' % (path, args)
     # A list of tuples of the form (path, Future).
-    self._fetches = [(path, fetcher.FetchAsync(path))
+    self._fetches = [(path, fetcher.FetchAsync(apply_args(path)))
                      for path in paths]
     self._value = {}
     self._error = None
     self._binary = binary
 
   def _ListDir(self, directory):
     dom = xml.parseString(directory)
     files = [elem.childNodes[0].data for elem in dom.getElementsByTagName('a')]
     if '..' in files:
       files.remove('..')
@@ skipping 15 matching lines @@
       else:
         self._value[path] = result.content
     if self._error is not None:
       raise self._error
     return self._value
 
 class SubversionFileSystem(FileSystem):
   '''Class to fetch resources from src.chromium.org.
   '''
   @staticmethod
-  def Create(branch):
+  def Create(branch, revision=None):
     if branch == 'trunk':
       svn_path = 'trunk/src/%s' % svn_constants.EXTENSIONS_PATH
     else:
       svn_path = 'branches/%s/src/%s' % (branch,
                                          svn_constants.EXTENSIONS_PATH)
     return SubversionFileSystem(
         AppEngineUrlFetcher('%s/%s' % (url_constants.SVN_URL, svn_path)),
         AppEngineUrlFetcher('%s/%s' % (url_constants.VIEWVC_URL, svn_path)),
-        svn_path)
+        svn_path,
+        revision=revision)
 
-  def __init__(self, file_fetcher, stat_fetcher, svn_path):
+  def __init__(self, file_fetcher, stat_fetcher, svn_path, revision=None):
     self._file_fetcher = file_fetcher
     self._stat_fetcher = stat_fetcher
     self._svn_path = svn_path
+    self._revision = revision
 
   def Read(self, paths, binary=False):
+    args = None
+    if self._revision is not None:
+      # |fetcher| gets from svn.chromium.org which uses p= for version.
+      args = 'p=%s' % self._revision
     return Future(delegate=_AsyncFetchFuture(paths,
                                              self._file_fetcher,
-                                             binary))
+                                             binary,
+                                             args=args))
 
   def _ParseHTML(self, html):
     '''Unfortunately, the viewvc page has a stray </div> tag, so this takes care
     of all mismatched tags.
     '''
     try:
       return xml.parseString(html)
     except ExpatError as e:
       return self._ParseHTML('\n'.join(
           line for (i, line) in enumerate(html.split('\n'))
@@ skipping 48 matching lines @@
                       dict((path, str(version))
                            for path, version in child_versions.iteritems()))
 
     # Bleh, but, this data is so unreliable. There are actually some empty file
     # listings caused by git/svn/something not cleaning up empty dirs.
     return StatInfo('0', {})
 
   def Stat(self, path):
     directory, filename = posixpath.split(path)
     directory += '/'
+    if self._revision is not None:
+      # |stat_fetch| uses viewvc which uses pathrev= for version.
+      directory += '?pathrev=%s' % self._revision
     result = self._stat_fetcher.Fetch(directory)
     if result.status_code == 404:
       raise FileNotFoundError(
           'Got 404 when fetching %s from %s for Stat' % (path, directory))
     stat_info = self._CreateStatInfo(result.content)
     if path.endswith('/'):
       return stat_info
     if filename not in stat_info.child_versions:
       raise FileNotFoundError('%s was not in child versions' % filename)
     return StatInfo(stat_info.child_versions[filename])
 
   def GetIdentity(self):
+    # NOTE: no revision here, consider it just an implementation detail of the
+    # file version that is handled by Stat.
     return '@'.join((self.__class__.__name__, StringIdentity(self._svn_path)))