Ticket #2200: twisted.web2.server.patch

twisted/web2/server.py

@@ -1 +1 @@
 # -*- test-case-name: twisted.web2.test.test_server -*-
 # Copyright (c) 2001-2004 Twisted Matrix Laboratories.
 # See LICENSE for details.
+from twisted.internet.defer import succeed
+from twisted.web2.dav.util import joinURL
 
 
 """This is a web-sever which integrates with the twisted.internet
@@ -150 +152 @@
             self._initialprepath = kw['prepathuri']
             del kw['prepathuri']
 
+        self._resourcesByURL = {}
+        self._urlsByResource = {}
+
         # Copy response filters from the class
         self.responseFilters = self.responseFilters[:]
         self.files = {}
         self.resources = []
         http.Request.__init__(self, *args, **kw)
 
-    def addResponseFilter(self, f, atEnd=False):
+    def addResponseFilter(self, filter, atEnd=False, onlyOnce=False):
+        """
+        Add a response filter to this request.
+        Response filters are applied to the response to this request in order.
+        @param filter: a callable which takes an response argument and returns
+            a response object.
+        @param atEnd: if C{True}, C{filter} is added at the end of the list of
+            response filters; if C{False}, it is added to the beginning.
+        @param onlyOnce: if C{True}, C{filter} is not added to the list of
+            response filters if it already in the list.
+        """
+        if onlyOnce and filter in self.responseFilters:
+            return
         if atEnd:
-            self.responseFilters.append(f)
+            self.responseFilters.append(filter)
         else:
-            self.responseFilters.insert(0, f)
+            self.responseFilters.insert(0, filter)
 
     def unparseURL(self, scheme=None, host=None, port=None,
                    path=None, params=None, querystring=None, fragment=None):
@@ -265 +282 @@
         
         d = defer.Deferred()
         d.addCallback(self._getChild, self.site.resource, self.postpath)
+        d.addCallback(self._rememberResource, "/" + "/".join(self.prepath))
         d.addCallback(lambda res, req: res.renderHTTP(req), self)
         d.addCallback(self._cbFinishRender)
         d.addErrback(self._processingFailed)
@@ -320 +338 @@
                     url = "/" + "/".join(path)
                 else:
                     url = "/"
-        
-                self._rememberURLForResource(quote(url), res)
                 return res
             #else:
             #    raise ValueError("locateChild must not return StopTraversal with a resource other than self.")
@@ -342 +358 @@
                 self.prepath.append(self.postpath.pop(0))
 
         child = self._getChild(None, newres, newpath, updatepaths=updatepaths)
-        self._rememberURLForResource(quote(url), child)
 
         return child
 
-    _resourcesByURL = weakref.WeakKeyDictionary()
-
-    def _rememberURLForResource(self, url, resource):
+    def _rememberResource(self, resource, url):
         """
-        Remember the URL of visited resources.
+        Remember the URL of a visited resources.
         """
         self._resourcesByURL[resource] = url
+        self._urlsByResource[url] = resource
+        return resource
 
     def urlForResource(self, resource):
         """
@@ -367 +382 @@
 
         @return: the URL of C{resource} if known, otherwise C{None}.
         """
-        try:
-            return self._resourcesByURL[resource]
-        except KeyError:
-            return None
+        return self._resourcesByURL.get(resource, None)
 
     def locateResource(self, url):
         """
@@ -385 +397 @@
             The contained response will have a status code of
             L{responsecode.BAD_REQUEST}.
         """
-        if url is None: return None
+        if url is None:
+            return None
 
+        cached = self._urlsByResource.get(url, None)
+        if cached is not None:
+            return succeed(cached)
+
         #
         # Parse the URL
         #
@@ -406 +423 @@
                 "URL is not on this site (%s://%s/): %s" % (scheme, self.headers.getHeader("host"), url)
             ))
 
-        segments = path.split("/")
+        segments = unquote(path).split("/")
         assert segments[0] == "", "URL path didn't begin with '/': %s" % (path,)
         segments = segments[1:]
-        segments = map(unquote, segments)
 
         def notFound(f):
             f.trap(http.HTTPError)
             if f.response.code != responsecode.NOT_FOUND:
-                raise f
+                return f
             return None
 
-        return defer.maybeDeferred(self._getChild, None, self.site.resource, segments, updatepaths=False)
+        d = defer.maybeDeferred(self._getChild, None, self.site.resource, segments, updatepaths=False)
+        d.addCallback(self._rememberResource, path)
+        d.addErrback(notFound)
+        return d
 
+    def locateChildResource(self, parent, child_name):
+        """
+        Looks up the child resource with the given name given the parent
+        resource.  This is similar to locateResource(), but doesn't have to
+        start the lookup from the root resource, so it is potentially faster.
+        @param parent: the parent of the resource being looked up.
+        @param child_name: the name of the child of C{parent} to looked up.
+            to C{parent}.
+        @return: a L{Deferred} resulting in the L{IResource} at the
+            given URL or C{None} if no such resource can be located.
+        @raise HTTPError: If C{url} is not a URL on the site that this
+            request is being applied to.  The contained response will
+            have a status code of L{responsecode.BAD_GATEWAY}.
+        @raise HTTPError: If C{url} contains a query or fragment.
+            The contained response will have a status code of
+            L{responsecode.BAD_REQUEST}.
+        """
+        if parent is None or child_name is None:
+            return None
+
+        url = joinURL(self.urlForResource(parent), child_name)
+
+        cached = self._urlsByResource.get(url, None)
+        if cached is not None:
+            return succeed(cached)
+
+        assert "/" not in child_name, "Child name may not contain '/': %s" % (child_name,)
+
+        segment = unquote(child_name)
+
+        def notFound(f):
+            f.trap(http.HTTPError)
+            if f.response.code != responsecode.NOT_FOUND:
+                return f
+            return None
+
+        d = defer.maybeDeferred(self._getChild, None, parent, [segment], updatepaths=False)
+        d.addCallback(self._rememberResource, url)
+        d.addErrback(notFound)
+        return d
+
     def _processingFailed(self, reason):
         if reason.check(http.HTTPError) is not None:
             # If the exception was an HTTPError, leave it alone