public IDictionary <Guid, string> GetSavedUrls()
{
RRTracer.Trace("SqlServerStore Looking for previously saved content.");
var files = repository.GetActiveFiles();
return(files.ToDictionary(file => uriBuilder.ParseKey(file), file => uriBuilder.BuildResourceUrl(uriBuilder.ParseKey(file), uriBuilder.ParseSignature(file), RRContainer.GetAllResourceTypes().SingleOrDefault(x => file.EndsWith(x.FileName)).GetType())));
}
protected virtual string ProcessCss(string url)
{
RRTracer.Trace("Beginning Processing {0}", url);
var urlParts = url.Split(new[] { '^' }, 2);
url = urlParts[0];
RRTracer.Trace("Beginning to Download {0}", url);
var cssContent = WebClientWrapper.DownloadString <CssResource>(url);
RRTracer.Trace("Finished Downloading {0}", url);
RRTracer.Trace("Beginning to absolutize urls in {0}", url);
cssContent = MakeRelativeUrlsAbsoluteAndRemoveComments(cssContent, url);
RRTracer.Trace("finished absolutizing urls in {0}", url);
RRTracer.Trace("Beginning to expand imports in {0}", url);
cssContent = ExpandImports(cssContent, url);
RRTracer.Trace("Finished expanding imports in {0}", url);
if (!configuration.ImageSpritingDisabled)
{
RRTracer.Trace("Beginning to process sprites in {0}", url);
ProcessSprites(cssContent);
RRTracer.Trace("Finished processing sprites in {0}", url);
}
if (urlParts.Length > 1)
{
RRTracer.Trace("Beginning to wrap media in {0}", url);
cssContent = WrapMedia(cssContent, urlParts[1]);
RRTracer.Trace("finished wraping media in {0}", url);
}
return(cssContent);
}
public DbDiskCache(IFileWrapper fileWrapper, IRRConfiguration configuration, IUriBuilder uriBuilder) : base(fileWrapper, configuration, uriBuilder, null)
{
RRTracer.Trace("Creating db disk cache");
const int interval = 1000 * 60 * 5;
timer = new Timer(PurgeOldFiles, null, 0, interval);
}
private void OnChange(object sender, FileSystemEventArgs e)
{
var path = e.FullPath;
RRTracer.Trace("watcher watched {0}", path);
var guid = uriBuilder.ParseKey(path.Replace('\\', '/'));
var contentSignature = uriBuilder.ParseSignature(path.Replace('\\', '/'));
if (guid != Guid.Empty)
{
var resourceType = RRContainer.Current.GetAllInstances <IResourceType>().SingleOrDefault(x => path.EndsWith(x.FileName, true, CultureInfo.InvariantCulture));
if (resourceType != null)
{
RRTracer.Trace("New Content {0} and watched: {1}", e.ChangeType, path);
if (e.ChangeType == WatcherChangeTypes.Deleted)
{
ReductionRepository.RemoveReduction(guid);
}
if ((e.ChangeType == WatcherChangeTypes.Created || e.ChangeType == WatcherChangeTypes.Changed))
{
ReductionRepository.AddReduction(guid, uriBuilder.BuildResourceUrl(guid, contentSignature, resourceType.GetType()));
}
}
}
}
public virtual void Add(BackgroundImageClass image)
{
var imageKey = new ImageMetadata(image);
if (RRContainer.Current.GetAllInstances <IFilter>().Where(x => x is SpriteFilter).FirstOrDefault(y => y.IgnoreTarget(new SpriteFilterContext(image))) != null || spriteList.ContainsKey(imageKey))
{
return;
}
SpritedImage spritedImage;
try
{
spritedImage = SpriteContainer.AddImage(image);
}
catch (Exception ex)
{
var message = string.Format("There were errors reducing {0}", image.ImageUrl);
var wrappedException =
new ApplicationException(message, ex);
RRTracer.Trace(message);
RRTracer.Trace(ex.ToString());
if (Registry.CaptureErrorAction != null)
{
Registry.CaptureErrorAction(wrappedException);
}
return;
}
spriteList.Add(imageKey, spritedImage);
if (SpriteContainer.Size >= config.SpriteSizeLimit || (SpriteContainer.Colors >= config.SpriteColorLimit && !config.ImageQuantizationDisabled && !config.ImageOptimizationDisabled))
{
Flush();
}
}
private void DoTransform(byte[] buffer, ref int startTransformPosition)
{
currentStartStringsToSkip = new bool[currentStartStringsToSkip.Length];
if ((startTransformPosition - actualOffset) >= 0)
{
BaseStream.Write(buffer, actualOffset, startTransformPosition - actualOffset);
}
try
{
var transformed =
encoding.GetBytes(responseTransformer.Transform(encoding.GetString(transformBuffer.ToArray())));
BaseStream.Write(transformed, 0, transformed.Length);
}
catch (Exception ex)
{
var message = string.Format("There were errors transforming {0}", encoding.GetString(transformBuffer.ToArray()));
var wrappedException =
new ApplicationException(message, ex);
RRTracer.Trace(message);
RRTracer.Trace(ex.ToString());
if (Registry.CaptureErrorAction != null)
{
Registry.CaptureErrorAction(wrappedException);
}
BaseStream.Write(transformBuffer.ToArray(), 0, transformBuffer.Count);
}
startTransformPosition = 0;
transformBuffer.Clear();
}
public IDictionary <Guid, string> GetSavedUrls()
{
RRTracer.Trace("LocalDiskStore Looking for previously saved content.");
var dic = new Dictionary <Guid, string>();
if (configuration == null || string.IsNullOrEmpty(configuration.SpritePhysicalPath))
{
return(dic);
}
var activeFiles = FileWrapper.GetDatedFiles(configuration.SpritePhysicalPath, "*RequestReduce*");
return((from files in activeFiles
where !files.FileName.Contains("-Expired-") && uriBuilder.ParseKey(files.FileName.Replace("\\", "/")) != Guid.Empty
group files by uriBuilder.ParseKey(files.FileName.Replace("\\", "/"))
into filegroup
join files2 in activeFiles on new { k = filegroup.Key, u = filegroup.Max(m => m.CreatedDate) } equals
new { k = uriBuilder.ParseKey(files2.FileName.Replace("\\", "/")), u = files2.CreatedDate }
select files2.FileName)
.ToDictionary(file => uriBuilder.ParseKey(file.Replace("\\", "/")),
file =>
uriBuilder.BuildResourceUrl(uriBuilder.ParseKey(file.Replace("\\", "/")),
uriBuilder.ParseSignature(file.Replace("\\", "/")),
RRContainer.Current.GetAllInstances <IResourceType>().
SingleOrDefault(x => file.EndsWith(x.FileName, true, CultureInfo.InvariantCulture)).GetType())));
}
public static void InstallFilter(HttpContextBase context)
{
var request = context.Request;
var config = RRContainer.Current.GetInstance <IRRConfiguration>();
if (context.Items.Contains(ContextKey) ||
(config.CssProcessingDisabled && config.JavaScriptProcessingDisabled) ||
context.Response.IsRequestBeingRedirected ||
RRContainer.Current.GetAllInstances <IFilter>().Where(x => x is PageFilter).FirstOrDefault(y => y.IgnoreTarget(new PageFilterContext(context.Request))) != null)
{
return;
}
if (request.QueryString["RRFilter"] != null && request.QueryString["RRFilter"].Equals("disabled", StringComparison.OrdinalIgnoreCase))
{
context.Response.Cache.SetCacheability(HttpCacheability.Private);
return;
}
var hostingEnvironment = RRContainer.Current.GetInstance <IHostingEnvironmentWrapper>();
if (string.IsNullOrEmpty(config.ResourcePhysicalPath))
{
config.ResourcePhysicalPath = hostingEnvironment.MapPath(config.ResourceVirtualPath);
}
var oldFilter = context.Response.Filter; //suppresses a asp.net3.5 bugg
context.Response.Filter = RRContainer.Current.GetInstance <AbstractFilter>();
context.Items.Add(ContextKey, new object());
RRTracer.Trace("Attaching Filter to {0}", request.RawUrl);
}
public void InstallFilter(HttpContextBase context)
{
RRTracer.Trace("Entering Module");
var request = context.Request;
var config = RRContainer.Current.GetInstance <IRRConfiguration>();
if (context.Items.Contains(CONTEXT_KEY) ||
context.Response.ContentType != "text/html" ||
(request.QueryString["RRFilter"] != null && request.QueryString["RRFilter"].Equals("disabled", StringComparison.OrdinalIgnoreCase)) ||
(config.CssProcessingDisabled && config.JavaScriptProcessingDisabled) ||
context.Response.StatusCode == 302 ||
context.Response.StatusCode == 301 ||
request.RawUrl == "/favicon.ico" ||
RRContainer.Current.GetAllInstances <IFilter>().Where(x => x is PageFilter).FirstOrDefault(y => y.IgnoreTarget(new PageFilterContext(context.Request))) != null ||
IsInRRContentDirectory(context))
{
return;
}
if (string.IsNullOrEmpty(config.SpritePhysicalPath))
{
config.SpritePhysicalPath = context.Server.MapPath(config.SpriteVirtualPath);
}
var oldFilter = context.Response.Filter; //suppresses a asp.net3.5 bug
context.Response.Filter = RRContainer.Current.GetInstance <AbstractFilter>();
context.Items.Add(CONTEXT_KEY, new object());
RRTracer.Trace("Attaching Filter to {0}", request.RawUrl);
}
protected override string ProcessResource(Guid key, IEnumerable <string> urls, string host)
{
RRTracer.Trace("beginning to merge js");
try
{
var mergedJSBuilder = new StringBuilder();
foreach (var url in urls)
{
mergedJSBuilder.Append(ProcessJavaScript(url).Trim());
if (mergedJSBuilder.Length > 0 && (mergedJSBuilder[mergedJSBuilder.Length - 1] != ';'))
{
mergedJSBuilder.Append(";");
RRTracer.Trace("Appending missing semicolon to {0}", url);
}
mergedJSBuilder.AppendLine();
}
RRTracer.Trace("finished merging js with a length of {0}", mergedJSBuilder.Length);
return(mergedJSBuilder.ToString());
}
catch (NearFutureJavascriptException)
{
RRTracer.Trace("catching near future exception");
return(null);
}
}
protected virtual string ProcessJavaScript(string url)
{
RRTracer.Trace("Beginning Processing {0}", url);
string jsContent = string.Empty;
url = url.Replace("&", "&");
RRTracer.Trace("Beginning to Download {0}", url);
using (var response = WebClientWrapper.Download <JavaScriptResource>(url))
{
if (response == null)
{
RRTracer.Trace("Response is null for {0}", url);
return(null);
}
var expires = response.Headers["Expires"];
try
{
if (!string.IsNullOrEmpty(expires) && DateTime.Parse(expires) < DateTime.Now.AddDays(6))
{
RRTracer.Trace("{0} expires in less than a week", url);
AddUrlToIgnores(url);
}
}
catch (FormatException) { RRTracer.Trace("Format exception thrown parsing expires of {0}", url); }
var cacheControl = response.Headers["Cache-Control"];
if (!string.IsNullOrEmpty(cacheControl))
{
var cacheControlVals = cacheControl.ToLower().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var val in cacheControlVals)
{
try
{
if ((val.Contains("no-") || (val.Contains("max-age") && Int32.Parse(val.Trim().Remove(0, 8)) < (60 * 60 * 24 * 7))))
{
RRTracer.Trace("{0} max-age in less than a week", url);
AddUrlToIgnores(url);
}
}
catch (FormatException) { RRTracer.Trace("Format exception thrown parsing max-age of {0}", url); }
}
}
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var streamDecoder = responseDecoder.GetDecodableStream(responseStream, response.Headers["Content-Encoding"]))
{
using (var streameader = new StreamReader(streamDecoder, Encoding.UTF8))
{
jsContent = streameader.ReadToEnd();
RRTracer.Trace("content of {0} read and has {1} bytes and a length of {2}", url, response.ContentLength, jsContent.Length);
}
}
}
}
}
return(jsContent);
}
public virtual void Dispose()
{
if (configuration.IsFullTrust)
{
ShutdownWatcher();
}
RRTracer.Trace("Local Disk Store Disposed.");
}
public void RemoveReduction(Guid key)
{
lock (lockObject)
{
dictionary.Remove(key);
}
RRTracer.Trace("Reduction {0} removed.", key);
}
public SqlServerStore(IUriBuilder uriBuilder, IFileRepository repository, LocalDiskStore fileStore, IReductionRepository reductionRepository)
{
RRTracer.Trace("Sql Server Store Created.");
this.uriBuilder = uriBuilder;
this.repository = repository;
FileStore = fileStore;
this.reductionRepository = reductionRepository;
}
private void ProcessQueue()
{
RRTracer.Trace("Process Queue Thread Started");
while (IsRunning)
{
ProcessQueuedItem();
Thread.Sleep(100);
}
}
private string DoTransform <T>(string preTransform, StringBuilder urls, List <string> transformableMatches, string noCommentTransform) where T : IResourceType
{
var resource = RRContainer.Current.GetInstance <T>();
RRTracer.Trace("Looking for reduction for {0}", urls);
var transform = reductionRepository.FindReduction(urls.ToString());
if (transform != null)
{
RRTracer.Trace("Reduction found for {0}", urls);
if (uriBuilder.ParseSignature(transform) != Guid.Empty.RemoveDashes())
{
var firstScript =
RRContainer.Current.GetInstance <JavaScriptResource>().ResourceRegex.Match(noCommentTransform);
var firstScriptIndex = firstScript.Success ? preTransform.IndexOf(firstScript.ToString(), StringComparison.Ordinal) : -1;
var insertionIdx = (firstScript.Success && firstScriptIndex <
preTransform.IndexOf(transformableMatches[0], StringComparison.Ordinal) && resource is CssResource)
? firstScriptIndex - 1
: preTransform.IndexOf(transformableMatches[0], StringComparison.Ordinal) - 1;
preTransform = preTransform.Insert(insertionIdx + 1, resource.TransformedMarkupTag(transform));
}
var result = preTransform;
foreach (var match in transformableMatches)
{
var idx = result.IndexOf(match, StringComparison.Ordinal);
result = result.Remove(idx, match.Length);
if (idx == result.Length)
{
continue;
}
if (result[idx] == '\r')
{
result = result.Remove(idx, 1);
}
if (result[idx] == '\n')
{
result = result.Remove(idx, 1);
}
}
return(result);
}
var host = string.Empty;
if (!string.IsNullOrEmpty(config.ContentHost))
{
var uri = context.Request.Url;
if (uri != null)
{
host = string.Format("{0}://{1}/", uri.Scheme, uri.Host);
}
}
reducingQueue.Enqueue(new QueueItem <T> {
Urls = urls.ToString(), Host = host
});
RRTracer.Trace("No reduction found for {0}. Enqueuing.", urls);
return(preTransform);
}
private void ProcessSprites(string cssContent)
{
var newImages = cssImageTransformer.ExtractImageUrls(cssContent);
foreach (var imageUrl in newImages)
{
RRTracer.Trace("Adding {0}", imageUrl.ImageUrl);
spriteManager.Add(imageUrl);
RRTracer.Trace("Finished adding {0}", imageUrl.ImageUrl);
}
}
public override void Flush()
{
if (isAdjacent)
{
var transformed =
encoding.GetBytes(responseTransformer.Transform(encoding.GetString(transformBuffer.ToArray())));
BaseStream.Write(transformed, 0, transformed.Length);
transformBuffer.Clear();
}
BaseStream.Flush();
RRTracer.Trace("Flushing Filter");
}
public ReducingQueue(IReductionRepository reductionRepository, IStore store)
{
RRTracer.Trace("Instantiating new Reducing queue.");
queueLock = new ReaderWriterLockSlim();
ReductionRepository = reductionRepository;
Store = store;
BackgroundThread = new Thread(ProcessQueue)
{
IsBackground = true
};
BackgroundThread.Start();
}
public void HandleRRFlush(HttpContextBase httpContextWrapper)
{
var url = EnsurePath(httpContextWrapper.Request.RawUrl);
if (!IsInRRContentDirectory(httpContextWrapper) ||
(!url.ToLowerInvariant().Contains("/flush/") &&
!url.ToLowerInvariant().Contains("/flushfailures/")))
{
return;
}
var config = RRContainer.Current.GetInstance <IRRConfiguration>();
var hostingEnvironment = RRContainer.Current.GetInstance <IHostingEnvironmentWrapper>();
var ipfilter = RRContainer.Current.GetInstance <IIpFilter>();
if (string.IsNullOrEmpty(config.SpritePhysicalPath))
{
config.SpritePhysicalPath = hostingEnvironment.MapPath(config.SpriteVirtualPath);
}
var user = httpContextWrapper.User == null ? string.Empty : httpContextWrapper.User.Identity.Name;
if ((config.AuthorizedUserList.AllowsAnonymous() || config.AuthorizedUserList.Contains(user)) &&
ipfilter.IsAuthorizedIpAddress(httpContextWrapper))
{
if (url.ToLowerInvariant().Contains("/flushfailures/"))
{
var queue = RRContainer.Current.GetInstance <IReducingQueue>();
queue.ClearFailures();
RRTracer.Trace("Failures Cleared");
}
else
{
var uriBuilder = RRContainer.Current.GetInstance <IUriBuilder>();
var key = uriBuilder.ParseKey(url.ToLower().Replace("/flush/rrflush.aspx/", "-flush"));
if (key == Guid.Empty)
{
key = uriBuilder.ParseKey(url.ToLower().Replace("/flush/", "-flush"));
}
var store = RRContainer.Current.GetInstance <IStore>();
store.Flush(key);
RRTracer.Trace("{0} Flushed {1}", user, key);
}
if (HttpContext.Current != null)
{
httpContextWrapper.Response.Redirect(string.Format("{0}/dashboard", config.SpriteVirtualPath));
}
}
else
{
httpContextWrapper.Response.StatusCode = 401;
}
}
public override void Write(byte[] buffer, int offset, int count)
{
watch.Start();
RRTracer.Trace("Beginning Filter Write");
if (Closed)
{
throw new ObjectDisposedException("ResponseFilter");
}
originalOffset = actualOffset = offset;
actualLength = count;
var startTransformPosition = 0;
var endTransformPosition = 0;
for (var idx = offset; idx < (count + offset); idx++)
{
matchPosition = HandleMatch(ref idx, buffer[idx], buffer, ref startTransformPosition, ref endTransformPosition);
}
RRTracer.Trace("Response filter state is {0}", state);
switch (state)
{
case SearchState.LookForStart:
if (endTransformPosition > 0)
{
if ((actualOffset + actualLength) - endTransformPosition > 0)
{
BaseStream.Write(buffer, endTransformPosition, (actualOffset + actualLength) - endTransformPosition);
}
}
else
{
BaseStream.Write(buffer, actualOffset, actualLength);
}
break;
case SearchState.MatchingStart:
case SearchState.MatchingStartClose:
case SearchState.LookForStop:
case SearchState.MatchingStop:
case SearchState.LookForAdjacentScript:
if (startTransformPosition > actualOffset)
{
BaseStream.Write(buffer, actualOffset, startTransformPosition - actualOffset);
}
break;
}
RRTracer.Trace("Ending Filter Write");
watch.Stop();
}
public virtual void Add(BackgroundImageClass image)
{
var imageKey = new ImageMetadata(image);
if (RRContainer.Current.GetAllInstances <IFilter>().Where(x => x is SpriteFilter).FirstOrDefault(y => y.IgnoreTarget(new SpriteFilterContext(image))) != null)
{
return;
}
if (SpriteList.Any(x => x.Key.Equals(imageKey)))
{
var originalImage = SpriteList.First(x => x.Key.Equals(imageKey)).Value;
var clonedImage = new SpritedImage(originalImage.AverageColor, image, originalImage.Image)
{
Position = originalImage.Position, Url = originalImage.Url, Metadata = imageKey
};
//SpriteContainer.AddImage(clonedImage);
SpriteList.Add(new KeyValuePair <ImageMetadata, SpritedImage>(imageKey, clonedImage));
return;
}
SpritedImage spritedImage;
var sprite = SpriteList.FirstOrDefault(x => x.Value.CssClass.ImageUrl == image.ImageUrl);
if (sprite.Value != null)
{
image.IsSprite = true;
sprite.Value.CssClass.IsSprite = true;
}
try
{
spritedImage = SpriteContainer.AddImage(image);
spritedImage.Metadata = imageKey;
}
catch (Exception ex)
{
var message = string.Format("There were errors reducing {0}", image.ImageUrl);
var wrappedException =
new ApplicationException(message, ex);
RRTracer.Trace(message);
RRTracer.Trace(ex.ToString());
if (Registry.CaptureErrorAction != null)
{
Registry.CaptureErrorAction(wrappedException);
}
return;
}
SpriteList.Add(new KeyValuePair <ImageMetadata, SpritedImage>(imageKey, spritedImage));
if (SpriteContainer.Size >= config.SpriteSizeLimit || (SpriteContainer.Colors >= config.SpriteColorLimit && !config.ImageQuantizationDisabled && !config.ImageOptimizationDisabled))
{
Flush();
}
}
protected override string ProcessResource(Guid key, IEnumerable <string> urls)
{
spriteManager.SpritedCssKey = key;
var mergedCss = new StringBuilder();
RRTracer.Trace("beginning to merge css");
foreach (var url in urls)
{
mergedCss.Append(ProcessCss(url));
}
RRTracer.Trace("Finished merging css");
spriteManager.Dispose();
return(SpriteCss(mergedCss.ToString()));
}
public void InstallFilter(HttpContextBase context)
{
RRTracer.Trace("Entering Module");
var request = context.Request;
if (context.Response.ContentType != "text/html" ||
request.RawUrl == "/favicon.ico" ||
IsInRRContentDirectory(context))
{
return;
}
ResponseFilter.InstallFilter(context);
}
public void AddReduction(Guid key, string reducedUrl)
{
try
{
lock (lockObject)
{
dictionary[key] = reducedUrl;
RRTracer.Trace("Reduction {0} added to ReductionRepository Dictionary.", key);
}
}
catch (ArgumentException)
{
}
}
public void InstallFilter(HttpContextBase context)
{
RRTracer.Trace("Entering Module");
var uri = context.Request.Url;
if ((context.Response.ContentType != "text/html" &&
context.Response.ContentType != "application/xhtml+xml") ||
uri.AbsolutePath == "/favicon.ico" ||
IsInRRContentDirectory(uri))
{
return;
}
ResponseFilter.InstallFilter(context);
}
public virtual void Flush()
{
if (SpriteContainer.Size > 0)
{
RRTracer.Trace("Beginning to Flush sprite");
using (var spriteWriter = new SpriteWriter(SpriteContainer.Width, SpriteContainer.Height))
{
var offset = 0;
foreach (var image in SpriteContainer)
{
spriteWriter.WriteImage(image.Image);
image.Position = offset;
offset += image.Image.Width + 1;
}
var bytes = spriteWriter.GetBytes("image/png");
byte[] optBytes;
try
{
optBytes = (config.ImageOptimizationDisabled || !config.IsFullTrust) ? bytes : pngOptimizer.OptimizePng(bytes, config.ImageOptimizationCompressionLevel, config.ImageQuantizationDisabled);
}
catch (OptimizationException optEx)
{
optBytes = bytes;
RRTracer.Trace(string.Format("Errors optimizing {0}. Received Error: {1}", SpritedCssKey, optEx.Message));
if (Registry.CaptureErrorAction != null)
{
Registry.CaptureErrorAction(optEx);
}
}
var url = GetSpriteUrl(optBytes);
store.Save(optBytes, url, null);
foreach (var image in SpriteContainer)
{
image.Url = url;
foreach (var dupImage in SpriteList)
{
if (dupImage.Key.Equals(image.Metadata) && dupImage.Value.Position == -1)
{
dupImage.Value.Position = image.Position;
dupImage.Value.Url = image.Url;
}
}
}
}
RRTracer.Trace("Finished Flushing sprite");
}
SpriteContainer = new SpriteContainer(webClientWrapper, config);
}
public virtual string Process(Guid key, string urls)
{
RRTracer.Trace("beginning reducing process for {0}", urls);
var urlList = SplitUrls(urls);
var processedResource = ProcessResource(key, urlList);
var virtualfileName = string.Empty;
if (processedResource != null)
{
var bytes = Encoding.UTF8.GetBytes(minifier.Minify <T>(processedResource));
virtualfileName = uriBuilder.BuildResourceUrl <T>(key, bytes);
store.Save(bytes, virtualfileName, urls);
}
RRTracer.Trace("finishing reducing process for {0}", urls);
return(virtualfileName);
}
public void ProcessRequest(HttpContextBase context)
{
var url = context.Request.Url.AbsolutePath;
if (string.IsNullOrEmpty(config.ResourcePhysicalPath))
{
config.ResourcePhysicalPath = hostingEnvironment.MapPath(config.ResourceVirtualPath);
}
RRTracer.Trace("Beginning to serve {0}", url);
var sig = uriBuilder.ParseSignature(url);
if (sig == Guid.Empty.RemoveDashes())
{
return;
}
var etag = context.Request.Headers["If-None-Match"];
etag = etag == null ? string.Empty : etag.Replace("\"", "");
if (sig == etag || store.SendContent(url, context.Response))
{
context.Response.Cache.SetETag(string.Format(@"""{0}""", sig));
context.Response.Cache.SetCacheability(HttpCacheability.Public);
context.Response.Expires = 60 * 24 * 360; //LITTLE under A YEAR
if (sig == etag)
{
context.Response.StatusCode = 304;
}
else if (url.EndsWith(".css", StringComparison.OrdinalIgnoreCase))
{
context.Response.ContentType = "text/css";
}
else if (url.EndsWith(".js", StringComparison.OrdinalIgnoreCase))
{
context.Response.ContentType = "application/x-javascript";
}
else if (url.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
{
context.Response.ContentType = "image/png";
}
if (context.ApplicationInstance != null)
{
context.ApplicationInstance.CompleteRequest();
}
}
RRTracer.Trace("Finished serving {0}", url);
}
public void HandleRRFlush(HttpContextBase httpContextWrapper)
{
var url = EnsurePath(httpContextWrapper.Request.RawUrl);
if (!IsInRRContentDirectory(httpContextWrapper) ||
(!url.EndsWith("/flush/", StringComparison.OrdinalIgnoreCase) &&
!url.EndsWith("/flushfailures/", StringComparison.OrdinalIgnoreCase)))
{
return;
}
var config = RRContainer.Current.GetInstance <IRRConfiguration>();
if (string.IsNullOrEmpty(config.SpritePhysicalPath))
{
config.SpritePhysicalPath = httpContextWrapper.Server.MapPath(config.SpriteVirtualPath);
}
var user = httpContextWrapper.User.Identity.Name;
if (config.AuthorizedUserList.AllowsAnonymous() || config.AuthorizedUserList.Contains(user))
{
if (url.EndsWith("/flushfailures/", StringComparison.OrdinalIgnoreCase))
{
var queue = RRContainer.Current.GetInstance <IReducingQueue>();
queue.ClearFailures();
RRTracer.Trace("Failures Cleared");
}
else
{
var store = RRContainer.Current.GetInstance <IStore>();
var uriBuilder = RRContainer.Current.GetInstance <IUriBuilder>();
var key = uriBuilder.ParseKey(url.ToLower().Replace("/flush/", "-flush"));
store.Flush(key);
RRTracer.Trace("{0} Flushed {1}", user, key);
}
if (HttpContext.Current != null)
{
httpContextWrapper.Response.Redirect(string.Format("{0}/dashboard", config.SpriteVirtualPath));
}
}
else
{
httpContextWrapper.Response.StatusCode = 401;
}
}
