made compression and caching available to plugin api endpoints

6 files changed, 748 insertions, 566 deletions

diff --git a/MediaBrowser.Server.Implementations/HttpServer/BaseRestService.cs b/MediaBrowser.Server.Implementations/HttpServer/BaseRestService.cs
deleted file mode 100644
index ff2273750..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/BaseRestService.cs
+++ /dev/null
@@ -1,470 +0,0 @@
-using MediaBrowser.Common.Extensions;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Common.Net;
-using MediaBrowser.Model.Logging;
-using ServiceStack.Common;
-using ServiceStack.Common.Web;
-using ServiceStack.ServiceHost;
-using ServiceStack.ServiceInterface;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Net;
-using System.Threading.Tasks;
-using MimeTypes = MediaBrowser.Common.Net.MimeTypes;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    /// <summary>
-    /// Class BaseRestService
-    /// </summary>
-    public class BaseRestService : Service, IRestfulService
-    {
-        /// <summary>
-        /// Gets or sets the logger.
-        /// </summary>
-        /// <value>The logger.</value>
-        public ILogger Logger { get; set; }
-
-        /// <summary>
-        /// Gets a value indicating whether this instance is range request.
-        /// </summary>
-        /// <value><c>true</c> if this instance is range request; otherwise, <c>false</c>.</value>
-        protected bool IsRangeRequest
-        {
-            get
-            {
-                return !string.IsNullOrEmpty(RequestContext.GetHeader("Range"));
-            }
-        }
-
-        /// <summary>
-        /// To the optimized result.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="result">The result.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">result</exception>
-        protected object ToOptimizedResult<T>(T result)
-            where T : class
-        {
-            if (result == null)
-            {
-                throw new ArgumentNullException("result");
-            }
-            
-            return RequestContext.ToOptimizedResult(result);
-        }
-
-        /// <summary>
-        /// To the optimized result using cache.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
-        protected object ToOptimizedResultUsingCache<T>(Guid cacheKey, DateTime lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn)
-               where T : class
-        {
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (factoryFn == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            var key = cacheKey.ToString("N");
-
-            var result = PreProcessCachedResult(cacheKey, key, lastDateModified, cacheDuration);
-
-            if (result != null)
-            {
-                // Return null so that service stack won't do anything
-                return null;
-            }
-
-            return ToOptimizedResult(factoryFn());
-        }
-
-        /// <summary>
-        /// To the cached result.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
-        protected object ToCachedResult<T>(Guid cacheKey, DateTime lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, string contentType)
-          where T : class
-        {
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (factoryFn == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            Response.ContentType = contentType;
-            
-            var key = cacheKey.ToString("N");
-
-            var result = PreProcessCachedResult(cacheKey, key, lastDateModified, cacheDuration);
-
-            if (result != null)
-            {
-                // Return null so that service stack won't do anything
-                return null;
-            }
-
-            return factoryFn();
-        }
-
-        /// <summary>
-        /// To the static file result.
-        /// </summary>
-        /// <param name="path">The path.</param>
-        /// <param name="headersOnly">if set to <c>true</c> [headers only].</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">path</exception>
-        protected object ToStaticFileResult(string path, bool headersOnly = false)
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                throw new ArgumentNullException("path");
-            }
-
-            var dateModified = File.GetLastWriteTimeUtc(path);
-
-            var cacheKey = path + dateModified.Ticks;
-
-            return ToStaticResult(cacheKey.GetMD5(), dateModified, null, MimeTypes.GetMimeType(path), () => Task.FromResult(GetFileStream(path)), headersOnly);
-        }
-
-        /// <summary>
-        /// Gets the file stream.
-        /// </summary>
-        /// <param name="path">The path.</param>
-        /// <returns>Stream.</returns>
-        private Stream GetFileStream(string path)
-        {
-            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous);
-        }
-
-        /// <summary>
-        /// To the static result.
-        /// </summary>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <param name="headersOnly">if set to <c>true</c> [headers only].</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
-        protected object ToStaticResult(Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType, Func<Task<Stream>> factoryFn, bool headersOnly = false)
-        {
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (factoryFn == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            var key = cacheKey.ToString("N");
-
-            Response.ContentType = contentType;
-            
-            var result = PreProcessCachedResult(cacheKey, key, lastDateModified, cacheDuration);
-
-            if (result != null)
-            {
-                // Return null so that service stack won't do anything
-                return null;
-            }
-
-            var compress = ShouldCompressResponse(contentType);
-
-            return ToStaticResult(contentType, factoryFn, compress, headersOnly).Result;
-        }
-
-        /// <summary>
-        /// Shoulds the compress response.
-        /// </summary>
-        /// <param name="contentType">Type of the content.</param>
-        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
-        private bool ShouldCompressResponse(string contentType)
-        {
-            // It will take some work to support compression with byte range requests
-            if (IsRangeRequest)
-            {
-                return false;
-            }
-
-            // Don't compress media
-            if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            // Don't compress images
-            if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            if (contentType.StartsWith("font/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-            if (contentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// To the static result.
-        /// </summary>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <param name="compress">if set to <c>true</c> [compress].</param>
-        /// <param name="headersOnly">if set to <c>true</c> [headers only].</param>
-        /// <returns>System.Object.</returns>
-        private async Task<object> ToStaticResult(string contentType, Func<Task<Stream>> factoryFn, bool compress, bool headersOnly = false)
-        {
-            if (!compress || string.IsNullOrEmpty(RequestContext.CompressionType))
-            {
-                Response.ContentType = contentType;
-
-                var stream = await factoryFn().ConfigureAwait(false);
-
-                var httpListenerResponse = (HttpListenerResponse) Response.OriginalResponse;
-                httpListenerResponse.SendChunked = false;
-
-                if (IsRangeRequest)
-                {
-                    return new RangeRequestWriter(RequestContext.GetHeader("Range"), httpListenerResponse, stream, headersOnly);
-                }
-             
-                httpListenerResponse.ContentLength64 = stream.Length;
-                return headersOnly ? null : new StreamWriter(stream, Logger);
-            }
-
-            if (headersOnly)
-            {
-                return null;
-            }
-
-            string content;
-
-            using (var stream = await factoryFn().ConfigureAwait(false))
-            {
-                using (var reader = new StreamReader(stream))
-                {
-                    content = await reader.ReadToEndAsync().ConfigureAwait(false);
-                }
-            }
-
-            var contents = content.Compress(RequestContext.CompressionType);
-
-            return new CompressedResult(contents, RequestContext.CompressionType, contentType);
-        }
-
-        /// <summary>
-        /// Pres the process optimized result.
-        /// </summary>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="cacheKeyString">The cache key string.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <returns>System.Object.</returns>
-        private object PreProcessCachedResult(Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration)
-        {
-            Response.AddHeader("ETag", cacheKeyString);
-
-            if (IsNotModified(cacheKey, lastDateModified, cacheDuration))
-            {
-                AddAgeHeader(lastDateModified);
-                AddExpiresHeader(cacheKeyString, cacheDuration);
-                //ctx.Response.SendChunked = false;
-
-                Response.StatusCode = 304;
-
-                return new byte[]{};
-            }
-
-            SetCachingHeaders(cacheKeyString, lastDateModified, cacheDuration);
-
-            return null;
-        }
-
-        /// <summary>
-        /// Determines whether [is not modified] [the specified cache key].
-        /// </summary>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <returns><c>true</c> if [is not modified] [the specified cache key]; otherwise, <c>false</c>.</returns>
-        private bool IsNotModified(Guid? cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
-        {
-            var isNotModified = true;
-
-            var ifModifiedSinceHeader = RequestContext.GetHeader("If-Modified-Since");
-
-            if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
-            {
-                DateTime ifModifiedSince;
-
-                if (DateTime.TryParse(ifModifiedSinceHeader, out ifModifiedSince))
-                {
-                    isNotModified = IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified);
-                }
-            }
-
-            var ifNoneMatchHeader = RequestContext.GetHeader("If-None-Match");
-            
-            // Validate If-None-Match
-            if (isNotModified && (cacheKey.HasValue || !string.IsNullOrEmpty(ifNoneMatchHeader)))
-            {
-                Guid ifNoneMatch;
-
-                if (Guid.TryParse(ifNoneMatchHeader ?? string.Empty, out ifNoneMatch))
-                {
-                    if (cacheKey.HasValue && cacheKey.Value == ifNoneMatch)
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Determines whether [is not modified] [the specified if modified since].
-        /// </summary>
-        /// <param name="ifModifiedSince">If modified since.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="dateModified">The date modified.</param>
-        /// <returns><c>true</c> if [is not modified] [the specified if modified since]; otherwise, <c>false</c>.</returns>
-        private bool IsNotModified(DateTime ifModifiedSince, TimeSpan? cacheDuration, DateTime? dateModified)
-        {
-            if (dateModified.HasValue)
-            {
-                var lastModified = NormalizeDateForComparison(dateModified.Value);
-                ifModifiedSince = NormalizeDateForComparison(ifModifiedSince);
-
-                return lastModified <= ifModifiedSince;
-            }
-
-            if (cacheDuration.HasValue)
-            {
-                var cacheExpirationDate = ifModifiedSince.Add(cacheDuration.Value);
-
-                if (DateTime.UtcNow < cacheExpirationDate)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-
-        /// <summary>
-        /// When the browser sends the IfModifiedDate, it's precision is limited to seconds, so this will account for that
-        /// </summary>
-        /// <param name="date">The date.</param>
-        /// <returns>DateTime.</returns>
-        private DateTime NormalizeDateForComparison(DateTime date)
-        {
-            return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
-        }
-
-        /// <summary>
-        /// Sets the caching headers.
-        /// </summary>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        private void SetCachingHeaders(string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
-        {
-            // Don't specify both last modified and Etag, unless caching unconditionally. They are redundant
-            // https://developers.google.com/speed/docs/best-practices/caching#LeverageBrowserCaching
-            if (lastDateModified.HasValue && (string.IsNullOrEmpty(cacheKey) || cacheDuration.HasValue))
-            {
-                AddAgeHeader(lastDateModified);
-                Response.AddHeader("LastModified", lastDateModified.Value.ToString("r"));
-            }
-
-            if (cacheDuration.HasValue)
-            {
-                Response.AddHeader("Cache-Control", "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds));
-            }
-            else if (!string.IsNullOrEmpty(cacheKey))
-            {
-                Response.AddHeader("Cache-Control", "public");
-            }
-            else
-            {
-                Response.AddHeader("Cache-Control", "no-cache, no-store, must-revalidate");
-                Response.AddHeader("pragma", "no-cache, no-store, must-revalidate");
-            }
-
-            AddExpiresHeader(cacheKey, cacheDuration);
-        }
-
-        /// <summary>
-        /// Adds the expires header.
-        /// </summary>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        private void AddExpiresHeader(string cacheKey, TimeSpan? cacheDuration)
-        {
-            if (cacheDuration.HasValue)
-            {
-                Response.AddHeader("Expires", DateTime.UtcNow.Add(cacheDuration.Value).ToString("r"));
-            }
-            else if (string.IsNullOrEmpty(cacheKey))
-            {
-                Response.AddHeader("Expires", "-1");
-            }
-        }
-
-        /// <summary>
-        /// Adds the age header.
-        /// </summary>
-        /// <param name="lastDateModified">The last date modified.</param>
-        private void AddAgeHeader(DateTime? lastDateModified)
-        {
-            if (lastDateModified.HasValue)
-            {
-                Response.AddHeader("Age", Convert.ToInt64((DateTime.UtcNow - lastDateModified.Value).TotalSeconds).ToString(CultureInfo.InvariantCulture));
-            }
-        }
-
-        /// <summary>
-        /// Gets the routes.
-        /// </summary>
-        /// <returns>IEnumerable{RouteInfo}.</returns>
-        public virtual IEnumerable<RouteInfo> GetRoutes()
-        {
-            return new RouteInfo[] {};
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
index 2dd968988..78b883d34 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
@@ -1,14 +1,589 @@
-using MediaBrowser.Common.Net;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Model.Logging;
+using ServiceStack.Common;
 using ServiceStack.Common.Web;
+using ServiceStack.ServiceHost;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+using MimeTypes = MediaBrowser.Common.Net.MimeTypes;
 
 namespace MediaBrowser.Server.Implementations.HttpServer
 {
+    /// <summary>
+    /// Class HttpResultFactory
+    /// </summary>
     public class HttpResultFactory : IHttpResultFactory
     {
-        public object GetResult(Stream stream, string contentType)
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HttpResultFactory"/> class.
+        /// </summary>
+        /// <param name="logManager">The log manager.</param>
+        public HttpResultFactory(ILogManager logManager)
+        {
+            _logger = logManager.GetLogger("HttpResultFactory");
+        }
+
+        /// <summary>
+        /// Gets the result.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        public object GetResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
+        {
+            var result = new HttpResult(content, contentType);
+
+            if (responseHeaders != null)
+            {
+                AddResponseHeaders(result, responseHeaders);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the optimized result.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="result">The result.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">result</exception>
+        public object GetOptimizedResult<T>(IRequestContext requestContext, T result, IDictionary<string, string> responseHeaders = null)
+            where T : class
+        {
+            if (result == null)
+            {
+                throw new ArgumentNullException("result");
+            }
+
+            var optimizedResult = requestContext.ToOptimizedResult(result);
+
+            if (responseHeaders != null)
+            {
+                // Apply headers
+                var hasOptions = optimizedResult as IHasOptions;
+
+                if (hasOptions != null)
+                {
+                    AddResponseHeaders(hasOptions, responseHeaders);
+                }
+            }
+
+            return optimizedResult;
+        }
+
+        /// <summary>
+        /// Gets the optimized result using cache.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// cacheKey
+        /// or
+        /// factoryFn
+        /// </exception>
+        public object GetOptimizedResultUsingCache<T>(IRequestContext requestContext, Guid cacheKey, DateTime lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, IDictionary<string, string> responseHeaders = null)
+               where T : class
+        {
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (factoryFn == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>();
+            }
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, null);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            return GetOptimizedResult(requestContext, factoryFn(), responseHeaders);
+        }
+
+        /// <summary>
+        /// To the cached result.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
+        public object GetCachedResult<T>(IRequestContext requestContext, Guid cacheKey, DateTime lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, string contentType, IDictionary<string, string> responseHeaders = null)
+          where T : class
+        {
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (factoryFn == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>();
+            }
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, contentType);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            result = factoryFn();
+
+            // Apply caching headers
+            var hasOptions = result as IHasOptions;
+
+            if (hasOptions != null)
+            {
+                AddResponseHeaders(hasOptions, responseHeaders);
+                return hasOptions;
+            }
+
+            // Otherwise wrap into an HttpResult
+            var httpResult = new HttpResult(result, contentType ?? "text/html", HttpStatusCode.NotModified);
+
+            AddResponseHeaders(httpResult, responseHeaders);
+
+            return httpResult;
+        }
+
+        /// <summary>
+        /// Pres the process optimized result.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="cacheKeyString">The cache key string.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <returns>System.Object.</returns>
+        private object GetCachedResult(IRequestContext requestContext, IDictionary<string, string> responseHeaders, Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType)
+        {
+            responseHeaders["ETag"] = cacheKeyString;
+
+            if (IsNotModified(requestContext, cacheKey, lastDateModified, cacheDuration))
+            {
+                AddAgeHeader(responseHeaders, lastDateModified);
+                AddExpiresHeader(responseHeaders, cacheKeyString, cacheDuration);
+
+                var result = new HttpResult(new byte[] { }, contentType ?? "text/html", HttpStatusCode.NotModified);
+
+                AddResponseHeaders(result, responseHeaders);
+
+                return result;
+            }
+
+            AddCachingHeaders(responseHeaders, cacheKeyString, lastDateModified, cacheDuration);
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the static file result.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">path</exception>
+        public object GetStaticFileResult(IRequestContext requestContext, string path, IDictionary<string, string> responseHeaders = null, bool isHeadRequest = false)
         {
-            return new HttpResult(stream, contentType);
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            var dateModified = File.GetLastWriteTimeUtc(path);
+
+            var cacheKey = path + dateModified.Ticks;
+
+            return GetStaticResult(requestContext, cacheKey.GetMD5(), dateModified, null, MimeTypes.GetMimeType(path), () => Task.FromResult(GetFileStream(path)), responseHeaders, isHeadRequest);
+        }
+
+        /// <summary>
+        /// Gets the file stream.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>Stream.</returns>
+        private Stream GetFileStream(string path)
+        {
+            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous);
+        }
+
+        /// <summary>
+        /// Gets the static result.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">cacheKey
+        /// or
+        /// factoryFn</exception>
+        public object GetStaticResult(IRequestContext requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType, Func<Task<Stream>> factoryFn, IDictionary<string, string> responseHeaders = null, bool isHeadRequest = false)
+        {
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (factoryFn == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>();
+            }
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, contentType);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            var compress = ShouldCompressResponse(requestContext, contentType);
+
+            var hasOptions = GetStaticResult(requestContext, responseHeaders, contentType, factoryFn, compress, isHeadRequest).Result;
+
+            AddResponseHeaders(hasOptions, responseHeaders);
+
+            return hasOptions;
+        }
+
+        /// <summary>
+        /// Shoulds the compress response.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        private bool ShouldCompressResponse(IRequestContext requestContext, string contentType)
+        {
+            // It will take some work to support compression with byte range requests
+            if (!string.IsNullOrEmpty(requestContext.GetHeader("Range")))
+            {
+                return false;
+            }
+
+            // Don't compress media
+            if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            // Don't compress images
+            if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            if (contentType.StartsWith("font/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+            if (contentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        /// <summary>
+        /// Gets the static result.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="compress">if set to <c>true</c> [compress].</param>
+        /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
+        /// <returns>Task{IHasOptions}.</returns>
+        private async Task<IHasOptions> GetStaticResult(IRequestContext requestContext, IDictionary<string, string> responseHeaders, string contentType, Func<Task<Stream>> factoryFn, bool compress, bool isHeadRequest)
+        {
+            if (!compress || string.IsNullOrEmpty(requestContext.CompressionType))
+            {
+                var stream = await factoryFn().ConfigureAwait(false);
+
+                var rangeHeader = requestContext.GetHeader("Range");
+
+                if (!string.IsNullOrEmpty(rangeHeader))
+                {
+                    return new RangeRequestWriter(rangeHeader, stream, contentType, isHeadRequest);
+                }
+
+                responseHeaders["Content-Length"] = stream.Length.ToString(UsCulture);
+
+                if (isHeadRequest)
+                {
+                    return new HttpResult(new byte[] { }, contentType);
+                }
+
+                return new StreamWriter(stream, contentType, _logger);
+            }
+
+            if (isHeadRequest)
+            {
+                return new HttpResult(new byte[] { }, contentType);
+            }
+
+            string content;
+
+            using (var stream = await factoryFn().ConfigureAwait(false))
+            {
+                using (var reader = new StreamReader(stream))
+                {
+                    content = await reader.ReadToEndAsync().ConfigureAwait(false);
+                }
+            }
+
+            var contents = content.Compress(requestContext.CompressionType);
+
+            return new CompressedResult(contents, requestContext.CompressionType, contentType);
+        }
+
+        /// <summary>
+        /// Adds the caching responseHeaders.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        private void AddCachingHeaders(IDictionary<string, string> responseHeaders, string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
+        {
+            // Don't specify both last modified and Etag, unless caching unconditionally. They are redundant
+            // https://developers.google.com/speed/docs/best-practices/caching#LeverageBrowserCaching
+            if (lastDateModified.HasValue && (string.IsNullOrEmpty(cacheKey) || cacheDuration.HasValue))
+            {
+                AddAgeHeader(responseHeaders, lastDateModified);
+                responseHeaders["LastModified"] = lastDateModified.Value.ToString("r");
+            }
+
+            if (cacheDuration.HasValue)
+            {
+                responseHeaders["Cache-Control"] = "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds);
+            }
+            else if (!string.IsNullOrEmpty(cacheKey))
+            {
+                responseHeaders["Cache-Control"] = "public";
+            }
+            else
+            {
+                responseHeaders["Cache-Control"] = "no-cache, no-store, must-revalidate";
+                responseHeaders["pragma"] = "no-cache, no-store, must-revalidate";
+            }
+
+            AddExpiresHeader(responseHeaders, cacheKey, cacheDuration);
+        }
+
+        /// <summary>
+        /// Adds the expires header.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        private void AddExpiresHeader(IDictionary<string, string> responseHeaders, string cacheKey, TimeSpan? cacheDuration)
+        {
+            if (cacheDuration.HasValue)
+            {
+                responseHeaders["Expires"] = DateTime.UtcNow.Add(cacheDuration.Value).ToString("r");
+            }
+            else if (string.IsNullOrEmpty(cacheKey))
+            {
+                responseHeaders["Expires"] = "-1";
+            }
+        }
+
+        /// <summary>
+        /// Adds the age header.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        private void AddAgeHeader(IDictionary<string, string> responseHeaders, DateTime? lastDateModified)
+        {
+            if (lastDateModified.HasValue)
+            {
+                responseHeaders["Age"] = Convert.ToInt64((DateTime.UtcNow - lastDateModified.Value).TotalSeconds).ToString(CultureInfo.InvariantCulture);
+            }
+        }
+        /// <summary>
+        /// Determines whether [is not modified] [the specified cache key].
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <returns><c>true</c> if [is not modified] [the specified cache key]; otherwise, <c>false</c>.</returns>
+        private bool IsNotModified(IRequestContext requestContext, Guid? cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
+        {
+            var isNotModified = true;
+
+            var ifModifiedSinceHeader = requestContext.GetHeader("If-Modified-Since");
+
+            if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
+            {
+                DateTime ifModifiedSince;
+
+                if (DateTime.TryParse(ifModifiedSinceHeader, out ifModifiedSince))
+                {
+                    isNotModified = IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified);
+                }
+            }
+
+            var ifNoneMatchHeader = requestContext.GetHeader("If-None-Match");
+
+            // Validate If-None-Match
+            if (isNotModified && (cacheKey.HasValue || !string.IsNullOrEmpty(ifNoneMatchHeader)))
+            {
+                Guid ifNoneMatch;
+
+                if (Guid.TryParse(ifNoneMatchHeader ?? string.Empty, out ifNoneMatch))
+                {
+                    if (cacheKey.HasValue && cacheKey.Value == ifNoneMatch)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether [is not modified] [the specified if modified since].
+        /// </summary>
+        /// <param name="ifModifiedSince">If modified since.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="dateModified">The date modified.</param>
+        /// <returns><c>true</c> if [is not modified] [the specified if modified since]; otherwise, <c>false</c>.</returns>
+        private bool IsNotModified(DateTime ifModifiedSince, TimeSpan? cacheDuration, DateTime? dateModified)
+        {
+            if (dateModified.HasValue)
+            {
+                var lastModified = NormalizeDateForComparison(dateModified.Value);
+                ifModifiedSince = NormalizeDateForComparison(ifModifiedSince);
+
+                return lastModified <= ifModifiedSince;
+            }
+
+            if (cacheDuration.HasValue)
+            {
+                var cacheExpirationDate = ifModifiedSince.Add(cacheDuration.Value);
+
+                if (DateTime.UtcNow < cacheExpirationDate)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        /// <summary>
+        /// When the browser sends the IfModifiedDate, it's precision is limited to seconds, so this will account for that
+        /// </summary>
+        /// <param name="date">The date.</param>
+        /// <returns>DateTime.</returns>
+        private DateTime NormalizeDateForComparison(DateTime date)
+        {
+            return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
+        }
+
+        /// <summary>
+        /// Adds the response headers.
+        /// </summary>
+        /// <param name="hasOptions">The has options.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        private void AddResponseHeaders(IHasOptions hasOptions, IDictionary<string, string> responseHeaders)
+        {
+            foreach (var item in responseHeaders)
+            {
+                hasOptions.Options[item.Key] = item.Value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the error result.
+        /// </summary>
+        /// <param name="statusCode">The status code.</param>
+        /// <param name="errorMessage">The error message.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        public void ThrowError(int statusCode, string errorMessage, IDictionary<string, string> responseHeaders = null)
+        {
+            var error = new HttpError
+            {
+                Status = statusCode,
+                ErrorCode = errorMessage
+            };
+
+            if (responseHeaders != null)
+            {
+                AddResponseHeaders(error, responseHeaders);
+            }
+
+            throw error;
         }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpServer.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpServer.cs
index 79663dca9..d22605cb3 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpServer.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/HttpServer.cs
@@ -174,6 +174,30 @@ namespace MediaBrowser.Server.Implementations.HttpServer
                         // This is a good choice for applications that are singly homed and depend on public proxies for user locality.                        
                         res.AddHeader("Vary", "Accept-Encoding");
                     }
+
+                    var hasOptions = dto as IHasOptions;
+
+                    if (hasOptions != null)
+                    {
+                        // Content length has to be explicitly set on on HttpListenerResponse or it won't be happy
+                        string contentLength;
+
+                        if (hasOptions.Options.TryGetValue("Content-Length", out contentLength) && !string.IsNullOrEmpty(contentLength))
+                        {
+                            var length = long.Parse(contentLength);
+
+                            if (length > 0)
+                            {
+                                var response = (HttpListenerResponse) res.OriginalResponse;
+
+                                response.ContentLength64 = length;
+
+                                // Disable chunked encoding. Technically this is only needed when using Content-Range, but
+                                // anytime we know the content length there's no need for it
+                                response.SendChunked = false;
+                            }
+                        }
+                    }
                 });
         }
 
@@ -532,11 +556,6 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
             EndpointHost.ConfigureHost(this, ServerName, CreateServiceManager());
             ContentTypeFilters.Register(ContentType.ProtoBuf, (reqCtx, res, stream) => ProtobufSerializer.SerializeToStream(res, stream), (type, stream) => ProtobufSerializer.DeserializeFromStream(stream, type));
-            
-            foreach (var route in services.SelectMany(i => i.GetRoutes()))
-            {
-                Routes.Add(route.RequestType, route.Path, route.Verbs);
-            }
 
             Init();
         }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs b/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
index b61e05d0b..a355a2db5 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
@@ -1,6 +1,8 @@
 using ServiceStack.Service;
+using ServiceStack.ServiceHost;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -8,30 +10,105 @@ using System.Threading.Tasks;
 
 namespace MediaBrowser.Server.Implementations.HttpServer
 {
-    public class RangeRequestWriter : IStreamWriter
+    public class RangeRequestWriter : IStreamWriter, IHttpResult
     {
         /// <summary>
         /// Gets or sets the source stream.
         /// </summary>
         /// <value>The source stream.</value>
         private Stream SourceStream { get; set; }
-        private HttpListenerResponse Response { get; set; }
         private string RangeHeader { get; set; }
         private bool IsHeadRequest { get; set; }
 
+        private long RangeStart { get; set; }
+        private long RangeEnd { get; set; }
+        private long RangeLength { get; set; }
+        private long TotalContentLength { get; set; }
+
+        /// <summary>
+        /// The _options
+        /// </summary>
+        private readonly Dictionary<string, string> _options = new Dictionary<string, string>();
+
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        /// <summary>
+        /// Additional HTTP Headers
+        /// </summary>
+        /// <value>The headers.</value>
+        public Dictionary<string, string> Headers
+        {
+            get { return _options; }
+        }
+
+        /// <summary>
+        /// Gets the options.
+        /// </summary>
+        /// <value>The options.</value>
+        public IDictionary<string, string> Options
+        {
+            get { return Headers; }
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="StreamWriter" /> class.
         /// </summary>
         /// <param name="rangeHeader">The range header.</param>
-        /// <param name="response">The response.</param>
         /// <param name="source">The source.</param>
+        /// <param name="contentType">Type of the content.</param>
         /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
-        public RangeRequestWriter(string rangeHeader, HttpListenerResponse response, Stream source, bool isHeadRequest)
+        public RangeRequestWriter(string rangeHeader, Stream source, string contentType, bool isHeadRequest)
         {
+            if (string.IsNullOrEmpty(contentType))
+            {
+                throw new ArgumentNullException("contentType");
+            }
+            
             RangeHeader = rangeHeader;
-            Response = response;
             SourceStream = source;
             IsHeadRequest = isHeadRequest;
+
+            ContentType = contentType;
+            Options["Content-Type"] = contentType;
+            Options["Accept-Ranges"] = "bytes";
+            StatusCode = HttpStatusCode.PartialContent;
+
+            SetRangeValues();
+        }
+
+        /// <summary>
+        /// Sets the range values.
+        /// </summary>
+        private void SetRangeValues()
+        {
+            var requestedRange = RequestedRanges.First();
+
+            TotalContentLength = SourceStream.Length;
+
+            // If the requested range is "0-", we can optimize by just doing a stream copy
+            if (!requestedRange.Value.HasValue)
+            {
+                RangeEnd = TotalContentLength - 1;
+            }
+            else
+            {
+                RangeEnd = requestedRange.Value.Value;
+            }
+
+            RangeStart = requestedRange.Key;
+            RangeLength = 1 + RangeEnd - RangeStart;
+            
+            // Content-Length is the length of what we're serving, not the original content
+            Options["Content-Length"] = RangeLength.ToString(UsCulture);
+            Options["Content-Range"] = string.Format("bytes {0}-{1}/{2}", RangeStart, RangeEnd, TotalContentLength);
+            
+            if (RangeStart > 0)
+            {
+                SourceStream.Position = RangeStart;
+            }
         }
 
         /// <summary>
@@ -42,7 +119,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         /// Gets the requested ranges.
         /// </summary>
         /// <value>The requested ranges.</value>
-        protected IEnumerable<KeyValuePair<long, long?>> RequestedRanges
+        protected List<KeyValuePair<long, long?>> RequestedRanges
         {
             get
             {
@@ -83,9 +160,6 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         /// <param name="responseStream">The response stream.</param>
         public void WriteTo(Stream responseStream)
         {
-            Response.Headers["Accept-Ranges"] = "bytes";
-            Response.StatusCode = 206;
-            
             var task = WriteToAsync(responseStream);
 
             Task.WaitAll(task);
@@ -98,94 +172,46 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         /// <returns>Task.</returns>
         private async Task WriteToAsync(Stream responseStream)
         {
-            using (var source = SourceStream)
+            // Headers only
+            if (IsHeadRequest)
             {
-                var requestedRange = RequestedRanges.First();
-
-                var totalLength = SourceStream.Length;
+                return;
+            }
 
+            using (var source = SourceStream)
+            {
                 // If the requested range is "0-", we can optimize by just doing a stream copy
-                if (!requestedRange.Value.HasValue)
+                if (RangeEnd == TotalContentLength - 1)
                 {
-                    await ServeCompleteRangeRequest(source, requestedRange, responseStream, totalLength).ConfigureAwait(false);
+                    await source.CopyToAsync(responseStream).ConfigureAwait(false);
                 }
+                else
+                {
+                    // Read the bytes we need
+                    var buffer = new byte[Convert.ToInt32(RangeLength)];
+                    await source.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
 
-                // This will have to buffer a portion of the content into memory
-                await ServePartialRangeRequest(source, requestedRange.Key, requestedRange.Value.Value, responseStream, totalLength).ConfigureAwait(false);
+                    await responseStream.WriteAsync(buffer, 0, Convert.ToInt32(RangeLength)).ConfigureAwait(false);
+                }
             }
         }
 
-        /// <summary>
-        /// Handles a range request of "bytes=0-"
-        /// This will serve the complete content and add the content-range header
-        /// </summary>
-        /// <param name="sourceStream">The source stream.</param>
-        /// <param name="requestedRange">The requested range.</param>
-        /// <param name="responseStream">The response stream.</param>
-        /// <param name="totalContentLength">Total length of the content.</param>
-        /// <returns>Task.</returns>
-        private Task ServeCompleteRangeRequest(Stream sourceStream, KeyValuePair<long, long?> requestedRange, Stream responseStream, long totalContentLength)
-        {
-            var rangeStart = requestedRange.Key;
-            var rangeEnd = totalContentLength - 1;
-            var rangeLength = 1 + rangeEnd - rangeStart;
+        public string ContentType { get; set; }
 
-            // Content-Length is the length of what we're serving, not the original content
-            Response.ContentLength64 = rangeLength;
-            Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
+        public IRequestContext RequestContext { get; set; }
 
-            // Headers only
-            if (IsHeadRequest)
-            {
-                return Task.FromResult(true);
-            }
+        public object Response { get; set; }
 
-            if (rangeStart > 0)
-            {
-                sourceStream.Position = rangeStart;
-            }
+        public IContentTypeWriter ResponseFilter { get; set; }
 
-            return sourceStream.CopyToAsync(responseStream);
-        }
+        public int Status { get; set; }
 
-        /// <summary>
-        /// Serves a partial range request
-        /// </summary>
-        /// <param name="sourceStream">The source stream.</param>
-        /// <param name="rangeStart">The range start.</param>
-        /// <param name="rangeEnd">The range end.</param>
-        /// <param name="responseStream">The response stream.</param>
-        /// <param name="totalContentLength">Total length of the content.</param>
-        /// <returns>Task.</returns>
-        private async Task ServePartialRangeRequest(Stream sourceStream, long rangeStart, long rangeEnd, Stream responseStream, long totalContentLength)
+        public HttpStatusCode StatusCode
         {
-            var rangeLength = 1 + rangeEnd - rangeStart;
-
-            // Content-Length is the length of what we're serving, not the original content
-            Response.ContentLength64 = rangeLength;
-            Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
-
-            // Headers only
-            if (IsHeadRequest)
-            {
-                return;
-            }
-
-            sourceStream.Position = rangeStart;
-
-            // Fast track to just copy the stream to the end
-            if (rangeEnd == totalContentLength - 1)
-            {
-                await sourceStream.CopyToAsync(responseStream).ConfigureAwait(false);
-            }
-            else
-            {
-                // Read the bytes we need
-                var buffer = new byte[Convert.ToInt32(rangeLength)];
-                await sourceStream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
-
-                await responseStream.WriteAsync(buffer, 0, Convert.ToInt32(rangeLength)).ConfigureAwait(false);
-            }
+            get { return (HttpStatusCode)Status; }
+            set { Status = (int)value; }
         }
+
+        public string StatusDescription { get; set; }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/StreamWriter.cs b/MediaBrowser.Server.Implementations/HttpServer/StreamWriter.cs
index 6f5d6e25f..da84a51cd 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/StreamWriter.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/StreamWriter.cs
@@ -1,6 +1,8 @@
 using MediaBrowser.Model.Logging;
 using ServiceStack.Service;
+using ServiceStack.ServiceHost;
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 
@@ -9,7 +11,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer
     /// <summary>
     /// Class StreamWriter
     /// </summary>
-    public class StreamWriter : IStreamWriter
+    public class StreamWriter : IStreamWriter, IHasOptions
     {
         private ILogger Logger { get; set; }
         
@@ -20,14 +22,35 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         public Stream SourceStream { get; set; }
 
         /// <summary>
+        /// The _options
+        /// </summary>
+        private readonly IDictionary<string, string> _options = new Dictionary<string, string>();
+        /// <summary>
+        /// Gets the options.
+        /// </summary>
+        /// <value>The options.</value>
+        public IDictionary<string, string> Options
+        {
+            get { return _options; }
+        }
+
+        /// <summary>
         /// Initializes a new instance of the <see cref="StreamWriter" /> class.
         /// </summary>
         /// <param name="source">The source.</param>
+        /// <param name="contentType">Type of the content.</param>
         /// <param name="logger">The logger.</param>
-        public StreamWriter(Stream source, ILogger logger)
+        public StreamWriter(Stream source, string contentType, ILogger logger)
         {
+            if (string.IsNullOrEmpty(contentType))
+            {
+                throw new ArgumentNullException("contentType");
+            }
+
             SourceStream = source;
             Logger = logger;
+
+            Options["Content-Type"] = contentType;
         }
 
         /// <summary>
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SwaggerService.cs b/MediaBrowser.Server.Implementations/HttpServer/SwaggerService.cs
index 18ab40d93..8772176a0 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/SwaggerService.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/SwaggerService.cs
@@ -1,4 +1,5 @@
-using ServiceStack.ServiceHost;
+using MediaBrowser.Common.Net;
+using ServiceStack.ServiceHost;
 using System.Diagnostics;
 using System.IO;
 
@@ -16,9 +17,11 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         /// <value>The name.</value>
         public string ResourceName { get; set; }
     }
-    
-    public class SwaggerService : BaseRestService
+
+    public class SwaggerService : IRequiresRequestContext, IRestfulService
     {
+        public IHttpResultFactory HttpResultFactory { get; set; }
+        
         /// <summary>
         /// Gets the specified request.
         /// </summary>
@@ -32,7 +35,13 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
             var requestedFile = Path.Combine(swaggerDirectory, request.ResourceName.Replace('/', '\\'));
 
-            return ToStaticFileResult(requestedFile);
+            return HttpResultFactory.GetStaticFileResult(RequestContext, requestedFile);
         }
+
+        /// <summary>
+        /// Gets or sets the request context.
+        /// </summary>
+        /// <value>The request context.</value>
+        public IRequestContext RequestContext { get; set; }
     }
 }