Fix sharing cache when parsing in parallel

CHANGELOG.rst

@@ -7,7 +7,7 @@ Changelog
 Bug fixes:
 
 * Fix race condition between parallel requests when the cache is used
-  (:issue:`371`). Thanks :user:`ThiefMaster` for reporting.
+  (:issue:`371`). Thanks :user:`ThiefMaster` for reporting and fixing.
 
 5.1.2 (2019-02-03)
 ******************

src/webargs/asyncparser.py

@@ -77,6 +77,7 @@ async def parse(
 
         Receives the same arguments as `webargs.core.Parser.parse`.
         """
+        self.clear_cache()  # in case someone used `parse_*()`
         req = req if req is not None else self.get_default_request()
         assert req is not None, "Must pass req object"
         data = None
@@ -93,8 +94,6 @@ async def parse(
             await self._on_validation_error(
                 error, req, schema, error_status_code, error_headers
             )
-        finally:
-            self.clear_cache()
         return data
 
     async def _on_validation_error(

src/webargs/core.py

@@ -5,6 +5,7 @@
 import inspect
 import logging
 import warnings
+from copy import copy
 from distutils.version import LooseVersion
 
 try:
@@ -317,6 +318,11 @@ def _get_schema(self, argmap, req):
             )
         return schema
 
+    def _clone(self):
+        clone = copy(self)
+        clone.clear_cache()
+        return clone
+
     def parse(
         self,
         argmap,
@@ -345,28 +351,34 @@ def parse(
 
          :return: A dictionary of parsed arguments
         """
+        self.clear_cache()  # in case someone used `parse_*()`
         req = req if req is not None else self.get_default_request()
         assert req is not None, "Must pass req object"
         data = None
         validators = _ensure_list_of_callables(validate)
+        parser = self._clone()
         schema = self._get_schema(argmap, req)
         try:
-            parsed = self._parse_request(
+            parsed = parser._parse_request(
                 schema=schema, req=req, locations=locations or self.locations
             )
             result = schema.load(parsed)
             data = result.data if MARSHMALLOW_VERSION_INFO[0] < 3 else result
-            self._validate_arguments(data, validators)
+            parser._validate_arguments(data, validators)
         except ma.exceptions.ValidationError as error:
-            self._on_validation_error(
+            parser._on_validation_error(
                 error, req, schema, error_status_code, error_headers
             )
-        finally:
-            self.clear_cache()
         return data
 
     def clear_cache(self):
-        """Invalidate the parser's cache."""
+        """Invalidate the parser's cache.
+
+        This is usually a no-op now since the Parser clone used for parsing a
+        request is discarded afterwards.  It can still be used when manually
+        calling ``parse_*`` methods which would populate the cache on the main
+        Parser instance.
+        """
         self._cache = {}
         return None
 

src/webargs/tornadoparser.py

@@ -82,10 +82,6 @@ def get_value(d, name, field):
 class TornadoParser(core.Parser):
     """Tornado request argument parser."""
 
-    def __init__(self, *args, **kwargs):
-        super(TornadoParser, self).__init__(*args, **kwargs)
-        self.json = None
-
     def parse_json(self, req, name, field):
         """Pull a json value from the request."""
         json_data = self._cache.get("json")

tests/test_tornadoparser.py

@@ -298,17 +298,6 @@ def test_it_should_parse_query_arguments(self):
         assert parsed["integer"] == [1, 2]
         assert parsed["string"] == value
 
-    def test_parsing_clears_cache(self):
-        request = make_json_request({"string": "value", "integer": [1, 2]})
-        string_result = parser.parse_json(request, "string", fields.Str())
-        assert string_result == "value"
-        assert "json" in parser._cache
-        assert "string" in parser._cache["json"]
-        assert "integer" in parser._cache["json"]
-        attrs = {"string": fields.Str(), "integer": fields.List(fields.Int())}
-        parser.parse(attrs, request)
-        assert parser._cache == {}
-
     def test_it_should_parse_form_arguments(self):
         attrs = {"string": fields.Field(), "integer": fields.List(fields.Int())}