/ClientDependency.Core/CompositeFiles/CompositeDependencyHandler.cs

using System;

using System.Collections.Generic;

using System.Web;

using System.Reflection;

using System.IO;

using System.Linq;

using ClientDependency.Core.CompositeFiles.Providers;

using ClientDependency.Core.Config;

using System.Text;

using System.Web.Security;



namespace ClientDependency.Core.CompositeFiles

{

    public class CompositeDependencyHandler : IHttpHandler

    {

        private readonly static object Lock = new object();



        /// <summary>

        /// When building composite includes, it creates a Base64 encoded string of all of the combined dependency file paths

        /// for a given composite group. If this group contains too many files, then the file path with the query string will be very long.

        /// This is the maximum allowed number of characters that there is allowed, otherwise an exception is thrown.

        /// </summary>

        /// <remarks>

        /// If this handler path needs to change, it can be changed by setting it in the global.asax on application start

        /// </remarks>

        public static int MaxHandlerUrlLength = 2048;



        bool IHttpHandler.IsReusable

        {

            get

            {

                return true;

            }

        }



        void IHttpHandler.ProcessRequest(HttpContext context)

        {

            var contextBase = new HttpContextWrapper(context);

            

            ClientDependencyType type;

            string fileKey;

            int version = 0;



            if (string.IsNullOrEmpty(context.Request.PathInfo))

            {

                // querystring format

                fileKey = context.Request["s"];

                if (!string.IsNullOrEmpty(context.Request["cdv"]) && !Int32.TryParse(context.Request["cdv"], out version))

                    throw new ArgumentException("Could not parse the version in the request");

                try

                {

                    type = (ClientDependencyType)Enum.Parse(typeof(ClientDependencyType), context.Request["t"], true);

                }

                catch

                {

                    throw new ArgumentException("Could not parse the type set in the request");

                }

            }

            else

            {



                //get path to parse

                var path = context.Request.PathInfo.TrimStart('/');

                var pathFormat = ClientDependencySettings.Instance.DefaultCompositeFileProcessingProvider.PathBasedUrlFormat;

                //parse using the parser

                if (!PathBasedUrlFormatter.Parse(pathFormat, path, out fileKey, out type, out version))

                {

                    throw new FormatException("Could not parse the URL path: " + path + " with the format specified: " + pathFormat);

                }

            }



            fileKey = context.Server.UrlDecode(fileKey);



            if (string.IsNullOrEmpty(fileKey))

                throw new ArgumentException("Must specify a fileset in the request");



            byte[] outputBytes = null;



            //retry up to 5 times... this is only here due to a bug found in another website that was returning a blank 

            //result. To date, it can't be replicated in VS, but we'll leave it here for error handling support... can't hurt

            for (int i = 0; i < 5; i++)

            {

                outputBytes = ProcessRequestInternal(contextBase, fileKey, type, version, outputBytes);

                if (outputBytes != null && outputBytes.Length > 0)

                    break;



                ClientDependencySettings.Instance.Logger.Error(string.Format("No bytes were returned, this is attempt {0}. Fileset: {1}, Type: {2}, Version: {3}", i, fileKey, type, version), null);

            }



            if (outputBytes == null || outputBytes.Length == 0)

            {

                ClientDependencySettings.Instance.Logger.Fatal(string.Format("No bytes were returned after 5 attempts. Fileset: {0}, Type: {1}, Version: {2}", fileKey, type, version), null);

                List<CompositeFileDefinition> fDefs;

                outputBytes = GetCombinedFiles(contextBase, fileKey, type, out fDefs);

            }



            context.Response.ContentType = type == ClientDependencyType.Javascript ? "application/x-javascript" : "text/css";

            context.Response.OutputStream.Write(outputBytes, 0, outputBytes.Length);

        }



        internal byte[] ProcessRequestInternal(HttpContextBase context, string fileset, ClientDependencyType type, int version, byte[] outputBytes)

        {

            //get the compression type supported

            var clientCompression = context.GetClientCompression();



			var x1 = ClientDependencySettings.Instance;

			if (x1 == null) throw new Exception("x1");

			var x2 = x1.DefaultFileMapProvider;

			if (x2 == null) throw new Exception("x2");



            //get the map to the composite file for this file set, if it exists.

            var map = ClientDependencySettings.Instance.DefaultFileMapProvider.GetCompositeFile(fileset, version, clientCompression.ToString());



            string compositeFileName = "";

            if (map != null && map.HasFileBytes)

            {

                ProcessFromFile(context, map, out compositeFileName, out outputBytes);

            }

            else

            {

                lock (Lock)

                {

                    //check again...

                    if (map != null && map.HasFileBytes)

                    {

                        //there's files there now, so process them

                        ProcessFromFile(context, map, out compositeFileName, out outputBytes);

                    }

                    else

                    {

                        List<CompositeFileDefinition> fileDefinitions;

                        byte[] fileBytes;



                        if (ClientDependencySettings.Instance.DefaultCompositeFileProcessingProvider.UrlType == CompositeUrlType.MappedId)

                        {

                            //need to try to find the map by it's id/version (not compression)

                            var filePaths = ClientDependencySettings.Instance.DefaultFileMapProvider.GetDependentFiles(fileset, version);



                            if (filePaths == null)

                            {

                                throw new KeyNotFoundException("no map was found for the dependency key: " + fileset +

                                                               " ,CompositeUrlType.MappedId requires that a map is found");

                            }



                            //combine files and get the definition types of them (internal vs external resources)

                            fileBytes = ClientDependencySettings.Instance.DefaultCompositeFileProcessingProvider

                                .CombineFiles(filePaths.ToArray(), context, type, out fileDefinitions);

                        }

                        else

                        {

                            //need to do the combining, etc... and save the file map                            

                            fileBytes = GetCombinedFiles(context, fileset, type, out fileDefinitions);                           

                        }



                        //compress data                        

                        outputBytes = ClientDependencySettings.Instance.DefaultCompositeFileProcessingProvider.CompressBytes(clientCompression, fileBytes);

                        context.AddCompressionResponseHeader(clientCompression);



                        //save combined file

                        var compositeFile = ClientDependencySettings.Instance

                            .DefaultCompositeFileProcessingProvider

                            .SaveCompositeFile(outputBytes, type, context.Server);



                        if (compositeFile != null)

                        {

                            compositeFileName = compositeFile.FullName;

                            if (!string.IsNullOrEmpty(compositeFileName))

                            {

                                //Update the XML file map

                                ClientDependencySettings.Instance.DefaultFileMapProvider.CreateUpdateMap(fileset, clientCompression.ToString(),

                                    fileDefinitions.Select(x => new BasicFile(type) { FilePath = x.Uri }).Cast<IClientDependencyFile>(),

                                        compositeFileName,

                                        ClientDependencySettings.Instance.Version);

                            }

                        }

                    }

                }

            }



            SetCaching(context, compositeFileName, fileset, clientCompression);

            return outputBytes;

        }



        private byte[] GetCombinedFiles(HttpContextBase context, string fileset, ClientDependencyType type, out List<CompositeFileDefinition> fDefs)

        {

            //get the file list

            string[] filePaths = fileset.DecodeFrom64Url().Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

            //combine files and get the definition types of them (internal vs external resources)

            return ClientDependencySettings.Instance.DefaultCompositeFileProcessingProvider.CombineFiles(filePaths, context, type, out fDefs);

        }



        private void ProcessFromFile(HttpContextBase context, CompositeFileMap map, out string compositeFileName, out byte[] outputBytes)

        {

            //the saved file's bytes are already compressed.

            outputBytes = map.GetCompositeFileBytes();

            compositeFileName = map.CompositeFileName;

            CompressionType cType = (CompressionType)Enum.Parse(typeof(CompressionType), map.CompressionType);

            context.AddCompressionResponseHeader(cType);

        }



        /// <summary>

        /// Sets the output cache parameters and also the client side caching parameters

        /// </summary>

        /// <param name="context"></param>

        /// <param name="fileName">The name of the file that has been saved to disk</param>

        /// <param name="fileset">The Base64 encoded string supplied in the query string for the handler</param>

        /// <param name="compressionType"></param>

        private void SetCaching(HttpContextBase context, string fileName, string fileset, CompressionType compressionType)

        {            

            //This ensures OutputCaching is set for this handler and also controls

            //client side caching on the browser side. Default is 10 days.

            var duration = TimeSpan.FromDays(10);

            var cache = context.Response.Cache;

            cache.SetCacheability(HttpCacheability.Public);



            cache.SetExpires(DateTime.Now.Add(duration));

            cache.SetMaxAge(duration);

            cache.SetValidUntilExpires(true);

            cache.SetLastModified(DateTime.Now);



            cache.SetETag("\"" + (fileset + compressionType.ToString()).GenerateHash() + "\"");



            //set server OutputCache to vary by our params



            /* // proper way to do it is to have

             * cache.SetVaryByCustom("cdparms");

             * 

             * // then have this in global.asax

             * public override string GetVaryByCustomString(HttpContext context, string arg)

             * {

             *   if (arg == "cdparms")

             *   {

             *     if (string.IsNullOrEmpty(context.Request.PathInfo))

             *     {

             *       // querystring format

             *       return context.Request["s"] + "+" + context.Request["t"] + "+" + (context.Request["v"] ?? "0");

             *     }

             *     else

             *     {

             *	     // path format

             *	     return context.Request.PathInfo.Replace('/', '');

             *     }

             *   }

             * }

             * 

             * // that way, there would be one cache entry for both querystring and path formats.

             * // but, it requires a global.asax and I can't find a way to do without it.

             */



            // in any case, cache already varies by pathInfo (build-in) so for path formats, we do not need anything

            // just add params for querystring format, just in case...

            cache.VaryByParams["t"] = true;

            cache.VaryByParams["s"] = true;

            cache.VaryByParams["cdv"] = true;



            //ensure the cache is different based on the encoding specified per browser

            cache.VaryByContentEncodings["gzip"] = true;

            cache.VaryByContentEncodings["deflate"] = true;



            //don't allow varying by wildcard

            cache.SetOmitVaryStar(true);

            //ensure client browser maintains strict caching rules

            cache.AppendCacheExtension("must-revalidate, proxy-revalidate");



            //This is the only way to set the max-age cachability header in ASP.Net!

            //FieldInfo maxAgeField = cache.GetType().GetField("_maxAge", BindingFlags.Instance | BindingFlags.NonPublic);

            //maxAgeField.SetValue(cache, duration);



            //make this output cache dependent on the file if there is one.

            if (!string.IsNullOrEmpty(fileName))

                context.Response.AddFileDependency(fileName);

        }



    }

}