Merge remote-tracking branch 'origin/release' into merge-release-into-master

Conflicts:
	requirements/edx/github.txt

common/djangoapps/request_cache/__init__.py

@@ -0,0 +1,28 @@
+"""
+A cache that is cleared after every request.
+
+This module requires that :class:`request_cache.middleware.RequestCache`
+is installed in order to clear the cache after each request.
+"""
+
+
+from request_cache import middleware
+
+
+def get_cache(name):
+    """
+    Return the request cache named ``name``.
+
+    Arguments:
+        name (str): The name of the request cache to load
+
+    Returns: dict
+    """
+    return middleware.RequestCache.get_request_cache(name)
+
+
+def get_request():
+    """
+    Return the current request.
+    """
+    return middleware.RequestCache.get_current_request()

common/djangoapps/request_cache/middleware.py

@@ -1,34 +1,48 @@
 import threading
 
-_request_cache_threadlocal = threading.local()
-_request_cache_threadlocal.data = {}
-_request_cache_threadlocal.request = None
+
+class _RequestCache(threading.local):
+    """
+    A thread-local for storing the per-request cache.
+    """
+    def __init__(self):
+        super(_RequestCache, self).__init__()
+        self.data = {}
+        self.request = None
+
+
+REQUEST_CACHE = _RequestCache()
 
 
 class RequestCache(object):
     @classmethod
-    def get_request_cache(cls):
-        return _request_cache_threadlocal
+    def get_request_cache(cls, name=None):
+        """
+        This method is deprecated. Please use :func:`request_cache.get_cache`.
+        """
+        if name is None:
+            return REQUEST_CACHE
+        else:
+            return REQUEST_CACHE.data.setdefault(name, {})
 
     @classmethod
     def get_current_request(cls):
         """
-        Get a reference to the HttpRequest object, if we are presently
-        servicing one.
+        This method is deprecated. Please use :func:`request_cache.get_request`.
         """
-        return _request_cache_threadlocal.request
+        return REQUEST_CACHE.request
 
     @classmethod
     def clear_request_cache(cls):
         """
         Empty the request cache.
         """
-        _request_cache_threadlocal.data = {}
-        _request_cache_threadlocal.request = None
+        REQUEST_CACHE.data = {}
+        REQUEST_CACHE.request = None
 
     def process_request(self, request):
         self.clear_request_cache()
-        _request_cache_threadlocal.request = request
+        REQUEST_CACHE.request = request
         return None
 
     def process_response(self, request, response):

common/lib/xmodule/xmodule/assetstore/assetmgr.py

@@ -9,11 +9,12 @@ Handles:
 Phase 1: Checks to see if an asset's metadata can be found in the course's modulestore.
     If not found, fails over to access the asset from the contentstore.
     At first, the asset metadata will never be found, since saving isn't implemented yet.
+Note: Hotfix (PLAT-734) No asset calls find_asset_metadata, and directly accesses from contentstore.
+
 """
 
 from contracts import contract, new_contract
 from opaque_keys.edx.keys import AssetKey
-from xmodule.modulestore.django import modulestore
 from xmodule.contentstore.django import contentstore
 
 
@@ -49,14 +50,11 @@ class AssetManager(object):
     @contract(asset_key='AssetKey', throw_on_not_found='bool', as_stream='bool')
     def find(asset_key, throw_on_not_found=True, as_stream=False):
         """
-        Finds a course asset either in the assetstore -or- in the deprecated contentstore.
+        Finds course asset in the deprecated contentstore.
+        This method was previously searching for the course asset in the assetstore first, then in the deprecated
+        contentstore. However, the asset was never found in the assetstore since an asset's metadata is
+        not yet stored there.(removed calls to modulestore().find_asset_metadata(asset_key))
+        The assetstore search was removed due to performance issues caused by each call unpickling the pickled and
+        compressed course structure from the structure cache.
         """
-        content_md = modulestore().find_asset_metadata(asset_key)
-
-        # If found, raise an exception.
-        if content_md:
-            # For now, no asset metadata should be found in the modulestore.
-            raise AssetMetadataFoundTemporary()
-        else:
-            # If not found, load the asset via the contentstore.
-            return contentstore().find(asset_key, throw_on_not_found, as_stream)
+        return contentstore().find(asset_key, throw_on_not_found, as_stream)

common/lib/xmodule/xmodule/discussion_module.py

@@ -65,9 +65,13 @@ class DiscussionModule(DiscussionFields, XModule):
 
     def get_course(self):
         """
-        Return course by course id.
+        Return the CourseDescriptor at the root of the tree we're in.
         """
-        return self.descriptor.runtime.modulestore.get_course(self.course_id)
+        block = self
+        while block.parent:
+            block = block.get_parent()
+
+        return block
 
 
 class DiscussionDescriptor(DiscussionFields, MetadataOnlyEditingDescriptor, RawDescriptor):