Added concept of response backends to image resizer, so it's now trivial to use something like X-Sendfile and X-Accel-Redirect rather than serving the image data directly through the app.

Moved exceptions into their own module to avoid circular imports

oscar/apps/image/dynamic/__init__.py

@@ -1,32 +1,21 @@
-from oscar.apps.image.dynamic.cache import NullCache, DiskCache
+from oscar.apps.image.dynamic.cache import DiskCache
+from oscar.apps.image.dynamic.exceptions import ResizerConfigurationException, \
+    ResizerSyntaxException, ResizerFormatException
 from oscar.apps.image.dynamic.mods import AutotrimMod, CropMod, ResizeMod
+from oscar.apps.image.dynamic.response_backends import DirectResponse
 from wsgiref.util import request_uri, application_uri
 import Image
 import cStringIO
-import sys
-import os
-import math
 import datetime
-
+import math
+import os
+import sys
 
 try:
     import cStringIO as StringIO
 except:
     import StringIO
 
-
-class ResizerConfigurationException(Exception):
-    pass
-
-
-class ResizerSyntaxException(Exception):
-    pass
-
-
-class ResizerFormatException(Exception):
-    pass
-
-
 def get_class(kls):
     try:
         parts = kls.split('.')
@@ -90,7 +79,6 @@ class ImageModifier(object):
     quality = 80
 
     def __init__(self, url, config):
-
         if config.get('installed_mods'):
             mod_overrides = []
             for v in config['installed_mods']:
@@ -133,8 +121,7 @@ class ImageModifier(object):
                 self._params = dict(
                     [(x.split("-")[0], x.split("-")[1]) for x in param_parts])
                 self._params['type'] = parts[3]
-
-            except IndexError, e:
+            except IndexError:
                 raise ResizerSyntaxException("Invalid filename syntax")
         else:
             raise ResizerSyntaxException("Invalid filename syntax")
@@ -168,6 +155,9 @@ class ImageModifier(object):
 
     def get_type(self):
         return self.output_formats[self._params['type']]
+    
+    def get_mime_type(self):
+        return self.get_type()[1]
 
 
 class BaseImageHandler(object):
@@ -178,20 +168,10 @@ class BaseImageHandler(object):
     """
     modifier = ImageModifier
     cache = DiskCache
-
-    def build_response(self, data, modifier, start_response):
-        """
-        Serves the (now) cached image off the disc. It is assumed that the file
-        actually exists as it's non-existence should have been picked up while
-        checking to see if the cached version is valid.
-        """
-        status = '200 OK'
-
-        response_headers = [('Content-type', modifier.get_type()[1]),
-                            ('Content-Length', str(len(data)))]
-        start_response(status, response_headers)
-
-        return [data]
+    response_backend = DirectResponse
+    
+    def build_sendfile_response(self, metadata, modifier, start_response):
+        pass
 
     def __call__(self, environ, start_response):
         path = environ.get('PATH_INFO')
@@ -204,6 +184,9 @@ class BaseImageHandler(object):
 
         if config.get('cache_backend'):
             self.cache = get_class(config['cache_backend'])
+        if config.get('response_backend'):
+            self.response_backend = get_class(config['response_backend'])
+            
         try:
             c = self.cache(path, config)
             m = self.modifier(path, config)
@@ -213,7 +196,7 @@ class BaseImageHandler(object):
             if not c.check(m.source_path()):
                 data = m.generate_image()
                 c.write(data)
-            return self.build_response(c.read(), m, start_response)
+            return self.response_backend(m.get_mime_type(),c,start_response).build_response()
         except Exception, e:
             return error404(path, start_response)
 
@@ -235,7 +218,7 @@ class DjangoImageHandler(BaseImageHandler):
         django_response = HttpResponse()
 
         def start_response(status, headers):
-            status, reason = status.split(' ', 1)
+            status = status.split(' ', 1)[0]
             django_response.status_code = int(status)
             for header, value in headers:
                 django_response[header] = value

oscar/apps/image/dynamic/cache.py

@@ -79,6 +79,14 @@ class DiskCache(BaseCache):
         f = open(path, 'w')
         f.write(data)
         f.close()
+        
+    def file_info(self):
+        """
+        If we're using X-Sendfile or X-Accel-Redirect we want to return info
+        about the file, rather than the actual file content
+        """
+        size = os.path.getsize(self._cache_path())
+        return (self._cache_path(), size)
 
     def read(self):
         f = open(self._cache_path(), "r")

oscar/apps/image/dynamic/exceptions.py

@@ -0,0 +1,10 @@
+class ResizerConfigurationException(Exception):
+    pass
+
+
+class ResizerSyntaxException(Exception):
+    pass
+
+
+class ResizerFormatException(Exception):
+    pass

oscar/apps/image/dynamic/response_backends.py

@@ -0,0 +1,71 @@
+from oscar.apps.image.dynamic.exceptions import ResizerConfigurationException
+
+class BaseResponse(object):
+    def __init__(self,mime_type,cache,start_response):
+        self.mime_type = mime_type
+        self.cache = cache
+        self.start_response = start_response
+        
+    def build_response(self):
+        pass
+
+class DirectResponse(BaseResponse):
+    """
+    Serve the file directly, can use any caching mechanism
+    """
+    def build_response(self):
+        """
+        Serves the (now) cached image off the disc. It is assumed that the file
+        actually exists as it's non-existence should have been picked up while
+        checking to see if the cached version is valid.
+        """
+        status = '200 OK'
+
+        data = self.cache.read()
+        
+        response_headers = [('Content-Type', self.mime_type),
+                            ('Content-Length', str(len(data)))]
+        self.start_response(status, response_headers)
+
+        return [data]
+    
+class NginxSendfileResponse(BaseResponse):
+    """
+    This can only work with a disk-based caching system since it only returns
+    headers about the file rather than the file data itself
+    """
+    
+    def build_response(self):
+        if not hasattr(self.cache, 'file_info'):
+            msg = "Cache doesn't implements the method 'file_info'"
+            raise ResizerConfigurationException(msg)
+
+        print 'moooo'
+        
+        status = '200 OK'
+        
+        filename, content_length = self.cache.file_info()
+        
+        response_headers = [('Content-Type', self.mime_type),
+                            ('Content-Length', content_length),
+                            ('X-Accel-Redirect', filename)]
+        
+        self.start_response(status, response_headers)
+        return ['']
+    
+class ApacheSendfileResponse(BaseResponse):
+    def build_response(self):
+        if not hasattr(self.cache, 'file_info'):
+            msg = "ApacheSendfileResponse requires a cache that implements the method 'file_data'"
+            raise ResizerConfigurationException(msg)
+        
+        status = '200 OK'
+        
+        filename, content_length = self.cache.file_info()
+        
+        response_headers = [('Content-Type', self.mime_type),
+                            ('Content-Length', content_length),
+                            ('X-Sendfile', filename)]
+        
+        self.start_response(status, response_headers)
+        return ['']