made some improvements to the base http handler

14 files changed, 177 insertions, 428 deletions

diff --git a/MediaBrowser.Api/HttpHandlers/BaseMediaHandler.cs b/MediaBrowser.Api/HttpHandlers/BaseMediaHandler.cs
index 7ad0ed8aa..96ef60681 100644
--- a/MediaBrowser.Api/HttpHandlers/BaseMediaHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/BaseMediaHandler.cs
@@ -90,14 +90,15 @@ namespace MediaBrowser.Api.HttpHandlers
             }

         }

 

-        public override Task<string> GetContentType()

+        protected override Task<ResponseInfo> GetResponseInfo()

         {

-            return Task.FromResult(MimeTypes.GetMimeType("." + GetConversionOutputFormat()));

-        }

+            ResponseInfo info = new ResponseInfo

+            {

+                ContentType = MimeTypes.GetMimeType("." + GetConversionOutputFormat()),

+                CompressResponse = false

+            };

 

-        public override bool ShouldCompressResponse(string contentType)

-        {

-            return false;

+            return Task.FromResult<ResponseInfo>(info);

         }

 

         public override Task ProcessRequest(HttpListenerContext ctx)

diff --git a/MediaBrowser.Api/HttpHandlers/ImageHandler.cs b/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
index d3aaf27ff..4aa367fb7 100644
--- a/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
@@ -7,7 +7,6 @@ using MediaBrowser.Model.Entities;
 using System;

 using System.ComponentModel.Composition;

 using System.IO;

-using System.Linq;

 using System.Net;

 using System.Threading.Tasks;

 

@@ -82,76 +81,32 @@ namespace MediaBrowser.Api.HttpHandlers
             return ImageProcessor.GetImagePath(entity, ImageType, ImageIndex);

         }

 

-        public override async Task<string> GetContentType()

-        {

-            if (Kernel.Instance.ImageProcessors.Any(i => i.RequiresTransparency))

-            {

-                return MimeTypes.GetMimeType(".png");

-            }

-

-            return MimeTypes.GetMimeType(await GetImagePath().ConfigureAwait(false));

-        }

-

-        public override TimeSpan CacheDuration

-        {

-            get { return TimeSpan.FromDays(365); }

-        }

-

-        protected override async Task<DateTime?> GetLastDateModified()

+        protected async override Task<ResponseInfo> GetResponseInfo()

         {

             string path = await GetImagePath().ConfigureAwait(false);

 

-            DateTime date = File.GetLastWriteTimeUtc(path);

+            ResponseInfo info = new ResponseInfo

+            {

+                CacheDuration = TimeSpan.FromDays(365),

+                ContentType = MimeTypes.GetMimeType(path)

+            };

+

+            DateTime? date = File.GetLastWriteTimeUtc(path);

 

             // If the file does not exist it will return jan 1, 1601

             // http://msdn.microsoft.com/en-us/library/system.io.file.getlastwritetimeutc.aspx

-            if (date.Year == 1601)

+            if (date.Value.Year == 1601)

             {

                 if (!File.Exists(path))

                 {

-                    StatusCode = 404;

-                    return null;

-                }

-            }

-

-            return await GetMostRecentDateModified(date);

-        }

-

-        private async Task<DateTime> GetMostRecentDateModified(DateTime imageFileLastDateModified)

-        {

-            var date = imageFileLastDateModified;

-

-            var entity = await GetSourceEntity().ConfigureAwait(false);

-            

-            foreach (var processor in Kernel.Instance.ImageProcessors)

-            {

-                if (processor.IsConfiguredToProcess(entity, ImageType, ImageIndex))

-                {

-                    if (processor.ProcessingConfigurationDateLastModifiedUtc > date)

-                    {

-                        date = processor.ProcessingConfigurationDateLastModifiedUtc;

-                    }

+                    info.StatusCode = 404;

+                    date = null;

                 }

             }

 

-            return date;

-        }

-

-        protected override async Task<string> GetETag()

-        {

-            string tag = string.Empty;

-

-            var entity = await GetSourceEntity().ConfigureAwait(false);

-

-            foreach (var processor in Kernel.Instance.ImageProcessors)

-            {

-                if (processor.IsConfiguredToProcess(entity, ImageType, ImageIndex))

-                {

-                    tag += processor.ProcessingConfigurationDateLastModifiedUtc.Ticks.ToString();

-                }

-            }

+            info.DateLastModified = date;

 

-            return tag;

+            return info;

         }

 

         private int ImageIndex

diff --git a/MediaBrowser.Api/HttpHandlers/PluginAssemblyHandler.cs b/MediaBrowser.Api/HttpHandlers/PluginAssemblyHandler.cs
index 88161c114..47f08c8c3 100644
--- a/MediaBrowser.Api/HttpHandlers/PluginAssemblyHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/PluginAssemblyHandler.cs
@@ -15,8 +15,8 @@ namespace MediaBrowser.Api.HttpHandlers
         {

             return ApiService.IsApiUrlMatch("pluginassembly", request);

         }

-        

-        public override Task<string> GetContentType()

+

+        protected override Task<ResponseInfo> GetResponseInfo()

         {

             throw new NotImplementedException();

         }

diff --git a/MediaBrowser.Api/HttpHandlers/PluginConfigurationHandler.cs b/MediaBrowser.Api/HttpHandlers/PluginConfigurationHandler.cs
index 95af9a344..dc363956f 100644
--- a/MediaBrowser.Api/HttpHandlers/PluginConfigurationHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/PluginConfigurationHandler.cs
@@ -17,7 +17,7 @@ namespace MediaBrowser.Api.HttpHandlers
         {

             return ApiService.IsApiUrlMatch("pluginconfiguration", request);

         }

-        

+

         private BasePlugin _plugin;

         private BasePlugin Plugin

         {

@@ -39,18 +39,15 @@ namespace MediaBrowser.Api.HttpHandlers
             return Task.FromResult(Plugin.Configuration);

         }

 

-        public override TimeSpan CacheDuration

+        protected override async Task<ResponseInfo> GetResponseInfo()

         {

-            get

-            {

-                return TimeSpan.FromDays(7);

-            }

-        }

+            var info = await base.GetResponseInfo().ConfigureAwait(false);

 

-        protected override Task<DateTime?> GetLastDateModified()

-        {

-            return Task.FromResult<DateTime?>(Plugin.ConfigurationDateLastModified);

-        }

+            info.DateLastModified = Plugin.ConfigurationDateLastModified;

 

+            info.CacheDuration = TimeSpan.FromDays(7);

+

+            return info;

+        }

     }

 }

diff --git a/MediaBrowser.Api/HttpHandlers/ServerConfigurationHandler.cs b/MediaBrowser.Api/HttpHandlers/ServerConfigurationHandler.cs
index 64ba44ec2..48c6761b1 100644
--- a/MediaBrowser.Api/HttpHandlers/ServerConfigurationHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/ServerConfigurationHandler.cs
@@ -16,23 +16,22 @@ namespace MediaBrowser.Api.HttpHandlers
         {

             return ApiService.IsApiUrlMatch("serverconfiguration", request);

         }

-        

+

         protected override Task<ServerConfiguration> GetObjectToSerialize()

         {

             return Task.FromResult(Kernel.Instance.Configuration);

         }

 

-        public override TimeSpan CacheDuration

+        protected override async Task<ResponseInfo> GetResponseInfo()

         {

-            get

-            {

-                return TimeSpan.FromDays(7);

-            }

-        }

+            var info = await base.GetResponseInfo().ConfigureAwait(false);

 

-        protected override Task<DateTime?> GetLastDateModified()

-        {

-            return Task.FromResult<DateTime?>(File.GetLastWriteTimeUtc(Kernel.Instance.ApplicationPaths.SystemConfigurationFilePath));

+            info.DateLastModified =

+                File.GetLastWriteTimeUtc(Kernel.Instance.ApplicationPaths.SystemConfigurationFilePath);

+

+            info.CacheDuration = TimeSpan.FromDays(7);

+

+            return info;

         }

     }

 }

diff --git a/MediaBrowser.Api/HttpHandlers/WeatherHandler.cs b/MediaBrowser.Api/HttpHandlers/WeatherHandler.cs
index 90ecae122..378e89067 100644
--- a/MediaBrowser.Api/HttpHandlers/WeatherHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/WeatherHandler.cs
@@ -16,7 +16,7 @@ namespace MediaBrowser.Api.HttpHandlers
         {

             return ApiService.IsApiUrlMatch("weather", request);

         }

-        

+

         protected override Task<WeatherInfo> GetObjectToSerialize()

         {

             // If a specific zip code was requested on the query string, use that. Otherwise use the value from configuration

@@ -31,15 +31,13 @@ namespace MediaBrowser.Api.HttpHandlers
             return Kernel.Instance.WeatherProviders.First().GetWeatherInfoAsync(zipCode);

         }

 

-        /// <summary>

-        /// Tell the client to cache the weather info for 15 minutes

-        /// </summary>

-        public override TimeSpan CacheDuration

+        protected override async Task<ResponseInfo> GetResponseInfo()

         {

-            get

-            {

-                return TimeSpan.FromMinutes(15);

-            }

+            var info = await base.GetResponseInfo().ConfigureAwait(false);

+

+            info.CacheDuration = TimeSpan.FromMinutes(15);

+

+            return info;

         }

     }

 }

diff --git a/MediaBrowser.Common/Net/Handlers/BaseEmbeddedResourceHandler.cs b/MediaBrowser.Common/Net/Handlers/BaseEmbeddedResourceHandler.cs
index 3ce85a688..579e341fe 100644
--- a/MediaBrowser.Common/Net/Handlers/BaseEmbeddedResourceHandler.cs
+++ b/MediaBrowser.Common/Net/Handlers/BaseEmbeddedResourceHandler.cs
@@ -13,11 +13,6 @@ namespace MediaBrowser.Common.Net.Handlers
 

         protected string ResourcePath { get; set; }

 

-        public override Task<string> GetContentType()

-        {

-            return Task.FromResult(MimeTypes.GetMimeType(ResourcePath));

-        }

-

         protected override Task WriteResponseToOutputStream(Stream stream)

         {

             return GetEmbeddedResourceStream().CopyToAsync(stream);

diff --git a/MediaBrowser.Common/Net/Handlers/BaseHandler.cs b/MediaBrowser.Common/Net/Handlers/BaseHandler.cs
index ab12cb2cf..a5058e6ca 100644
--- a/MediaBrowser.Common/Net/Handlers/BaseHandler.cs
+++ b/MediaBrowser.Common/Net/Handlers/BaseHandler.cs
@@ -112,32 +112,6 @@ namespace MediaBrowser.Common.Net.Handlers
             }

         }

 

-        /// <summary>

-        /// Gets the MIME type to include in the response headers

-        /// </summary>

-        public abstract Task<string> GetContentType();

-

-        /// <summary>

-        /// Gets the status code to include in the response headers

-        /// </summary>

-        protected int StatusCode { get; set; }

-

-        /// <summary>

-        /// Gets the cache duration to include in the response headers

-        /// </summary>

-        public virtual TimeSpan CacheDuration

-        {

-            get

-            {

-                return TimeSpan.FromTicks(0);

-            }

-        }

-

-        public virtual bool ShouldCompressResponse(string contentType)

-        {

-            return true;

-        }

-

         private bool ClientSupportsCompression

         {

             get

@@ -186,22 +160,21 @@ namespace MediaBrowser.Common.Net.Handlers
                     ctx.Response.Headers["Accept-Ranges"] = "bytes";

                 }

 

-                // Set the initial status code

-                // When serving a range request, we need to return status code 206 to indicate a partial response body

-                StatusCode = SupportsByteRangeRequests && IsRangeRequest ? 206 : 200;

-

-                ctx.Response.ContentType = await GetContentType().ConfigureAwait(false);

+                ResponseInfo responseInfo = await GetResponseInfo().ConfigureAwait(false);

 

-                string etag = await GetETag().ConfigureAwait(false);

-

-                if (!string.IsNullOrEmpty(etag))

+                if (responseInfo.IsResponseValid)

                 {

-                    ctx.Response.Headers["ETag"] = etag;

+                    // Set the initial status code

+                    // When serving a range request, we need to return status code 206 to indicate a partial response body

+                    responseInfo.StatusCode = SupportsByteRangeRequests && IsRangeRequest ? 206 : 200;

                 }

 

-                TimeSpan cacheDuration = CacheDuration;

+                ctx.Response.ContentType = responseInfo.ContentType;

 

-                DateTime? lastDateModified = await GetLastDateModified().ConfigureAwait(false);

+                if (!string.IsNullOrEmpty(responseInfo.Etag))

+                {

+                    ctx.Response.Headers["ETag"] = responseInfo.Etag;

+                }

 

                 if (ctx.Request.Headers.AllKeys.Contains("If-Modified-Since"))

                 {

@@ -210,30 +183,26 @@ namespace MediaBrowser.Common.Net.Handlers
                     if (DateTime.TryParse(ctx.Request.Headers["If-Modified-Since"], out ifModifiedSince))

                     {

                         // If the cache hasn't expired yet just return a 304

-                        if (IsCacheValid(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified))

+                        if (IsCacheValid(ifModifiedSince.ToUniversalTime(), responseInfo.CacheDuration, responseInfo.DateLastModified))

                         {

                             // ETag must also match (if supplied)

-                            if ((etag ?? string.Empty).Equals(ctx.Request.Headers["If-None-Match"] ?? string.Empty))

+                            if ((responseInfo.Etag ?? string.Empty).Equals(ctx.Request.Headers["If-None-Match"] ?? string.Empty))

                             {

-                                StatusCode = 304;

+                                responseInfo.StatusCode = 304;

                             }

                         }

                     }

                 }

 

-                await PrepareResponse().ConfigureAwait(false);

-

-                Logger.LogInfo("Responding with status code {0} for url {1}", StatusCode, url);

+                Logger.LogInfo("Responding with status code {0} for url {1}", responseInfo.StatusCode, url);

 

-                if (IsResponseValid)

+                if (responseInfo.IsResponseValid)

                 {

-                    bool compressResponse = ShouldCompressResponse(ctx.Response.ContentType) && ClientSupportsCompression;

-

-                    await ProcessUncachedRequest(ctx, compressResponse, cacheDuration, lastDateModified).ConfigureAwait(false);

+                    await ProcessUncachedRequest(ctx, responseInfo).ConfigureAwait(false);

                 }

                 else

                 {

-                    ctx.Response.StatusCode = StatusCode;

+                    ctx.Response.StatusCode = responseInfo.StatusCode;

                     ctx.Response.SendChunked = false;

                 }

             }

@@ -250,7 +219,7 @@ namespace MediaBrowser.Common.Net.Handlers
             }

         }

 

-        private async Task ProcessUncachedRequest(HttpListenerContext ctx, bool compressResponse, TimeSpan cacheDuration, DateTime? lastDateModified)

+        private async Task ProcessUncachedRequest(HttpListenerContext ctx, ResponseInfo responseInfo)

         {

             long? totalContentLength = TotalContentLength;

 

@@ -269,22 +238,29 @@ namespace MediaBrowser.Common.Net.Handlers
                 ctx.Response.ContentLength64 = totalContentLength.Value;

             }

 

+            var compressResponse = responseInfo.CompressResponse && ClientSupportsCompression;

+

             // Add the compression header

             if (compressResponse)

             {

                 ctx.Response.AddHeader("Content-Encoding", CompressionMethod);

             }

 

+            if (responseInfo.DateLastModified.HasValue)

+            {

+                ctx.Response.Headers[HttpResponseHeader.LastModified] = responseInfo.DateLastModified.Value.ToString("r");

+            }

+

             // Add caching headers

-            if (cacheDuration.Ticks > 0)

+            if (responseInfo.CacheDuration.Ticks > 0)

             {

-                CacheResponse(ctx.Response, cacheDuration, lastDateModified);

+                CacheResponse(ctx.Response, responseInfo.CacheDuration);

             }

 

             // Set the status code

-            ctx.Response.StatusCode = StatusCode;

+            ctx.Response.StatusCode = responseInfo.StatusCode;

 

-            if (IsResponseValid)

+            if (responseInfo.IsResponseValid)

             {

                 // Finally, write the response data

                 Stream outputStream = ctx.Response.OutputStream;

@@ -311,28 +287,10 @@ namespace MediaBrowser.Common.Net.Handlers
             }

         }

 

-        private void CacheResponse(HttpListenerResponse response, TimeSpan duration, DateTime? dateModified)

+        private void CacheResponse(HttpListenerResponse response, TimeSpan duration)

         {

-            DateTime now = DateTime.UtcNow;

-

-            DateTime lastModified = dateModified ?? now;

-

             response.Headers[HttpResponseHeader.CacheControl] = "public, max-age=" + Convert.ToInt32(duration.TotalSeconds);

-            response.Headers[HttpResponseHeader.Expires] = now.Add(duration).ToString("r");

-            response.Headers[HttpResponseHeader.LastModified] = lastModified.ToString("r");

-        }

-

-        protected virtual Task<string> GetETag()

-        {

-            return Task.FromResult<string>(string.Empty);

-        }

-

-        /// <summary>

-        /// Gives subclasses a chance to do any prep work, and also to validate data and set an error status code, if needed

-        /// </summary>

-        protected virtual Task PrepareResponse()

-        {

-            return Task.FromResult<object>(null);

+            response.Headers[HttpResponseHeader.Expires] = DateTime.UtcNow.Add(duration).ToString("r");

         }

 

         protected abstract Task WriteResponseToOutputStream(Stream stream);

@@ -380,20 +338,7 @@ namespace MediaBrowser.Common.Net.Handlers
             return null;

         }

 

-        protected virtual Task<DateTime?> GetLastDateModified()

-        {

-            DateTime? value = null;

-

-            return Task.FromResult(value);

-        }

-

-        private bool IsResponseValid

-        {

-            get

-            {

-                return StatusCode == 200 || StatusCode == 206;

-            }

-        }

+        protected abstract Task<ResponseInfo> GetResponseInfo();

 

         private Hashtable _formValues;

 

@@ -455,4 +400,31 @@ namespace MediaBrowser.Common.Net.Handlers
             return formVars;

         }

     }

+

+    public class ResponseInfo

+    {

+        public string ContentType { get; set; }

+        public string Etag { get; set; }

+        public DateTime? DateLastModified { get; set; }

+        public TimeSpan CacheDuration { get; set; }

+        public bool CompressResponse { get; set; }

+        public int StatusCode { get; set; }

+

+        public ResponseInfo()

+        {

+            CacheDuration = TimeSpan.FromTicks(0);

+

+            CompressResponse = true;

+

+            StatusCode = 200;

+        }

+

+        public bool IsResponseValid

+        {

+            get

+            {

+                return StatusCode == 200 || StatusCode == 206;

+            }

+        }

+    }

 }
\ No newline at end of file
diff --git a/MediaBrowser.Common/Net/Handlers/BaseSerializationHandler.cs b/MediaBrowser.Common/Net/Handlers/BaseSerializationHandler.cs
index d60a9ae1f..53b3ee817 100644
--- a/MediaBrowser.Common/Net/Handlers/BaseSerializationHandler.cs
+++ b/MediaBrowser.Common/Net/Handlers/BaseSerializationHandler.cs
@@ -1,12 +1,12 @@
-using System;

+using MediaBrowser.Common.Serialization;

+using System;

 using System.IO;

 using System.Threading.Tasks;

-using MediaBrowser.Common.Serialization;

 

 namespace MediaBrowser.Common.Net.Handlers

 {

     public abstract class BaseSerializationHandler<T> : BaseHandler

-        where T : class 

+        where T : class

     {

         public SerializationFormat SerializationFormat

         {

@@ -22,61 +22,61 @@ namespace MediaBrowser.Common.Net.Handlers
                 return (SerializationFormat)Enum.Parse(typeof(SerializationFormat), format, true);

             }

         }

-        

-        public override Task<string> GetContentType()

+

+        protected string ContentType

         {

-            switch (SerializationFormat)

+            get

             {

-                case SerializationFormat.Jsv:

-                    return Task.FromResult("text/plain");

-                case SerializationFormat.Protobuf:

-                    return Task.FromResult("application/x-protobuf");

-                default:

-                    return Task.FromResult(MimeTypes.JsonMimeType);

+                switch (SerializationFormat)

+                {

+                    case SerializationFormat.Jsv:

+                        return "text/plain";

+                    case SerializationFormat.Protobuf:

+                        return "application/x-protobuf";

+                    default:

+                        return MimeTypes.JsonMimeType;

+                }

             }

         }

 

-        private bool _objectToSerializeEnsured;

-        private T _objectToSerialize;

-     

-        private async Task EnsureObjectToSerialize()

+        protected override async Task<ResponseInfo> GetResponseInfo()

         {

-            if (!_objectToSerializeEnsured)

+            ResponseInfo info = new ResponseInfo

             {

-                _objectToSerialize = await GetObjectToSerialize().ConfigureAwait(false);

+                ContentType = ContentType

+            };

 

-                if (_objectToSerialize == null)

-                {

-                    StatusCode = 404;

-                }

+            _objectToSerialize = await GetObjectToSerialize().ConfigureAwait(false);

 

-                _objectToSerializeEnsured = true;

+            if (_objectToSerialize == null)

+            {

+                info.StatusCode = 404;

             }

+

+            return info;

         }

 

-        protected abstract Task<T> GetObjectToSerialize();

+        private T _objectToSerialize;

 

-        protected override Task PrepareResponse()

-        {

-            return EnsureObjectToSerialize();

-        }

+        protected abstract Task<T> GetObjectToSerialize();

 

-        protected async override Task WriteResponseToOutputStream(Stream stream)

+        protected override Task WriteResponseToOutputStream(Stream stream)

         {

-            await EnsureObjectToSerialize().ConfigureAwait(false);

-

-            switch (SerializationFormat)

+            return Task.Run(() =>

             {

-                case SerializationFormat.Jsv:

-                    JsvSerializer.SerializeToStream(_objectToSerialize, stream);

-                    break;

-                case SerializationFormat.Protobuf:

-                    ProtobufSerializer.SerializeToStream(_objectToSerialize, stream);

-                    break;

-                default:

-                    JsonSerializer.SerializeToStream(_objectToSerialize, stream);

-                    break;

-            }

+                switch (SerializationFormat)

+                {

+                    case SerializationFormat.Jsv:

+                        JsvSerializer.SerializeToStream(_objectToSerialize, stream);

+                        break;

+                    case SerializationFormat.Protobuf:

+                        ProtobufSerializer.SerializeToStream(_objectToSerialize, stream);

+                        break;

+                    default:

+                        JsonSerializer.SerializeToStream(_objectToSerialize, stream);

+                        break;

+                }

+            });

         }

     }

 

diff --git a/MediaBrowser.Common/Net/Handlers/StaticFileHandler.cs b/MediaBrowser.Common/Net/Handlers/StaticFileHandler.cs
index 741d2d6c1..11438b164 100644
--- a/MediaBrowser.Common/Net/Handlers/StaticFileHandler.cs
+++ b/MediaBrowser.Common/Net/Handlers/StaticFileHandler.cs
@@ -33,46 +33,7 @@ namespace MediaBrowser.Common.Net.Handlers
             }

         }

 

-        private bool _sourceStreamEnsured;

-        private Stream _sourceStream;

-        private Stream SourceStream

-        {

-            get

-            {

-                EnsureSourceStream();

-                return _sourceStream;

-            }

-        }

-

-        private void EnsureSourceStream()

-        {

-            if (!_sourceStreamEnsured)

-            {

-                try

-                {

-                    _sourceStream = File.OpenRead(Path);

-                }

-                catch (FileNotFoundException ex)

-                {

-                    StatusCode = 404;

-                    Logger.LogException(ex);

-                }

-                catch (DirectoryNotFoundException ex)

-                {

-                    StatusCode = 404;

-                    Logger.LogException(ex);

-                }

-                catch (UnauthorizedAccessException ex)

-                {

-                    StatusCode = 403;

-                    Logger.LogException(ex);

-                }

-                finally

-                {

-                    _sourceStreamEnsured = true;

-                }

-            }

-        }

+        private Stream SourceStream { get; set; }

 

         protected override bool SupportsByteRangeRequests

         {

@@ -82,7 +43,7 @@ namespace MediaBrowser.Common.Net.Handlers
             }

         }

 

-        public override bool ShouldCompressResponse(string contentType)

+        private bool ShouldCompressResponse(string contentType)

         {

             // Can't compress these

             if (IsRangeRequest)

@@ -105,29 +66,41 @@ namespace MediaBrowser.Common.Net.Handlers
             return SourceStream.Length;

         }

 

-        protected override Task<DateTime?> GetLastDateModified()

+        protected override Task<ResponseInfo> GetResponseInfo()

         {

-            DateTime? value = null;

-

-            EnsureSourceStream();

+            ResponseInfo info = new ResponseInfo

+            {

+                ContentType = MimeTypes.GetMimeType(Path),

+            };

 

-            if (SourceStream != null)

+            try

+            {

+                SourceStream = File.OpenRead(Path);

+            }

+            catch (FileNotFoundException ex)

+            {

+                info.StatusCode = 404;

+                Logger.LogException(ex);

+            }

+            catch (DirectoryNotFoundException ex)

             {

-                value = File.GetLastWriteTimeUtc(Path);

+                info.StatusCode = 404;

+                Logger.LogException(ex);

+            }

+            catch (UnauthorizedAccessException ex)

+            {

+                info.StatusCode = 403;

+                Logger.LogException(ex);

             }

 

-            return Task.FromResult(value);

-        }

+            info.CompressResponse = ShouldCompressResponse(info.ContentType);

 

-        public override Task<string> GetContentType()

-        {

-            return Task.FromResult(MimeTypes.GetMimeType(Path));

-        }

+            if (SourceStream != null)

+            {

+                info.DateLastModified = File.GetLastWriteTimeUtc(Path);

+            }

 

-        protected override Task PrepareResponse()

-        {

-            EnsureSourceStream();

-            return Task.FromResult<object>(null);

+            return Task.FromResult<ResponseInfo>(info);

         }

 

         protected override Task WriteResponseToOutputStream(Stream stream)

diff --git a/MediaBrowser.Controller/Drawing/BaseImageProcessor.cs b/MediaBrowser.Controller/Drawing/BaseImageProcessor.cs
deleted file mode 100644
index a1441cf7f..000000000
--- a/MediaBrowser.Controller/Drawing/BaseImageProcessor.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-using MediaBrowser.Controller.Entities;

-using MediaBrowser.Model.Entities;

-using System;

-using System.ComponentModel.Composition;

-using System.Drawing;

-using System.Drawing.Drawing2D;

-

-namespace MediaBrowser.Controller.Drawing

-{

-    /// <summary>

-    /// Provides a base image processor class that plugins can use to process images as they are being writen to http responses

-    /// Since this is completely modular with MEF, a plugin only needs to have a subclass in their assembly with the following attribute on the class:

-    /// [Export(typeof(BaseImageProcessor))]

-    /// This will require a reference to System.ComponentModel.Composition

-    /// </summary>

-    public abstract class BaseImageProcessor

-    {

-        /// <summary>

-        /// Processes an image for a BaseEntity

-        /// </summary>

-        /// <param name="originalImage">The original Image, before re-sizing</param>

-        /// <param name="bitmap">The bitmap holding the original image, after re-sizing</param>

-        /// <param name="graphics">The graphics surface on which the output is drawn</param>

-        /// <param name="entity">The entity that owns the image</param>

-        /// <param name="imageType">The image type</param>

-        /// <param name="imageIndex">The image index (currently only used with backdrops)</param>

-        public abstract void ProcessImage(Image originalImage, Bitmap bitmap, Graphics graphics, BaseEntity entity, ImageType imageType, int imageIndex);

-

-        /// <summary>

-        /// If true, the image output format will be forced to png, resulting in an output size that will generally run larger than jpg

-        /// If false, the original image format is preserved.

-        /// </summary>

-        public virtual bool RequiresTransparency

-        {

-            get

-            {

-                return false;

-            }

-        }

-

-        /// <summary>

-        /// Determines if the image processor is configured to process the specified entity, image type and image index

-        /// This will aid http response caching so that we don't invalidate image caches when we don't have to

-        /// </summary>

-        public abstract bool IsConfiguredToProcess(BaseEntity entity, ImageType imageType, int imageIndex);

-

-        /// <summary>

-        /// This is used for caching purposes, since a configuration change needs to invalidate a user's image cache

-        /// If the image processor is hosted within a plugin then this should be the plugin ConfigurationDateLastModified 

-        /// </summary>

-        public abstract DateTime ProcessingConfigurationDateLastModifiedUtc { get; }

-    }

-

-    /// <summary>

-    /// This is demo-ware and should be deleted eventually

-    /// </summary>

-    //[Export(typeof(BaseImageProcessor))]

-    public class MyRoundedCornerImageProcessor : BaseImageProcessor

-    {

-        public override void ProcessImage(Image originalImage, Bitmap bitmap, Graphics graphics, BaseEntity entity, ImageType imageType, int imageIndex)

-        {

-            var CornerRadius = 20;

-

-            graphics.Clear(Color.Transparent);

-

-            using (GraphicsPath gp = new GraphicsPath())

-            {

-                gp.AddArc(0, 0, CornerRadius, CornerRadius, 180, 90);

-                gp.AddArc(0 + bitmap.Width - CornerRadius, 0, CornerRadius, CornerRadius, 270, 90);

-                gp.AddArc(0 + bitmap.Width - CornerRadius, 0 + bitmap.Height - CornerRadius, CornerRadius, CornerRadius, 0, 90);

-                gp.AddArc(0, 0 + bitmap.Height - CornerRadius, CornerRadius, CornerRadius, 90, 90);

-

-                graphics.SetClip(gp);

-                graphics.DrawImage(originalImage, 0, 0, bitmap.Width, bitmap.Height);

-            }

-        }

-

-        public override bool RequiresTransparency

-        {

-            get

-            {

-                return true;

-            }

-        }

-

-        private static DateTime testDate = DateTime.UtcNow;

-

-        public override DateTime ProcessingConfigurationDateLastModifiedUtc

-        {

-            get

-            {

-                // This will result in a situation where images are only cached throughout a server session, but again, this is a prototype

-                return testDate;

-            }

-        }

-

-        public override bool IsConfiguredToProcess(BaseEntity entity, ImageType imageType, int imageIndex)

-        {

-            return true;

-        }

-    }

-}

diff --git a/MediaBrowser.Controller/Drawing/ImageProcessor.cs b/MediaBrowser.Controller/Drawing/ImageProcessor.cs
index 7ee4ef734..29e40d17d 100644
--- a/MediaBrowser.Controller/Drawing/ImageProcessor.cs
+++ b/MediaBrowser.Controller/Drawing/ImageProcessor.cs
@@ -59,17 +59,6 @@ namespace MediaBrowser.Controller.Drawing
 

             ImageFormat outputFormat = originalImage.RawFormat;

 

-            // Run Kernel image processors

-            if (Kernel.Instance.ImageProcessors.Any())

-            {

-                ExecuteAdditionalImageProcessors(originalImage, thumbnail, thumbnailGraph, entity, imageType, imageIndex);

-

-                if (Kernel.Instance.ImageProcessors.Any(i => i.RequiresTransparency))

-                {

-                    outputFormat = ImageFormat.Png;

-                }

-            }

-

             // Write to the output stream

             SaveImage(outputFormat, thumbnail, toStream, quality);

 

@@ -109,27 +98,6 @@ namespace MediaBrowser.Controller.Drawing
             return entity.PrimaryImagePath;

         }

 

-

-        /// <summary>

-        /// Executes additional image processors that are registered with the Kernel

-        /// </summary>

-        /// <param name="originalImage">The original Image, before re-sizing</param>

-        /// <param name="bitmap">The bitmap holding the original image, after re-sizing</param>

-        /// <param name="graphics">The graphics surface on which the output is drawn</param>

-        /// <param name="entity">The entity that owns the image</param>

-        /// <param name="imageType">The image type</param>

-        /// <param name="imageIndex">The image index (currently only used with backdrops)</param>

-        private static void ExecuteAdditionalImageProcessors(Image originalImage, Bitmap bitmap, Graphics graphics, BaseEntity entity, ImageType imageType, int imageIndex)

-        {

-            foreach (var processor in Kernel.Instance.ImageProcessors)

-            {

-                if (processor.IsConfiguredToProcess(entity, imageType, imageIndex))

-                {

-                    processor.ProcessImage(originalImage, bitmap, graphics, entity, imageType, imageIndex);

-                }

-            }

-        }

-

         public static void SaveImage(ImageFormat outputFormat, Image newImage, Stream toStream, int? quality)

         {

             // Use special save methods for jpeg and png that will result in a much higher quality image

diff --git a/MediaBrowser.Controller/Kernel.cs b/MediaBrowser.Controller/Kernel.cs
index 1c11b9fc8..bf03d1af1 100644
--- a/MediaBrowser.Controller/Kernel.cs
+++ b/MediaBrowser.Controller/Kernel.cs
@@ -78,12 +78,6 @@ namespace MediaBrowser.Controller
         internal IBaseItemResolver[] EntityResolvers { get; private set; }

 

         /// <summary>

-        /// Gets the list of currently registered entity resolvers

-        /// </summary>

-        [ImportMany(typeof(BaseImageProcessor))]

-        public IEnumerable<BaseImageProcessor> ImageProcessors { get; private set; }

-

-        /// <summary>

         /// Creates a kernel based on a Data path, which is akin to our current programdata path

         /// </summary>

         public Kernel()

diff --git a/MediaBrowser.Controller/MediaBrowser.Controller.csproj b/MediaBrowser.Controller/MediaBrowser.Controller.csproj
index 131825af3..fd2be689e 100644
--- a/MediaBrowser.Controller/MediaBrowser.Controller.csproj
+++ b/MediaBrowser.Controller/MediaBrowser.Controller.csproj
@@ -59,7 +59,6 @@
     <Reference Include="System.Xml" />

   </ItemGroup>

   <ItemGroup>

-    <Compile Include="Drawing\BaseImageProcessor.cs" />

     <Compile Include="Drawing\DrawingUtils.cs" />

     <Compile Include="Drawing\ImageProcessor.cs" />

     <Compile Include="Entities\Audio.cs" />