Example #1
0
        /// <summary>
        /// Excute the request and response the needes content
        /// <para>Save the response in the Output cach for next requests</para>
        /// </summary>
        /// <param name="context"></param>
        /// <param name="absoluteFiles"></param>
        /// <param name="minify"></param>
        /// <param name="versionHash"></param>
        /// <param name="encodingMgr"></param>
        public void Excute(HttpContext context, string[] absoluteFiles, Minifier minify, int versionHash, EncodingManager encodingMgr)
        {
            context.Response.Write(SR.GetString(SR.CREDIT_STRING));

            List<string> exsitingFiles = new List<string>();
            for (int i = 0; i < absoluteFiles.Length; i++)
            {
                WriteContent(context, GetFileContent(absoluteFiles[i], minify, exsitingFiles));
            }
            SetResponseCacheSettings(context, exsitingFiles.ToArray());
            if (encodingMgr.IsEncodingEnabled)
            {
                encodingMgr.CompressResponse();
                encodingMgr.SetResponseEncodingType();
            }
        }
Example #2
0
        /// <summary>
        /// Process the request
        /// </summary>
        /// <param name="context"></param>
        public virtual void ProcessRequest(HttpContext context)
        {
            int versionHash;
            DateTime lastUpdate;
            string[] relativeFiles = context.Request.QueryString["d"].Split(',');
            string[] absoluteFiles = GetFilesInfo(relativeFiles,context, out versionHash,out lastUpdate);

            context.Response.Clear();
            SetHeaders(context, lastUpdate, versionHash);

            CheckETag(context, versionHash);

            Minifier currentMinifier = new Minifier(Minify);
            EncodingManager encodingMgr = new EncodingManager(context);
            if (!IsCompressContent())
            {
                encodingMgr.PreferredEncodingType = EncodingManager.EncodingType.None;
            }
            Settings.Instance.CurrentStorage.Excute(context, absoluteFiles, currentMinifier, versionHash, encodingMgr);
        }
Example #3
0
        /// <summary>
        /// Handles the PostReleaseRequestState event.
        /// </summary>
        /// <param name="sender">The object that raised the event (HttpApplication)</param>
        /// <param name="e">The event data</param>
        void OnPostReleaseRequestState(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;

            if (app.Context == null)
                return;

            // This part of the module compress only handlers from type System.Web.UI.Page
            // Other types such JavaScript or CSS files will be compressed in an httpHandelr.
            // Here we check if the current handler if a Page, if so, we compress it.
            if (app.Context.CurrentHandler is System.Web.UI.Page && app.Context.Response != null && Util.IsUIPageContentType(app.Context.Response.ContentType))
            {
                // Check if the path is not excluded.
                if (!settings.IsValidPath(app.Request.AppRelativeCurrentExecutionFilePath))
                    return;

                // Check if the mime type is not ecluded. (Use to exclude pages that generate specific mime type (such image or Excel...))
                if (!settings.IsValidType(app.Response.ContentType))
                    return;

                // Because there is a problem with async postbacks compression, we check here if the current request if an 'MS AJAX' call.
                // If so, we will not compress it.
                if (settings.CompressPage && !(Util.IsMsAjaxRequest(app.Context) && settings.MSAjaxVersion < 3.5))
                {
                    EncodingManager encodingMgr = new EncodingManager(app.Context);

                    if (encodingMgr.IsEncodingEnabled)
                    {
                        encodingMgr.CompressResponse();
                        encodingMgr.SetResponseEncodingType();
                    }
                }

                if (settings.AutoMode)
                {
                    bool processCss = settings.CompressCSS || settings.MinifyContent;
                    bool processJs = settings.CompressJavaScript || settings.MinifyContent;
                    app.Response.Filter = new AutoModeFilterStream(app.Response.Filter,app.Response.ContentEncoding, processJs,processCss);
                }
            }
        }
Example #4
0
        /// <summary>
        /// Handles the PreRequestHandlerExecute event.
        /// The compression moved to this step to catch Server.Transfer operation
        /// </summary>
        /// <param name="sender">The object that raised the event (HttpApplication)</param>
        /// <param name="e">The event data</param>
        void context_PreRequestHandlerExecute(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;

            if (app.Context == null || app.Context.Response == null)
                return;

            // This part of the module compress only handlers from type System.Web.UI.Page
            // Other types such JavaScript or CSS files will be compressed in an httpHandelr.
            // Here we check if the current handler if a Page handler, if so, we compress it.
            if (app.Context.CurrentHandler is System.Web.UI.Page && app.Context.Response != null)
            {
                // Check if the path is not excluded.
                if (!settings.IsValidPath(app.Request.AppRelativeCurrentExecutionFilePath))
                    return;

                if (Util.IsToolkitScriptManagerCombiner(app.Request))
                    return;

                if (settings.CompressPage && !Util.IsContainExcludedParamValue(app.Context) && !(Util.IsMsAjaxRequest(app.Context) && settings.MSAjaxVersion < 3.5))
                {
                    EncodingManager encodingMgr = new EncodingManager(app.Context);

                    if (encodingMgr.IsEncodingEnabled)
                    {
                        // Add preferredEncoding to the context.items for use later in the pipeline
                        app.Context.Items.Add("preferredEncoding", encodingMgr.PreferredEncoding);
                        //Add the compression filter
                        encodingMgr.CompressResponse();
                    }
                }

                if (settings.AutoMode && !Util.IsMsAjaxRequest(app.Context))
                {
                    bool processCss = settings.CompressCSS || settings.MinifyContent || settings.CombineCSS;
                    bool processJs = settings.CompressJavaScript || settings.MinifyContent;
                    app.Response.Filter = new AutoModeFilterStream(app.Response.Filter, app.Response.ContentEncoding, processJs, processCss, settings.CombineCSS, settings.CombineHeaderScripts);
                }
            }
        }
        private void OnPreRequestHandlerExecute(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;

            // Check if the current request is Webresource.axd
            if (app.Context.CurrentHandler is AssemblyResourceLoader)
            {
                HttpResponse response = app.Context.Response;
                int queryHash = (app.Context.Request.QueryString.ToString()).GetHashCode();

                // Check if the ETag is match. If so, we don't send nothing to the client, and stop here.
                CheckETag(app, queryHash);

                try
                {
                    // Parse the QueryString into parts
                    Quadruplet<Char, String, String, String> urlInfo = GetDataFromQuery(app.Context.Request.QueryString);

                    // Load the assembly
                    Assembly assembly = GetAssembly(urlInfo.First, urlInfo.Second);

                    if (assembly == null)
                        ThrowHttpException(404, SR.WebResourceCompressionModule_AssemblyNotFound, urlInfo.Forth);

                    // Get the resource info from assembly.
                    Quadruplet<bool, bool, string, bool> resourceInfo = GetResourceInfo(assembly, urlInfo.Third);

                    if (!resourceInfo.First)
                        ThrowHttpException(404, SR.WebResourceCompressionModule_AssemblyNotFound, urlInfo.Forth);

                    // If the WebResource needs to perform substitution (WebResource inside WebResource), we leave it to the original AssemblyResourceLoader handler ;-)
                    if (resourceInfo.Second)
                        return;

                    response.Clear();

                    // Set the response cache headers
                    SetCachingHeadersForWebResource(response.Cache, queryHash);

                    // Set the response content type
                    response.ContentType = resourceInfo.Third;

                    EncodingManager encodingMgr = new EncodingManager(app.Context);

                    // Write content with compression
                    if (resourceInfo.Forth && (Settings.Instance.CompressWebResource || Settings.Instance.MinifyContent))
                    {
                        using (StreamReader resourceStream = new StreamReader(assembly.GetManifestResourceStream(urlInfo.Third), true))
                        {
                            ProcessAndWriteToStream(resourceStream, app.Context, encodingMgr);
                        }
                    }
                    // Write content without compression or minify
                    else
                    {
                        using (Stream resourceStream = assembly.GetManifestResourceStream(urlInfo.Third))
                        {
                            WriteToStream(resourceStream, response.OutputStream);
                        }
                    }
                    response.OutputStream.Flush();
                    app.CompleteRequest();
                }
                catch (ArgumentNullException)
                {
                    return;
                }
                catch (TargetInvocationException)
                {
                    return;
                }
                catch (System.Security.Cryptography.CryptographicException)
                {
                    return;
                }
            }
        }
 /// <summary>
 /// Process & Write a StreamReader to an output stream
 /// </summary>
 /// <param name="reader"></param>
 /// <param name="context"></param>
 /// <param name="encodingMgr"></param>
 private static void ProcessAndWriteToStream(StreamReader reader, HttpContext context, EncodingManager encodingMgr)
 {
     string content = SR.GetString(SR.CREDIT_STRING);
     if (Settings.Instance.MinifyContent)
     {
         if (context.Response.ContentType.Contains("javascript"))
         {
             JavaScriptMinifier _Minifier = new JavaScriptMinifier();
             content += _Minifier.Minify(reader);
         }
         else if (context.Response.ContentType.Contains("css"))
         {
             CssMinifier _Minifier = new CssMinifier();
             content += _Minifier.Minify(reader);
         }
         else
         {
             content += reader.ReadToEnd();
         }
     }
     else
     {
         content += reader.ReadToEnd();
     }
     if (encodingMgr.IsEncodingEnabled && Settings.Instance.CompressWebResource)
     {
         encodingMgr.SetResponseEncodingType();
         byte[] compressed = encodingMgr.CompressString(content);
         context.Response.OutputStream.Write(compressed, 0, compressed.Length);
     }
     else
     {
         context.Response.Write(content);
     }
 }
Example #7
0
        /// <summary>
        ///  Excute the request and response the needes content
        /// <para>Save the response in the file system for next requests</para>
        /// </summary>
        /// <param name="context"></param>
        /// <param name="filesInfo"></param>
        /// <param name="minify"></param>
        /// <param name="versionHash"></param>
        /// <param name="encodingMgr"></param>
        public void Excute(HttpContext context, string[] filesInfo, Minifier minify, int versionHash, EncodingManager encodingMgr)
        {
            string phisicalRoot = context.Server.MapPath("~/") + cReferencesCache;

            string fullPath;
            if (encodingMgr.IsEncodingEnabled)
            {
                fullPath = phisicalRoot + "comp_" + encodingMgr.PreferredEncoding + "_" + versionHash + (minify.Target is JavaScriptCompressionHandler ? ".js" : ".css");
                encodingMgr.SetResponseEncodingType();
            }
            else
            {
                fullPath = phisicalRoot + versionHash + (minify.Target is JavaScriptCompressionHandler ? ".js" : ".css");
            }

            SetResponseCacheSettings(context, null);

            if (!File.Exists(fullPath))
            {
                lock (_syncObject)
                {
                    if (!File.Exists(fullPath))
                    {
                        if (!Directory.Exists(phisicalRoot))
                        {
                            Directory.CreateDirectory(phisicalRoot);
                        }
                        if (encodingMgr.IsEncodingEnabled)
                        {
                            StringBuilder contentSb = new StringBuilder(SR.GetString(SR.CREDIT_STRING));
                            foreach (string fileName in filesInfo)
                            {
                                if (fileName.StartsWith("NOT_FOUND", StringComparison.Ordinal))
                                {
                                    contentSb.AppendFormat(SR.File_FileNotFound + Environment.NewLine, Path.GetFileName(fileName.Split('|')[1]));
                                }
                                else
                                {
                                    using (StreamReader reader = new StreamReader(fileName, context.Response.ContentEncoding))
                                    {
                                        if (Settings.Instance.IsValidPathForMinify(fileName))
                                        {
                                            contentSb.AppendLine(minify(reader));
                                        }
                                        else
                                        {
                                            contentSb.AppendLine(reader.ReadToEnd());
                                        }
                                    }
                                }
                            }

                            using (FileStream fs = new FileStream(fullPath, FileMode.Create))
                            {
                                byte[] compressedContent = encodingMgr.CompressString(contentSb.ToString());
                                fs.Write(compressedContent, 0, compressedContent.Length);
                            }
                            // Release the StringBuilder
                            contentSb.Length = 0;
                        }
                        else
                        {
                            using (FileStream fs = new FileStream(fullPath, FileMode.Create))
                            using (StreamWriter sw = new StreamWriter(fs,context.Response.ContentEncoding))
                            {
                                string content = SR.GetString(SR.CREDIT_STRING);
                                sw.WriteLine(content);
                                foreach (string fileName in filesInfo)
                                {
                                    if (fileName.Length == 0)
                                    {
                                        content = string.Format(CultureInfo.CurrentCulture, SR.File_FileNotFound, Path.GetFileName(fileName));
                                    }
                                    else
                                    {
                                        using (StreamReader reader = new StreamReader(fileName, context.Response.ContentEncoding))
                                        {
                                            if (Settings.Instance.IsValidPathForMinify(fileName))
                                            {
                                                content = minify(reader);
                                            }
                                            else
                                            {
                                                content = reader.ReadToEnd();
                                            }
                                        }
                                    }
                                    sw.WriteLine(content);
                                }
                            }
                        }
                    }
                }
            }
            context.Response.TransmitFile(fullPath);
        }