2159 lines
81 KiB
C#
2159 lines
81 KiB
C#
|
||
//--------------------------------------------------------------------------------------------------------------------------
|
||
// <copyright company=’Microsoft Corporation’>
|
||
// Copyright © Microsoft Corporation. All Rights Reserved.
|
||
// </copyright>
|
||
//--------------------------------------------------------------------------------------------------------------------------
|
||
// @owner=alexgor, deliant
|
||
//==========================================================================================================================
|
||
// File: ChartHttpHandler.cs
|
||
//
|
||
// Namespace: Microsoft.Reporting.Chart.WebForms
|
||
//
|
||
// Classes: ChartHttpHandler
|
||
//
|
||
// Purpose: ChartHttpHandler is a static class which is responsible to handle with
|
||
// chart images, interactive images, scripts and other resources.
|
||
//
|
||
//
|
||
// Reviewed: DT
|
||
// Reviewed: deliant on 4/14/2011
|
||
// MSRC#10470, VSTS#941768 http://vstfdevdiv:8080/web/wi.aspx?id=941768
|
||
// Please review information associated with MSRC#10470 before making any changes to this file.
|
||
// - Fixes:
|
||
// - Fixed Directory Traversal/Arbitrary File Read, Delete with malformed image key.
|
||
// - Honor HttpContext.Current.Trace.IsEnabled when generate and deliver chart trace info.
|
||
// - Handle empty guid parameter ("?g=") as invalid when enforcing privacy.
|
||
// - Replaced the privacy byte array comparison with custom check (otherwise posible EOS marker can return 0 length string).
|
||
// - Added fixed string to session key to avoid direct session access.
|
||
//
|
||
// Added: deliant on 4/48/2011 fix for VSTS: 3593 - ASP.Net chart under web farm exhibit fast performace degradation
|
||
// Summary: Under large web farm setup ( ~16 processes and up) chart control image handler
|
||
// soon starts to show performace degradation up to denial of service, when a file system is used as storage.
|
||
// Issues:
|
||
// - The image files in count over 2000 in one single folder causes exponentially growing slow response,
|
||
// especially on the remote server. The fix places the Image files in separate subfolders for each process.
|
||
// - Private protection seeks and read several times in the image file istead reading the image at once
|
||
// and then check for privacy marker. Separate small network reads are expensive.
|
||
// - Due missing lock in initialization stage the chart lock files number can grow more that process max
|
||
// number which can create abandon chart image files
|
||
//==========================================================================================================================
|
||
|
||
#region Namespaces
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Text;
|
||
using System.Web;
|
||
using System.Web.UI;
|
||
using System.IO;
|
||
using System.Web.Caching;
|
||
using System.Collections;
|
||
using System.Web.Configuration;
|
||
using System.Resources;
|
||
using System.Reflection;
|
||
using System.Drawing;
|
||
using System.Drawing.Imaging;
|
||
using System.Threading;
|
||
using System.Collections.Specialized;
|
||
using System.Diagnostics;
|
||
using System.Web.Hosting;
|
||
using System.Web.SessionState;
|
||
using System.Drawing.Drawing2D;
|
||
using System.Runtime.InteropServices;
|
||
using System.Globalization;
|
||
using System.Diagnostics.CodeAnalysis;
|
||
using System.Security.Permissions;
|
||
using System.Security;
|
||
using System.Security.Cryptography;
|
||
using System.Collections.ObjectModel;
|
||
using System.Web.UI.WebControls;
|
||
|
||
#endregion //Namespaces
|
||
|
||
namespace System.Web.UI.DataVisualization.Charting
|
||
{
|
||
/// <summary>
|
||
/// ChartHttpHandler processes HTTP Web requests using, handles chart images, scripts and other resources.
|
||
/// </summary>
|
||
#if ASPPERM_35
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
#endif
|
||
public class ChartHttpHandler : Page, IRequiresSessionState, IHttpHandler
|
||
{
|
||
|
||
#region Fields
|
||
|
||
// flag that indicates whether this chart handler is installed
|
||
private static bool _installed = false;
|
||
|
||
// flag that indicates whether this chart handler is installed
|
||
private static bool _installChecked = false;
|
||
|
||
// storage settings
|
||
private static ChartHttpHandlerSettings _parameters = null;
|
||
|
||
|
||
// machine hash key which is part in chart image file name
|
||
private static string _machineHash = "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture) + "_";
|
||
|
||
// web gadren controller file. stays locked diring process lifetime.
|
||
private static FileStream _controllerFileStream = null;
|
||
private static string _controllerDirectory = null;
|
||
private static object _initHandlerLock = new object();
|
||
// used for storing Guid key in context;
|
||
internal static string ContextGuidKey = "{89FA5660-BD13-4f1b-8C7C-355CEC92CC7E}";
|
||
|
||
// web gadren controller file. stays locked diring process lifetime.
|
||
private const string handlerCheckQry = "check";
|
||
|
||
#endregion //Fields
|
||
|
||
#region Consts
|
||
|
||
internal const string ChartHttpHandlerName = "ChartImg.axd";
|
||
internal const string ChartHttpHandlerAppSection = "ChartImageHandler";
|
||
internal const string DefaultConfigSettings = @"storage=file;timeout=20;dir=c:\TempImageFiles\;";
|
||
internal const string WebDevServerUseConfigSettings = "WebDevServerUseConfigSettings";
|
||
#endregion //Consts
|
||
|
||
#region Constructors
|
||
|
||
/// <summary>
|
||
/// Ensures that the handler is initialized.
|
||
/// </summary>
|
||
/// <param name="hardCheck">if set to <c>true</c> then will be thrown all excepitons.</param>
|
||
private static void EnsureInitialized(bool hardCheck)
|
||
{
|
||
if (_installChecked)
|
||
{
|
||
return;
|
||
}
|
||
lock (_initHandlerLock)
|
||
{
|
||
if (_installChecked)
|
||
{
|
||
return;
|
||
}
|
||
if (HttpContext.Current != null)
|
||
{
|
||
try
|
||
{
|
||
using (TextWriter w = new StringWriter(CultureInfo.InvariantCulture))
|
||
{
|
||
HttpContext.Current.Server.Execute(ChartHttpHandlerName + "?" + handlerCheckQry + "=0", w);
|
||
}
|
||
_installed = true;
|
||
}
|
||
catch (HttpException)
|
||
{
|
||
if (hardCheck) throw;
|
||
}
|
||
catch (SecurityException)
|
||
{
|
||
// under minimal configuration we assume that the hanlder is installed if app settings are present.
|
||
_installed = !String.IsNullOrEmpty(WebConfigurationManager.AppSettings[ChartHttpHandlerAppSection]);
|
||
}
|
||
}
|
||
if (_installed || hardCheck)
|
||
{
|
||
InitializeControllerFile();
|
||
}
|
||
_installChecked = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initializes the storage settings
|
||
/// </summary>
|
||
//static ChartHttpHandler()
|
||
private static ChartHttpHandlerSettings InitializeParameters()
|
||
{
|
||
|
||
ChartHttpHandlerSettings result = new ChartHttpHandlerSettings();
|
||
if (HttpContext.Current != null)
|
||
{
|
||
// Read settings from config; use DefaultConfigSettings in case when setting is not found
|
||
string configSettings = WebConfigurationManager.AppSettings[ChartHttpHandlerAppSection];
|
||
if (String.IsNullOrEmpty(configSettings))
|
||
configSettings = DefaultConfigSettings;
|
||
|
||
result = new ChartHttpHandlerSettings(configSettings);
|
||
}
|
||
else
|
||
{
|
||
result.PrepareDesignTime();
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static void ResetControllerStream()
|
||
{
|
||
if (_controllerFileStream != null)
|
||
_controllerFileStream.Dispose();
|
||
_controllerFileStream = null;
|
||
_controllerDirectory = null;
|
||
}
|
||
|
||
private static void InitializeControllerFile()
|
||
{
|
||
if (Settings.StorageType == ChartHttpHandlerStorageType.File && _controllerFileStream == null)
|
||
{
|
||
byte[] data = System.Text.Encoding.UTF8.GetBytes("chart io controller file");
|
||
// 2048 processes max.
|
||
for (Int32 i = 0; i < 2048; i++)
|
||
{
|
||
try
|
||
{
|
||
ResetControllerStream();
|
||
string controllerFileName = String.Format(CultureInfo.InvariantCulture, "{0}msc_cntr_{1}.txt", Settings.Directory, i);
|
||
_controllerDirectory = String.Format(CultureInfo.InvariantCulture, "charts_{0}", i);
|
||
_controllerFileStream = new System.IO.FileStream(controllerFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
|
||
_controllerFileStream.Lock(0, data.Length);
|
||
_controllerFileStream.Write(data, 0, data.Length);
|
||
_machineHash = "_" + i + "_";
|
||
if (!Directory.Exists(Settings.Directory + _controllerDirectory))
|
||
{
|
||
Directory.CreateDirectory(Settings.Directory + _controllerDirectory);
|
||
}
|
||
else
|
||
{
|
||
TimeSpan lastWrite = DateTime.Now - Directory.GetLastWriteTime(Settings.Directory + _controllerDirectory);
|
||
if (lastWrite.Seconds < Settings.Timeout.Seconds)
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
catch (IOException)
|
||
{
|
||
continue;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
ResetControllerStream();
|
||
throw;
|
||
}
|
||
}
|
||
ResetControllerStream();
|
||
throw new UnauthorizedAccessException(SR.ExceptionHttpHandlerTempDirectoryUnaccesible(Settings.Directory));
|
||
}
|
||
}
|
||
|
||
#endregion //Constructors
|
||
|
||
#region Methods
|
||
|
||
#region ChartImage
|
||
|
||
/// <summary>
|
||
/// Processes the saved image.
|
||
/// </summary>
|
||
/// <param name="context">The context.</param>
|
||
/// <returns>false if the image cannot be processed</returns>
|
||
private static bool ProcessSavedChartImage(HttpContext context)
|
||
{
|
||
// image delivery doesn't depend if handler is intitilzed or not.
|
||
String key = context.Request["i"];
|
||
CurrentGuidKey = context.Request["g"];
|
||
IChartStorageHandler handler = GetHandler();
|
||
try
|
||
{
|
||
Byte[] data = handler.Load(KeyToUnc(key));
|
||
if (data != null && data.Length > 0)
|
||
{
|
||
context.Response.Charset = "";
|
||
context.Response.ContentType = GetMime(key);
|
||
context.Response.BinaryWrite(data);
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServed(key), null);
|
||
if (Settings.StorageType == ChartHttpHandlerStorageType.Session || Settings.DeleteAfterServicing)
|
||
{
|
||
handler.Delete(key);
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageDeleted(key), null);
|
||
}
|
||
return true;
|
||
}
|
||
if (!(handler is DefaultImageHandler))
|
||
{
|
||
// the default handler will write more detailed message
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailNotFound), null);
|
||
}
|
||
}
|
||
catch (NullReferenceException nre)
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, String.Empty), nre);
|
||
throw;
|
||
}
|
||
catch (IOException ioe)
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, String.Empty), ioe);
|
||
throw;
|
||
}
|
||
catch (SecurityException se)
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, String.Empty), se);
|
||
throw;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
#endregion //ChartImage
|
||
|
||
#region Utilities
|
||
|
||
|
||
/// <summary>
|
||
/// Gets or sets the current GUID key.
|
||
/// </summary>
|
||
/// <value>The current GUID key.</value>
|
||
internal static string CurrentGuidKey
|
||
{
|
||
get
|
||
{
|
||
if (HttpContext.Current != null)
|
||
{
|
||
return (string)HttpContext.Current.Items[ContextGuidKey];
|
||
}
|
||
return String.Empty;
|
||
}
|
||
set
|
||
{
|
||
if (HttpContext.Current != null)
|
||
{
|
||
if (String.IsNullOrEmpty(value))
|
||
{
|
||
HttpContext.Current.Items.Remove(ContextGuidKey);
|
||
}
|
||
else
|
||
{
|
||
HttpContext.Current.Items[ContextGuidKey] = value;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the chart image handler interface reference.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private static IChartStorageHandler GetHandler()
|
||
{
|
||
return ChartHttpHandler.Settings.GetHandler();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Determines whether this instance is installed.
|
||
/// </summary>
|
||
internal static void EnsureInstalled()
|
||
{
|
||
EnsureInitialized(true);
|
||
EnsureSessionIsClean();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the handler URL.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private static String GetHandlerUrl()
|
||
{
|
||
// the handler have to be executed in current cxecution path in order to get proper user identity
|
||
String appDir = Path.GetDirectoryName(HttpContext.Current.Request.CurrentExecutionFilePath ?? "").Replace("\\","/");
|
||
if (!appDir.EndsWith("/", StringComparison.Ordinal))
|
||
{
|
||
appDir += "/";
|
||
}
|
||
return appDir + ChartHttpHandlerName + "?";
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Gets the MIME type by resource url.
|
||
/// </summary>
|
||
/// <param name="resourceUrl">The resource URL.</param>
|
||
/// <returns></returns>
|
||
[SuppressMessage("Microsoft.Globalization", "CA1308",
|
||
Justification = "No security decision is being made on the ToLowerInvariant() call. It is being used to ensure the file extension is lowercase")]
|
||
private static String GetMime(String resourceUrl)
|
||
{
|
||
String ext = Path.GetExtension(resourceUrl);
|
||
|
||
ext = ext.ToLowerInvariant();
|
||
|
||
if (ext == ".js")
|
||
{
|
||
return "text/javascript";
|
||
}
|
||
else if (ext == ".htm")
|
||
{
|
||
return "text/html";
|
||
}
|
||
else if (".css,.html,.xml".IndexOf(ext, StringComparison.Ordinal) != -1)
|
||
{
|
||
return "text/" + ext.Substring(1);
|
||
}
|
||
else if (".jpg;.jpeg;.gif;.png;.emf".IndexOf(ext, StringComparison.Ordinal) != -1)
|
||
{
|
||
string fmt = ext.Substring(1).Replace("jpg", "jpeg");
|
||
return "image/" + fmt;
|
||
}
|
||
return "text/plain";
|
||
}
|
||
|
||
/// <summary>
|
||
/// Generates the chart image file name (key).
|
||
/// </summary>
|
||
/// <param name="ext">The ext.</param>
|
||
/// <param name="fileName">Name of the file.</param>
|
||
/// <returns></returns>
|
||
private static String GenerateKey(String ext)
|
||
{
|
||
String fmtKey = "chart" + _machineHash + "{0}." + ext;
|
||
RingTimeTracker rt = RingTimeTrackerFactory.GetRingTracker(fmtKey);
|
||
if (!String.IsNullOrEmpty(_controllerDirectory) && String.IsNullOrEmpty(Settings.FolderName))
|
||
{
|
||
return _controllerDirectory + @"\" + rt.GetNextKey();
|
||
}
|
||
return Settings.FolderName + rt.GetNextKey();
|
||
}
|
||
|
||
private static String KeyToUnc(String key)
|
||
{
|
||
if (!String.IsNullOrEmpty(key))
|
||
{
|
||
return key.Replace("/", @"\");
|
||
}
|
||
return key;
|
||
}
|
||
|
||
private static String KeyFromUnc(String key)
|
||
{
|
||
if (!String.IsNullOrEmpty(key))
|
||
{
|
||
return key.Replace(@"\", "/");
|
||
}
|
||
return key;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a URL by specified request query, file key.
|
||
/// </summary>
|
||
/// <param name="query">The query.</param>
|
||
/// <param name="fileKey">The file key.</param>
|
||
/// <param name="currentGuid">The current GUID.</param>
|
||
/// <returns></returns>
|
||
private static String GetUrl(String query, String fileKey, string currentGuid)
|
||
{
|
||
return GetHandlerUrl() + query + "=" + KeyFromUnc(fileKey) + "&g=" + currentGuid;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the image url.
|
||
/// </summary>
|
||
/// <param name="stream">The stream.</param>
|
||
/// <param name="imageExt">The image extention.</param>
|
||
/// <returns>Generated the image source URL</returns>
|
||
[SuppressMessage("Microsoft.Globalization", "CA1308",
|
||
Justification="No security decision is being made on the ToLowerInvariant() call. It is being used to ensure the file extension is lowercase")]
|
||
internal static String GetChartImageUrl(MemoryStream stream, String imageExt)
|
||
{
|
||
EnsureInitialized(true);
|
||
// generates new guid
|
||
string guidKey = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
|
||
// set new guid in context
|
||
CurrentGuidKey = guidKey;
|
||
|
||
Int32 tryCounts = 10;
|
||
while (tryCounts > 0)
|
||
{
|
||
tryCounts--;
|
||
try
|
||
{
|
||
String key = GenerateKey(imageExt.ToLowerInvariant());
|
||
IChartStorageHandler handler = Settings.GetHandler();
|
||
handler.Save(key, stream.ToArray());
|
||
if (!(handler is DefaultImageHandler))
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageSaved(key), null);
|
||
}
|
||
Settings.FolderName = String.Empty;
|
||
// clear guid so is not accessable out of the scope;
|
||
CurrentGuidKey = String.Empty;
|
||
return ChartHttpHandler.GetUrl("i", key, guidKey);
|
||
}
|
||
catch (IOException) { }
|
||
catch { throw;}
|
||
}
|
||
throw new IOException(SR.ExceptionHttpHandlerCanNotSave);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Ensures the session is clean.
|
||
/// </summary>
|
||
private static void EnsureSessionIsClean()
|
||
{
|
||
if (!_installed) return;
|
||
if (Settings.StorageType == ChartHttpHandlerStorageType.Session)
|
||
{
|
||
IChartStorageHandler handler = ChartHttpHandler.Settings.GetHandler();
|
||
foreach (RingTimeTracker tracker in RingTimeTrackerFactory.OpenedRingTimeTrackers())
|
||
{
|
||
tracker.ForEach(true, delegate(RingItem item)
|
||
{
|
||
if (item.InUse && String.CompareOrdinal(Settings.ReadSessionKey(), item.SessionID) == 0)
|
||
{
|
||
handler.Delete(tracker.GetKey(item));
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageDeleted(tracker.GetKey(item)), null);
|
||
item.InUse = false;
|
||
}
|
||
}
|
||
);
|
||
}
|
||
}
|
||
}
|
||
#endregion //Utilities
|
||
|
||
#region Diagnostics
|
||
|
||
private static void DiagnosticWriteAll(HttpContext context)
|
||
{
|
||
HtmlTextWriter writer;
|
||
using (TextWriter w = new StringWriter(CultureInfo.CurrentCulture))
|
||
{
|
||
|
||
if (context.Request.Browser != null)
|
||
writer = context.Request.Browser.CreateHtmlTextWriter(w);
|
||
else
|
||
writer = new Html32TextWriter(w);
|
||
writer.Write("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n\r<html xmlns=\"http://www.w3.org/1999/xhtml\" >\n\r");
|
||
writer.Write("<head>\r\n");
|
||
writer.Write("<style type=\"text/css\">\r\n body, span, table, td, th, div, caption {font-family: Tahoma, Arial, Helvetica, sans-serif;font-size: 10pt;} caption {background-color:Black; color: White; font-weight:bold; padding: 4px; text-align:left; } \r\n</style>\r\n");
|
||
writer.Write("</head>\r\n<body style=\"width:978px\">\r\n");
|
||
writer.Write("<h2>" + SR.DiagnosticHeader + "</h2>\r\n<hr/><br/>\n\r");
|
||
DiagnosticWriteSettings(writer);
|
||
writer.Write("<hr/>");
|
||
DiagnosticWriteActivity(writer);
|
||
writer.Write("<br/><hr/>\n\r<span>");
|
||
try
|
||
{
|
||
writer.Write(typeof(Chart).AssemblyQualifiedName);
|
||
}
|
||
catch ( SecurityException ) {}
|
||
writer.Write("</span></body>\r\n</html>\r\n");
|
||
context.Response.Write(w.ToString());
|
||
}
|
||
}
|
||
|
||
private static void DiagnosticWriteSettings(HtmlTextWriter writer)
|
||
{
|
||
writer.Write("<h4>" + SR.DiagnosticSettingsConfig(WebConfigurationManager.AppSettings[ChartHttpHandlerAppSection]) + "</h4>");
|
||
GridView grid = CreateGridView( true);
|
||
grid.Caption = SR.DiagnosticSettingsHeader;
|
||
BoundField field = new BoundField();
|
||
field.DataField = "Key";
|
||
field.HeaderText = SR.DiagnosticSettingsKey;
|
||
field.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
|
||
grid.Columns.Add(field);
|
||
|
||
field = new BoundField();
|
||
field.DataField = "Value";
|
||
field.HeaderText = SR.DiagnosticSettingsValue;
|
||
field.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
|
||
|
||
grid.Columns.Add(field);
|
||
Dictionary<String, String> settings = new Dictionary<String, String>();
|
||
|
||
settings.Add("StorageType", Settings.StorageType.ToString());
|
||
settings.Add("TimeOut", Settings.Timeout.ToString());
|
||
if (Settings.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
settings.Add("Directory", Settings.Directory);
|
||
}
|
||
settings.Add("DeleteAfterServicing", Settings.DeleteAfterServicing.ToString());
|
||
settings.Add("PrivateImages", Settings.PrivateImages.ToString());
|
||
settings.Add("ImageOwnerKey", Settings.ImageOwnerKey.ToString());
|
||
settings.Add("CustomHandlerName", Settings.CustomHandlerName);
|
||
settings.Add(ChartHttpHandler.WebDevServerUseConfigSettings, String.Equals(Settings[ChartHttpHandler.WebDevServerUseConfigSettings], "true", StringComparison.OrdinalIgnoreCase).ToString());
|
||
|
||
grid.DataSource = settings;
|
||
grid.DataBind();
|
||
|
||
grid.RenderControl(writer);
|
||
|
||
}
|
||
|
||
private static void DiagnosticWriteActivity(HtmlTextWriter writer)
|
||
{
|
||
GridView grid = CreateGridView( true);
|
||
grid.Caption = SR.DiagnosticActivityHeader;
|
||
BoundField field = new BoundField();
|
||
field.DataField = "DateStamp";
|
||
field.ItemStyle.VerticalAlign = VerticalAlign.Top;
|
||
field.HeaderText = SR.DiagnosticActivityTime;
|
||
field.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
|
||
field.HeaderStyle.Width = 150;
|
||
grid.Columns.Add(field);
|
||
|
||
field = new BoundField();
|
||
field.DataField = "Url";
|
||
field.HeaderText = SR.DiagnosticActivityMessage;
|
||
field.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
|
||
|
||
grid.Columns.Add(field);
|
||
|
||
grid.RowDataBound += new GridViewRowEventHandler(DiagnosticActivityGrid_RowDataBound);
|
||
|
||
grid.DataSource = Diagnostics.Messages;
|
||
grid.DataBind();
|
||
grid.RenderControl(writer);
|
||
|
||
}
|
||
|
||
static void DiagnosticActivityGrid_RowDataBound(object sender, GridViewRowEventArgs e)
|
||
{
|
||
if (e.Row.RowType == DataControlRowType.DataRow)
|
||
{
|
||
Diagnostics.HandlerPageTraceInfo currentInfo = (Diagnostics.HandlerPageTraceInfo)e.Row.DataItem;
|
||
TableCell cell = e.Row.Cells[1];
|
||
|
||
cell.Controls.Add(new Label() { Text = currentInfo.Verb + "," + currentInfo.Url });
|
||
|
||
GridView grid = CreateGridView(false);
|
||
grid.Style[HtmlTextWriterStyle.MarginLeft] = "20px";
|
||
|
||
grid.ShowHeader = false;
|
||
|
||
BoundField field = new BoundField();
|
||
field.DataField = "Text";
|
||
field.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
|
||
grid.Columns.Add(field);
|
||
|
||
grid.DataSource = currentInfo.Events;
|
||
grid.DataBind();
|
||
cell.Controls.Add(grid);
|
||
}
|
||
}
|
||
|
||
private static GridView CreateGridView(bool withAlternateStyle)
|
||
{
|
||
GridView result = new GridView();
|
||
|
||
result.AutoGenerateColumns = false;
|
||
result.CellPadding = 4;
|
||
result.Font.Names = new string[] { "Tahoma", "Ariel" };
|
||
result.Font.Size = new FontUnit(10, UnitType.Point);
|
||
result.BorderWidth = 0;
|
||
result.GridLines = GridLines.None;
|
||
result.Width = new Unit(100, UnitType.Percentage);
|
||
|
||
if (withAlternateStyle)
|
||
{
|
||
result.AlternatingRowStyle.BackColor = Color.White;
|
||
result.RowStyle.BackColor = ColorTranslator.FromHtml("#efefef");
|
||
result.RowStyle.ForeColor = Color.Black;
|
||
result.AlternatingRowStyle.ForeColor = Color.Black;
|
||
}
|
||
|
||
result.HeaderStyle.BackColor = Color.Gray;
|
||
result.HeaderStyle.ForeColor = Color.White;
|
||
result.HeaderStyle.Font.Bold = true;
|
||
return result;
|
||
}
|
||
|
||
#endregion //Diagnostics
|
||
|
||
#endregion //Methods
|
||
|
||
#region Properties
|
||
|
||
/// <summary>
|
||
/// Gets the chart image storage settings registred in web.config file under ChartHttpHandler key.
|
||
/// </summary>
|
||
/// <value>The settings.</value>
|
||
public static ChartHttpHandlerSettings Settings
|
||
{
|
||
get
|
||
{
|
||
if (_parameters == null)
|
||
{
|
||
_parameters = InitializeParameters();
|
||
}
|
||
return _parameters;
|
||
}
|
||
}
|
||
|
||
#endregion //Properties
|
||
|
||
#region IHttpHandler Members
|
||
|
||
/// <summary>
|
||
/// Gets a value indicating whether the <see cref="T:System.Web.UI.Page"/> object can be reused.
|
||
/// </summary>
|
||
/// <value></value>
|
||
/// <returns>false in all cases. </returns>
|
||
bool IHttpHandler.IsReusable
|
||
{
|
||
get { return true; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"></see> interface.
|
||
/// </summary>
|
||
/// <param name="context">An <see cref="T:System.Web.HttpContext"></see> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
|
||
void IHttpHandler.ProcessRequest(HttpContext context)
|
||
{
|
||
if (context.Request["i"] != null && ProcessSavedChartImage(context))
|
||
{
|
||
return;
|
||
}
|
||
else if (context.Request["trace"] != null && Diagnostics.IsTraceEnabled)
|
||
{
|
||
DiagnosticWriteAll(context);
|
||
return;
|
||
}
|
||
else if (context.Request[handlerCheckQry] != null)
|
||
{
|
||
// handler execute test - returns no errors.
|
||
return;
|
||
}
|
||
context.Response.StatusCode = 404;
|
||
context.Response.StatusDescription = SR.ExceptionHttpHandlerImageNotFound;
|
||
}
|
||
|
||
#endregion
|
||
|
||
}
|
||
|
||
#region Enumerations
|
||
|
||
/// <summary>
|
||
/// Determines chart image storage medium
|
||
/// </summary>
|
||
public enum ChartHttpHandlerStorageType
|
||
{
|
||
/// <summary>
|
||
/// Static into application memory
|
||
/// </summary>
|
||
InProcess,
|
||
|
||
/// <summary>
|
||
/// File system
|
||
/// </summary>
|
||
File,
|
||
/// <summary>
|
||
/// Using session as storage
|
||
/// </summary>
|
||
Session
|
||
|
||
}
|
||
/// <summary>
|
||
/// Determines the image owner key for privacy protection.
|
||
/// </summary>
|
||
internal enum ImageOwnerKeyType
|
||
{
|
||
/// <summary>
|
||
/// No privacy protection.
|
||
/// </summary>
|
||
None,
|
||
/// <summary>
|
||
/// The key will be automatically determined.
|
||
/// </summary>
|
||
Auto,
|
||
/// <summary>
|
||
/// The user name will be used as key.
|
||
/// </summary>
|
||
UserID,
|
||
/// <summary>
|
||
/// The AnonymousID will be used as key.
|
||
/// </summary>
|
||
AnonymousID,
|
||
/// <summary>
|
||
/// The SessionID will be used as key.
|
||
/// </summary>
|
||
SessionID
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region IChartStorageHandler interface
|
||
|
||
/// <summary>
|
||
/// Defines methods to manage rendered chart images in a storage.
|
||
/// </summary>
|
||
public interface IChartStorageHandler
|
||
{
|
||
/// <summary>
|
||
/// Saves the data into external medium.
|
||
/// </summary>
|
||
/// <param name="key">Index key.</param>
|
||
/// <param name="data">Image data.</param>
|
||
void Save(String key, Byte[] data);
|
||
|
||
|
||
/// <summary>
|
||
/// Loads the data from external medium.
|
||
/// </summary>
|
||
/// <param name="key">Index key.</param>
|
||
/// <returns>A byte array with image data</returns>
|
||
Byte[] Load(String key);
|
||
|
||
|
||
/// <summary>
|
||
/// Deletes the data from external medium.
|
||
/// </summary>
|
||
/// <param name="key">Index key.</param>
|
||
void Delete(String key);
|
||
|
||
/// <summary>
|
||
/// Checks for existence of data under specified key.
|
||
/// </summary>
|
||
/// <param name="key">Index key.</param>
|
||
/// <returns>True if data exists under specified key</returns>
|
||
bool Exists(String key);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ChartHttpHandlerSettings Class
|
||
|
||
/// <summary>
|
||
/// Enables access to the chart image storage settings.
|
||
/// </summary>
|
||
#if ASPPERM_35
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
#endif
|
||
public class ChartHttpHandlerSettings
|
||
{
|
||
#region Fields
|
||
|
||
private StorageSettingsCollection _ssCollection = new StorageSettingsCollection();
|
||
|
||
private string _sesionKey = "chartKey-" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
|
||
|
||
#endregion //Fields
|
||
|
||
#region Properties
|
||
|
||
private ChartHttpHandlerStorageType _chartImageStorage = ChartHttpHandlerStorageType.File;
|
||
|
||
/// <summary>
|
||
/// Gets or sets the chart image storage type.
|
||
/// </summary>
|
||
/// <value>The chart image storage.</value>
|
||
public ChartHttpHandlerStorageType StorageType
|
||
{
|
||
get { return _chartImageStorage; }
|
||
set { _chartImageStorage = value; }
|
||
}
|
||
|
||
private TimeSpan _timeout = TimeSpan.FromSeconds(30);
|
||
|
||
/// <summary>
|
||
/// Gets or sets the timeout.
|
||
/// </summary>
|
||
/// <value>The timeout.</value>
|
||
public TimeSpan Timeout
|
||
{
|
||
get { return _timeout; }
|
||
set { _timeout = value; }
|
||
}
|
||
|
||
private String _url = "~/";
|
||
/// <summary>
|
||
/// Gets or sets the URL.
|
||
/// </summary>
|
||
/// <value>The URL.</value>
|
||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings")]
|
||
public String Url
|
||
{
|
||
get { return _url; }
|
||
set { _url = value; }
|
||
}
|
||
|
||
private String _directory = String.Empty;
|
||
/// <summary>
|
||
/// Gets or sets the directory.
|
||
/// </summary>
|
||
/// <value>The directory.</value>
|
||
public String Directory
|
||
{
|
||
get { return _directory; }
|
||
set { _directory = value; }
|
||
}
|
||
|
||
private const String _folderKeyName = "{5FF3B636-70BA-4180-B7C5-FDD77D8FA525}";
|
||
/// <summary>
|
||
/// Gets or sets the folder which will be used for storing images under <see cref="Directory"/>.
|
||
/// </summary>
|
||
/// <value>The folder name.</value>
|
||
public String FolderName
|
||
{
|
||
get
|
||
{
|
||
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(_folderKeyName))
|
||
{
|
||
return (string)HttpContext.Current.Items[_folderKeyName];
|
||
}
|
||
return String.Empty;
|
||
}
|
||
set
|
||
{
|
||
if (!String.IsNullOrEmpty(value))
|
||
{
|
||
if (!(value.EndsWith("/", StringComparison.Ordinal) || value.EndsWith("\\", StringComparison.Ordinal)))
|
||
{
|
||
value += "\\";
|
||
}
|
||
this.ValidateUri(value);
|
||
}
|
||
if (HttpContext.Current != null)
|
||
{
|
||
HttpContext.Current.Items[_folderKeyName] = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
internal void ValidateUri(string key)
|
||
{
|
||
if (this.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
FileInfo fi = new FileInfo(this.Directory + key);
|
||
Uri directory = new Uri(this.Directory);
|
||
Uri combinedDirectory = new Uri(fi.FullName);
|
||
if (directory.IsBaseOf(combinedDirectory))
|
||
{
|
||
// it is fine.
|
||
return;
|
||
}
|
||
throw new UnauthorizedAccessException(SR.ExceptionHttpHandlerInvalidLocation);
|
||
}
|
||
}
|
||
|
||
private String _customHandlerName = typeof(DefaultImageHandler).FullName;
|
||
/// <summary>
|
||
/// Gets or sets the name of the custom handler.
|
||
/// </summary>
|
||
/// <value>The name of the custom handler.</value>
|
||
public String CustomHandlerName
|
||
{
|
||
get { return _customHandlerName; }
|
||
set { _customHandlerName = value; }
|
||
}
|
||
|
||
|
||
private Type _customHandlerType = null;
|
||
/// <summary>
|
||
/// Gets the type of the custom handler.
|
||
/// </summary>
|
||
/// <value>The type of the custom handler.</value>
|
||
public Type HandlerType
|
||
{
|
||
get
|
||
{
|
||
if (this._customHandlerType == null)
|
||
{
|
||
this._customHandlerType = Type.GetType(this.CustomHandlerName, true);
|
||
}
|
||
return this._customHandlerType;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a value indicating whether the handler will utilize private images.
|
||
/// </summary>
|
||
/// <value><c>true</c> if the handler will utilize private images; otherwise, <c>false</c>.</value>
|
||
/// <remarks>
|
||
/// When PrivateImages is set the handler will not return images out of session scope and
|
||
/// the client will not be able to download somebody else's images. This is default behavoiur.
|
||
/// </remarks>
|
||
public bool PrivateImages
|
||
{
|
||
get
|
||
{
|
||
return ImageOwnerKey != ImageOwnerKeyType.None;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Gets a settings parameter with the specified name registred in web.config file under ChartHttpHandler key.
|
||
/// </summary>
|
||
/// <value></value>
|
||
public string this[string name]
|
||
{
|
||
get
|
||
{
|
||
return this._ssCollection[name];
|
||
}
|
||
}
|
||
|
||
#endregion //Properties
|
||
|
||
#region Constructors
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="T:StorageSettings"/> class.
|
||
/// </summary>
|
||
internal ChartHttpHandlerSettings()
|
||
{
|
||
ImageOwnerKey = ImageOwnerKeyType.Auto;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="T:ChartHttpHandlerParameters"/> class.
|
||
/// </summary>
|
||
/// <param name="parameters">The parameters.</param>
|
||
internal ChartHttpHandlerSettings(String parameters) : this()
|
||
{
|
||
this.ParseParams(parameters);
|
||
this._ssCollection.SetReadOnly(true);
|
||
}
|
||
|
||
#endregion //Constructors
|
||
|
||
#region Methods
|
||
|
||
private ConstructorInfo _handlerConstructor = null;
|
||
IChartStorageHandler _storageHandler = null;
|
||
/// <summary>
|
||
/// Creates the handler instance.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
internal IChartStorageHandler GetHandler()
|
||
{
|
||
if (_storageHandler == null)
|
||
{
|
||
if (this._handlerConstructor == null)
|
||
{
|
||
this.InspectHandlerLoader();
|
||
}
|
||
_storageHandler = this._handlerConstructor.Invoke(new object[0]) as IChartStorageHandler;
|
||
}
|
||
return _storageHandler;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Inspects the handler if it is valid.
|
||
/// </summary>
|
||
private void InspectHandlerLoader()
|
||
{
|
||
this._handlerConstructor = this.HandlerType.GetConstructor(
|
||
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
|
||
null,
|
||
new Type[0],
|
||
new ParameterModifier[0]);
|
||
if (this._handlerConstructor == null)
|
||
{
|
||
throw new InvalidOperationException( SR.ExceptionHttpHandlerCanNotLoadType( this.HandlerType.FullName ));
|
||
}
|
||
if (this.GetHandler() == null)
|
||
{
|
||
throw new InvalidOperationException(SR.ExceptionHttpHandlerImageHandlerInterfaceUnsupported(ChartHttpHandler.Settings.HandlerType.FullName));
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Parses the params from web.config file key.
|
||
/// </summary>
|
||
/// <param name="parameters">The parameters.</param>
|
||
private void ParseParams(String parameters)
|
||
{
|
||
if (!String.IsNullOrEmpty(parameters))
|
||
{
|
||
|
||
String[] pairs = parameters.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
|
||
for (int index = 0; index < pairs.Length; index++)
|
||
{
|
||
String item = pairs[index].Trim();
|
||
int eqPositon = item.IndexOf('=');
|
||
if (eqPositon != -1)
|
||
{
|
||
String name = item.Substring(0, eqPositon).Trim();
|
||
String value = item.Substring(eqPositon + 1).Trim();
|
||
this._ssCollection.Add(name, value);
|
||
if (name.StartsWith("stor", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
if (value.StartsWith("inproc", StringComparison.OrdinalIgnoreCase) || value.StartsWith("memory", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
this.StorageType = ChartHttpHandlerStorageType.InProcess;
|
||
}
|
||
else if (value.StartsWith("file", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
this.StorageType = ChartHttpHandlerStorageType.File;
|
||
}
|
||
else if (value.StartsWith("session", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
this.StorageType = ChartHttpHandlerStorageType.Session;
|
||
}
|
||
else
|
||
{
|
||
throw new System.Configuration.SettingsPropertyWrongTypeException(SR.ExceptionHttpHandlerParameterUnknown(name, value));
|
||
}
|
||
}
|
||
else if (name.StartsWith("url", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
if (!value.EndsWith("/", StringComparison.Ordinal))
|
||
{
|
||
value += "/";
|
||
}
|
||
this.Url = value;
|
||
}
|
||
else if (name.StartsWith("dir", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
this.Directory = value;
|
||
}
|
||
else if (name.StartsWith("time", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
try
|
||
{
|
||
int seconds = Int32.Parse(value, CultureInfo.InvariantCulture);
|
||
if (seconds < -1)
|
||
{
|
||
throw new System.Configuration.SettingsPropertyWrongTypeException(SR.ExceptionHttpHandlerValueInvalid);
|
||
}
|
||
if (seconds == -1)
|
||
{
|
||
this.Timeout = TimeSpan.MaxValue;
|
||
}
|
||
else
|
||
{
|
||
this.Timeout = TimeSpan.FromSeconds(seconds);
|
||
}
|
||
}
|
||
catch (Exception exception)
|
||
{
|
||
throw new System.Configuration.SettingsPropertyWrongTypeException(SR.ExceptionHttpHandlerTimeoutParameterInvalid, exception);
|
||
}
|
||
}
|
||
else if (name.StartsWith("handler", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
this.CustomHandlerName = value;
|
||
}
|
||
else if (name.StartsWith("privateImages", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
bool privateImg = true;
|
||
if (Boolean.TryParse(value, out privateImg) && !privateImg)
|
||
{
|
||
ImageOwnerKey = ImageOwnerKeyType.None;
|
||
}
|
||
}
|
||
else if (name.StartsWith("imageOwnerKey", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
try
|
||
{
|
||
ImageOwnerKey = (ImageOwnerKeyType)Enum.Parse(typeof(ImageOwnerKeyType), value, true);
|
||
}
|
||
catch (ArgumentException)
|
||
{
|
||
throw new System.Configuration.SettingsPropertyWrongTypeException(SR.ExceptionHttpHandlerParameterInvalid(name, value));
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
this.Inspect();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Determines whether web dev server is active.
|
||
/// </summary>
|
||
/// <returns>
|
||
/// <c>true</c> if web dev server active; otherwise, <c>false</c>.
|
||
/// </returns>
|
||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "GetCurrentProcess will fail if there is no access. This is by design. ")]
|
||
// VSTS: 5176 Security annotation violations in System.Web.DataVisualization.dll
|
||
[SecuritySafeCritical]
|
||
private static bool IsWebDevActive()
|
||
{
|
||
try
|
||
{
|
||
Process process = Process.GetCurrentProcess();
|
||
if (process.ProcessName.StartsWith("WebDev.WebServer", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return true;
|
||
}
|
||
if (process.ProcessName.StartsWith("ii----press", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
catch (SecurityException)
|
||
{
|
||
}
|
||
return false;
|
||
}
|
||
/// <summary>
|
||
/// Inspects and validates this instance after loading params.
|
||
/// </summary>
|
||
internal void Inspect()
|
||
{
|
||
switch (this.StorageType)
|
||
{
|
||
case ChartHttpHandlerStorageType.InProcess:
|
||
|
||
break;
|
||
|
||
case ChartHttpHandlerStorageType.File:
|
||
|
||
if (IsWebDevActive() && !( String.Compare(this[ChartHttpHandler.WebDevServerUseConfigSettings], "true", StringComparison.OrdinalIgnoreCase) == 0))
|
||
{
|
||
this.StorageType = ChartHttpHandlerStorageType.InProcess;
|
||
break;
|
||
}
|
||
|
||
if (String.IsNullOrEmpty(this.Url))
|
||
{
|
||
throw new ArgumentException(SR.ExceptionHttpHandlerUrlMissing);
|
||
}
|
||
|
||
String fileDirectory = this.Directory;
|
||
if (String.IsNullOrEmpty(fileDirectory))
|
||
{
|
||
try
|
||
{
|
||
fileDirectory = HttpContext.Current.Server.MapPath(this.Url);
|
||
}
|
||
catch (Exception exception)
|
||
{
|
||
throw new InvalidOperationException(SR.ExceptionHttpHandlerUrlInvalid, exception);
|
||
}
|
||
}
|
||
fileDirectory = fileDirectory.Replace("/", "\\");
|
||
if (!fileDirectory.EndsWith("\\", StringComparison.Ordinal))
|
||
{
|
||
fileDirectory += "\\";
|
||
}
|
||
|
||
if (!System.IO.Directory.Exists(fileDirectory))
|
||
{
|
||
throw new DirectoryNotFoundException(SR.ExceptionHttpHandlerTempDirectoryInvalid(fileDirectory));
|
||
}
|
||
Exception thrown = null;
|
||
try
|
||
{
|
||
String testFileName = fileDirectory + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
|
||
using (FileStream fileStream = File.Create(testFileName)) { }
|
||
File.Delete(testFileName);
|
||
|
||
}
|
||
catch (DirectoryNotFoundException exception)
|
||
{
|
||
thrown = exception;
|
||
}
|
||
catch (NotSupportedException exception)
|
||
{
|
||
thrown = exception;
|
||
}
|
||
catch (PathTooLongException exception)
|
||
{
|
||
thrown = exception;
|
||
}
|
||
catch (UnauthorizedAccessException exception)
|
||
{
|
||
thrown = exception;
|
||
}
|
||
|
||
if (thrown != null)
|
||
{
|
||
throw new UnauthorizedAccessException(SR.ExceptionHttpHandlerTempDirectoryUnaccesible(fileDirectory));
|
||
}
|
||
|
||
this.Directory = fileDirectory;
|
||
break;
|
||
|
||
|
||
}
|
||
if (!String.IsNullOrEmpty(this.CustomHandlerName))
|
||
{
|
||
this.InspectHandlerLoader();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Prepares the design time params.
|
||
/// </summary>
|
||
internal void PrepareDesignTime()
|
||
{
|
||
this.StorageType = ChartHttpHandlerStorageType.File;
|
||
this.Timeout = TimeSpan.FromSeconds(3); ;
|
||
this.Url = Path.GetTempPath();
|
||
this.Directory = Path.GetTempPath();
|
||
}
|
||
|
||
internal string ReadSessionKey()
|
||
{
|
||
if (HttpContext.Current.Session != null)
|
||
{
|
||
// initialize session (if is empty any postsequent request will have different id);
|
||
if (HttpContext.Current.Session.IsNewSession)
|
||
{
|
||
if (HttpContext.Current.Session.IsReadOnly)
|
||
{
|
||
return string.Empty;
|
||
}
|
||
HttpContext.Current.Session[this._sesionKey] = 0;
|
||
}
|
||
return HttpContext.Current.Session.SessionID;
|
||
}
|
||
return String.Empty;
|
||
}
|
||
|
||
internal string GetPrivacyKey( out ImageOwnerKeyType keyType )
|
||
{
|
||
if (ImageOwnerKey == ImageOwnerKeyType.None)
|
||
{
|
||
keyType = ImageOwnerKeyType.None;
|
||
return String.Empty;
|
||
}
|
||
if (HttpContext.Current != null)
|
||
{
|
||
switch (ImageOwnerKey)
|
||
{
|
||
case ImageOwnerKeyType.Auto:
|
||
if (HttpContext.Current.User.Identity.IsAuthenticated)
|
||
{
|
||
keyType = ImageOwnerKeyType.UserID;
|
||
return HttpContext.Current.User.Identity.Name;
|
||
}
|
||
if (!String.IsNullOrEmpty(HttpContext.Current.Request.AnonymousID))
|
||
{
|
||
keyType = ImageOwnerKeyType.AnonymousID;
|
||
return HttpContext.Current.Request.AnonymousID;
|
||
}
|
||
string sessionId = ReadSessionKey();
|
||
keyType = String.IsNullOrEmpty(sessionId) ? ImageOwnerKeyType.None : ImageOwnerKeyType.SessionID;
|
||
return sessionId;
|
||
|
||
case ImageOwnerKeyType.UserID:
|
||
if (!HttpContext.Current.User.Identity.IsAuthenticated)
|
||
{
|
||
throw new InvalidOperationException(SR.ExceptionHttpHandlerPrivacyKeyInvalid("ImageOwnerKey", ImageOwnerKey.ToString()));
|
||
}
|
||
keyType = ImageOwnerKeyType.UserID;
|
||
return HttpContext.Current.User.Identity.Name;
|
||
|
||
case ImageOwnerKeyType.AnonymousID:
|
||
if (String.IsNullOrEmpty(HttpContext.Current.Request.AnonymousID))
|
||
{
|
||
throw new InvalidOperationException(SR.ExceptionHttpHandlerPrivacyKeyInvalid("ImageOwnerKey", ImageOwnerKey.ToString()));
|
||
}
|
||
keyType = ImageOwnerKeyType.AnonymousID;
|
||
return HttpContext.Current.Request.AnonymousID;
|
||
|
||
case ImageOwnerKeyType.SessionID:
|
||
if (HttpContext.Current.Session == null)
|
||
{
|
||
throw new InvalidOperationException(SR.ExceptionHttpHandlerPrivacyKeyInvalid("ImageOwnerKey", ImageOwnerKey.ToString()));
|
||
}
|
||
keyType = ImageOwnerKeyType.SessionID;
|
||
return ReadSessionKey();
|
||
|
||
default:
|
||
Debug.Fail("Unknown ImageOwnerKeyType.");
|
||
break;
|
||
}
|
||
}
|
||
keyType = ImageOwnerKeyType.None;
|
||
return string.Empty;
|
||
}
|
||
|
||
internal string PrivacyKey
|
||
{
|
||
get
|
||
{
|
||
ImageOwnerKeyType keyType;
|
||
return GetPrivacyKey(out keyType);
|
||
}
|
||
}
|
||
|
||
internal bool DeleteAfterServicing
|
||
{
|
||
get
|
||
{
|
||
// default, if is missing in config, is true.
|
||
return !(String.Compare(this["DeleteAfterServicing"], "false", StringComparison.OrdinalIgnoreCase) == 0);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the image owner key type.
|
||
/// </summary>
|
||
/// <value>The image owner key.</value>
|
||
internal ImageOwnerKeyType ImageOwnerKey { get; set; }
|
||
|
||
#endregion //Methods
|
||
|
||
#region SettingsCollection Class
|
||
|
||
private class StorageSettingsCollection : NameValueCollection
|
||
{
|
||
public StorageSettingsCollection()
|
||
: base(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
}
|
||
internal void SetReadOnly(bool flag)
|
||
{
|
||
this.IsReadOnly = flag;
|
||
}
|
||
}
|
||
|
||
#endregion //SettingsCollection Class
|
||
}
|
||
|
||
#endregion ChartHttpHandlerParameters
|
||
|
||
#region DefaultImageHandler Class
|
||
|
||
/// <summary>
|
||
/// Default implementation of ChartHttpHandler.IImageHandler interface
|
||
/// </summary>
|
||
internal class DefaultImageHandler : IChartStorageHandler
|
||
{
|
||
|
||
#region Fields
|
||
// Hashtable for storage
|
||
private static Hashtable _storageData = new Hashtable();
|
||
// lock object
|
||
private static ReaderWriterLock _rwl = new ReaderWriterLock();
|
||
// max access timeout
|
||
private const int accessTimeout = 10000;
|
||
|
||
static string _privacyKeyName = "_pk";
|
||
static byte[] _privacyMarker = (new Guid("332E3AB032904bceA82B249C25E65CB6")).ToByteArray();
|
||
static string _sessionKeyPrefix = "chart-3ece47b3-9481-4b22-ab45-ab669972eb79";
|
||
|
||
#endregion //Fields
|
||
|
||
#region Constructors
|
||
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="T:DefaultImageHandler"/> class.
|
||
/// </summary>
|
||
internal DefaultImageHandler()
|
||
{
|
||
}
|
||
#endregion //Constructors
|
||
|
||
#region Members
|
||
/// <summary>
|
||
/// Nots the type of the supported storage.
|
||
/// </summary>
|
||
/// <param name="settings">The settings.</param>
|
||
private void NotSupportedStorageType(ChartHttpHandlerSettings settings)
|
||
{
|
||
throw new NotSupportedException( SR.ExceptionHttpHandlerStorageTypeUnsupported( settings.StorageType.ToString() ));
|
||
}
|
||
|
||
#endregion //Members
|
||
|
||
#region Methods
|
||
|
||
/// <summary>
|
||
/// Returns privacy hash which will be save in the file.
|
||
/// </summary>
|
||
/// <returns>A byte array of hash data</returns>
|
||
private static byte[] GetHashData()
|
||
{
|
||
string currentGuid = ChartHttpHandler.CurrentGuidKey;
|
||
string sessionID = ChartHttpHandler.Settings.PrivacyKey;
|
||
|
||
if (String.IsNullOrEmpty(sessionID))
|
||
{
|
||
return new byte[0];
|
||
}
|
||
|
||
byte[] data = Encoding.UTF8.GetBytes(sessionID + "/" + currentGuid);
|
||
|
||
using (SHA1 sha = new SHA1CryptoServiceProvider())
|
||
{
|
||
return sha.ComputeHash(data);
|
||
}
|
||
|
||
}
|
||
|
||
private static bool CompareBytes(byte[] a, byte[] b)
|
||
{
|
||
if (a.Length != b.Length) return false;
|
||
for (int i = 0; i < a.Length; i++)
|
||
{
|
||
if (a[i] != b[i]) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private static string GetSessionImageKey(string key)
|
||
{
|
||
// all session variables starts with _sessionKeyPrefix to avoid direct access to session by passing image key in Url query.
|
||
return _sessionKeyPrefix + key;
|
||
}
|
||
|
||
#endregion //Methods
|
||
|
||
#region ImageHandler Members
|
||
|
||
/// <summary>
|
||
/// Stores the data into external medium.
|
||
/// </summary>
|
||
/// <param name="key">The key.</param>
|
||
/// <param name="data">The data.</param>
|
||
void IChartStorageHandler.Save(String key, Byte[] data)
|
||
{
|
||
ChartHttpHandlerSettings settings = ChartHttpHandler.Settings;
|
||
ImageOwnerKeyType imageOwnerKeyType = ImageOwnerKeyType.None;
|
||
string privacyKey = settings.GetPrivacyKey(out imageOwnerKeyType);
|
||
if (settings.StorageType == ChartHttpHandlerStorageType.InProcess)
|
||
{
|
||
_rwl.AcquireWriterLock(accessTimeout);
|
||
try
|
||
{
|
||
_storageData[key] = data;
|
||
if (settings.PrivateImages && !String.IsNullOrEmpty(privacyKey))
|
||
{
|
||
_storageData[key + _privacyKeyName] = privacyKey;
|
||
Diagnostics.TraceWrite( SR.DiagnosticChartImageSavedPrivate(key, imageOwnerKeyType.ToString()), null);
|
||
}
|
||
else
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageSaved(key), null);
|
||
}
|
||
finally
|
||
{
|
||
_rwl.ReleaseWriterLock();
|
||
}
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
using (FileStream stream = File.Create(settings.Directory + key))
|
||
{
|
||
stream.Write(data, 0, data.Length);
|
||
if (settings.PrivateImages && !String.IsNullOrEmpty(privacyKey))
|
||
{
|
||
byte[] privacyData = GetHashData();
|
||
stream.Write(privacyData, 0, privacyData.Length);
|
||
// we will put a marker at the end of the file;
|
||
stream.Write(_privacyMarker, 0, _privacyMarker.Length);
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageSavedPrivate(key, imageOwnerKeyType.ToString()), null);
|
||
}
|
||
else
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageSaved(key), null);
|
||
}
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.Session)
|
||
{
|
||
HttpContext.Current.Session[GetSessionImageKey(key)] = data;
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageSaved(key), null);
|
||
}
|
||
else this.NotSupportedStorageType(settings);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Retrieves the data from external medium.
|
||
/// </summary>
|
||
/// <param name="key">The key.</param>
|
||
Byte[] IChartStorageHandler.Load( String key)
|
||
{
|
||
ChartHttpHandlerSettings settings = ChartHttpHandler.Settings;
|
||
ImageOwnerKeyType imageOwnerKeyType = ImageOwnerKeyType.None;
|
||
string privacyKey = settings.GetPrivacyKey(out imageOwnerKeyType);
|
||
Byte[] data = new Byte[0];
|
||
if (settings.StorageType == ChartHttpHandlerStorageType.InProcess)
|
||
{
|
||
_rwl.AcquireReaderLock(accessTimeout);
|
||
try
|
||
{
|
||
if (settings.PrivateImages)
|
||
{
|
||
if (!String.IsNullOrEmpty(privacyKey))
|
||
{
|
||
if (!String.Equals((string)_storageData[key + _privacyKeyName], privacyKey, StringComparison.Ordinal))
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailPrivacyFail(imageOwnerKeyType.ToString())), null);
|
||
return data;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!String.IsNullOrEmpty((string)_storageData[key + _privacyKeyName]))
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailPrivacyFail(imageOwnerKeyType.ToString())), null);
|
||
return data;
|
||
}
|
||
}
|
||
}
|
||
data = (Byte[])_storageData[key];
|
||
if (data == null)
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailNotFound), null);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_rwl.ReleaseReaderLock();
|
||
}
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
settings.ValidateUri(key);
|
||
if (File.Exists(settings.Directory + key))
|
||
{
|
||
using (FileStream fileStream = File.OpenRead(settings.Directory + key))
|
||
{
|
||
byte[] fileData = new byte[fileStream.Length];
|
||
fileStream.Read(fileData, 0, fileData.Length);
|
||
using (MemoryStream stream = new MemoryStream(fileData))
|
||
{
|
||
int streamCut = 0;
|
||
if (settings.PrivateImages)
|
||
{
|
||
// read the marker first
|
||
byte[] privacyMarkerStream = new Byte[_privacyMarker.Length];
|
||
|
||
streamCut += _privacyMarker.Length;
|
||
stream.Seek(stream.Length - streamCut, SeekOrigin.Begin);
|
||
stream.Read(privacyMarkerStream, 0, privacyMarkerStream.Length);
|
||
|
||
if (!String.IsNullOrEmpty(privacyKey))
|
||
{
|
||
byte[] privacyData = GetHashData();
|
||
streamCut += privacyData.Length;
|
||
byte[] privacyDataFromStream = new Byte[privacyData.Length];
|
||
stream.Seek(stream.Length - streamCut, SeekOrigin.Begin);
|
||
stream.Read(privacyDataFromStream, 0, privacyDataFromStream.Length);
|
||
|
||
if (!CompareBytes(privacyDataFromStream, privacyData))
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailPrivacyFail(imageOwnerKeyType.ToString())), null);
|
||
return data;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// this image is marked as private - check end return null if fails
|
||
if (String.Equals(
|
||
Encoding.Unicode.GetString(privacyMarkerStream),
|
||
Encoding.Unicode.GetString(_privacyMarker),
|
||
StringComparison.Ordinal))
|
||
{
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailPrivacyFail(imageOwnerKeyType.ToString())), null);
|
||
return data;
|
||
}
|
||
// its fine ( no user is stored )
|
||
streamCut = 0;
|
||
}
|
||
}
|
||
stream.Seek(0, SeekOrigin.Begin);
|
||
data = new Byte[(int)stream.Length - streamCut];
|
||
stream.Read(data, 0, (int)data.Length);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
Diagnostics.TraceWrite(SR.DiagnosticChartImageServedFail(key, SR.DiagnosticChartImageServedFailNotFound), null);
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.Session)
|
||
{
|
||
data = (Byte[])HttpContext.Current.Session[GetSessionImageKey(key)];
|
||
}
|
||
else this.NotSupportedStorageType(settings);
|
||
return data;
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Removes the data from external medium.
|
||
/// </summary>
|
||
/// <param name="key">The key.</param>
|
||
void IChartStorageHandler.Delete(String key)
|
||
{
|
||
ChartHttpHandlerSettings settings = ChartHttpHandler.Settings;
|
||
if (settings.StorageType == ChartHttpHandlerStorageType.InProcess)
|
||
{
|
||
|
||
_rwl.AcquireWriterLock(accessTimeout);
|
||
try
|
||
{
|
||
_storageData.Remove(key);
|
||
_storageData.Remove(key + _privacyKeyName);
|
||
}
|
||
finally
|
||
{
|
||
_rwl.ReleaseWriterLock();
|
||
}
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
File.Delete(settings.Directory + key);
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.Session)
|
||
{
|
||
HttpContext.Current.Session.Remove(GetSessionImageKey(key));
|
||
}
|
||
else this.NotSupportedStorageType(settings);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks for existence the specified key.
|
||
/// </summary>
|
||
/// <param name="key">The key.</param>
|
||
/// <returns></returns>
|
||
bool IChartStorageHandler.Exists(String key)
|
||
{
|
||
ChartHttpHandlerSettings settings = ChartHttpHandler.Settings;
|
||
if (settings.StorageType == ChartHttpHandlerStorageType.InProcess)
|
||
{
|
||
_rwl.AcquireReaderLock(accessTimeout);
|
||
try
|
||
{
|
||
return _storageData.Contains(key);
|
||
}
|
||
finally
|
||
{
|
||
_rwl.ReleaseReaderLock();
|
||
}
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.File)
|
||
{
|
||
return File.Exists(settings.Directory + key);
|
||
}
|
||
else if (settings.StorageType == ChartHttpHandlerStorageType.Session)
|
||
{
|
||
return HttpContext.Current.Session[GetSessionImageKey(key)] is Byte[];
|
||
}
|
||
else this.NotSupportedStorageType(settings);
|
||
return false;
|
||
}
|
||
|
||
#endregion
|
||
|
||
}
|
||
|
||
#endregion //DefaultImageHandler Class
|
||
|
||
#region RingTimeTracker class
|
||
|
||
/// <summary>
|
||
/// RingItem contains time span of creation timedate and index for key generation.
|
||
/// </summary>
|
||
internal class RingItem
|
||
{
|
||
internal Int32 Index;
|
||
internal DateTime Created = DateTime.Now;
|
||
internal string SessionID = String.Empty;
|
||
internal bool InUse;
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="T:RingItem"/> class.
|
||
/// </summary>
|
||
/// <param name="index">The index.</param>
|
||
internal RingItem( int index)
|
||
{
|
||
this.Index = index;
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// RingTimeTracker is a helper class for generating keys and tracking RingItem.
|
||
/// Contains linked list queue and tracks exprired items.
|
||
/// </summary>
|
||
internal class RingTimeTracker
|
||
{
|
||
#region Fields
|
||
// the item life span
|
||
private TimeSpan _itemLifeTime = TimeSpan.FromSeconds(360);
|
||
// last requested RingItem
|
||
private LinkedListNode<RingItem> _current;
|
||
// default key format to format names
|
||
private String _keyFormat = String.Empty;
|
||
// LinkedList with ring items
|
||
private LinkedList<RingItem> _list = new LinkedList<RingItem>();
|
||
// Record session ID
|
||
private bool _recordSessionID = false;
|
||
|
||
#endregion //Fields
|
||
|
||
#region Constructors
|
||
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="T:RingTimeTracker"/> class.
|
||
/// </summary>
|
||
/// <param name="itemLifeTime">The item life time.</param>
|
||
/// <param name="keyFormat">The key format.</param>
|
||
/// <param name="recordSessionID">if set to <c>true</c> the session ID will be recorded.</param>
|
||
internal RingTimeTracker(TimeSpan itemLifeTime, String keyFormat, bool recordSessionID)
|
||
{
|
||
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(keyFormat));
|
||
this._itemLifeTime = itemLifeTime;
|
||
this._keyFormat = keyFormat;
|
||
this._list.AddLast(new RingItem(_list.Count));
|
||
this._current = this._list.First;
|
||
this._current.Value.Created = DateTime.Now - this._itemLifeTime - TimeSpan.FromSeconds(1);
|
||
this._recordSessionID = recordSessionID;
|
||
}
|
||
|
||
#endregion //Constructors
|
||
|
||
#region Methods
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Determines whether the specified item is expired.
|
||
/// </summary>
|
||
/// <param name="item">The item.</param>
|
||
/// <param name="now">The now.</param>
|
||
/// <returns>
|
||
/// <c>true</c> if the specified item is expired; otherwise, <c>false</c>.
|
||
/// </returns>
|
||
internal bool IsExpired(RingItem item, DateTime now)
|
||
{
|
||
TimeSpan elapsed = (now - item.Created);
|
||
return elapsed > this._itemLifeTime;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Gets the next key.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
internal String GetNextKey()
|
||
{
|
||
DateTime now = DateTime.Now;
|
||
lock (this)
|
||
{
|
||
if ( !this.IsExpired(this._current.Value, now))
|
||
{
|
||
if (this._current.Next == null)
|
||
{
|
||
if (!this.IsExpired(this._list.First.Value, now))
|
||
{
|
||
this._list.AddLast(new RingItem(_list.Count));
|
||
this._current = this._list.Last;
|
||
}
|
||
else
|
||
{
|
||
this._current = this._list.First;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!this.IsExpired(this._current.Next.Value, now))
|
||
{
|
||
this._list.AddAfter(this._current, new RingItem(_list.Count));
|
||
}
|
||
this._current = this._current.Next;
|
||
}
|
||
}
|
||
this._current.Value.Created = now;
|
||
if (this._recordSessionID)
|
||
{
|
||
this._current.Value.SessionID = ChartHttpHandler.Settings.ReadSessionKey();
|
||
this._current.Value.InUse = true;
|
||
}
|
||
return this.GetCurrentKey();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the current key.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
internal String GetCurrentKey()
|
||
{
|
||
return String.Format( CultureInfo.InvariantCulture, this._keyFormat, this._current.Value.Index);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the key.
|
||
/// </summary>
|
||
/// <param name="ringItem">The ring item.</param>
|
||
/// <returns></returns>
|
||
internal String GetKey(RingItem ringItem)
|
||
{
|
||
return String.Format(CultureInfo.InvariantCulture, this._keyFormat, ringItem.Index);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Do Action for each item.
|
||
/// </summary>
|
||
/// <param name="onlyExpired">if set to <c>true</c> do action for only expired items.</param>
|
||
/// <param name="action">The action.</param>
|
||
public void ForEach(bool onlyExpired, Action<RingItem> action)
|
||
{
|
||
if (action == null)
|
||
{
|
||
throw new ArgumentNullException("action");
|
||
}
|
||
DateTime now = DateTime.Now;
|
||
lock (this)
|
||
{
|
||
foreach (RingItem item in this._list)
|
||
{
|
||
if (onlyExpired)
|
||
{
|
||
if (this.IsExpired(item, now))
|
||
{
|
||
action(item);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
action(item);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion //Methods
|
||
|
||
}
|
||
#endregion //RingTracker class
|
||
|
||
#region RingTimeTrackerFactory Class
|
||
|
||
/// <summary>
|
||
/// RingTimeTrackerFactory contains static list of RingTimeTracker for each key formats
|
||
/// </summary>
|
||
internal static class RingTimeTrackerFactory
|
||
{
|
||
|
||
private static ListDictionary _ringTrackers = new ListDictionary();
|
||
private static Object _lockObject = new Object();
|
||
|
||
/// <summary>
|
||
/// Gets the ring tracker by specified key format.
|
||
/// </summary>
|
||
/// <param name="keyFormat">The key format.</param>
|
||
/// <returns></returns>
|
||
internal static RingTimeTracker GetRingTracker(String keyFormat)
|
||
{
|
||
if (_ringTrackers.Contains(keyFormat))
|
||
{
|
||
return (RingTimeTracker)_ringTrackers[keyFormat];
|
||
}
|
||
lock (_lockObject)
|
||
{
|
||
if (_ringTrackers.Contains(keyFormat))
|
||
{
|
||
return (RingTimeTracker)_ringTrackers[keyFormat];
|
||
}
|
||
RingTimeTracker result = new RingTimeTracker(ChartHttpHandler.Settings.Timeout, keyFormat,ChartHttpHandler.Settings.StorageType == ChartHttpHandlerStorageType.Session);
|
||
_ringTrackers.Add(keyFormat, result);
|
||
return result;
|
||
}
|
||
}
|
||
|
||
internal static IList OpenedRingTimeTrackers()
|
||
{
|
||
lock (_lockObject)
|
||
{
|
||
return new ArrayList(_ringTrackers.Values);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
#endregion //RingTimeTrackerFactory Class
|
||
|
||
#region Diagnostics class
|
||
|
||
/// <summary>
|
||
/// Contains helpres methods for diagnostics.
|
||
/// </summary>
|
||
internal static class Diagnostics
|
||
{
|
||
/// <summary>
|
||
/// Trace category
|
||
/// </summary>
|
||
const string ChartCategory = "chart.handler";
|
||
/// <summary>
|
||
/// Name of context item which contain the current trace item
|
||
/// </summary>
|
||
const string ContextID = "Trace-{89FA5660-BD13-4f1b-8C7C-355CEC92CC7E}";
|
||
/// <summary>
|
||
/// Used for syncronizing.
|
||
/// </summary>
|
||
static object _lockObject = new object();
|
||
/// <summary>
|
||
/// Limit of trace messages in the history.
|
||
/// </summary>
|
||
const int MessageLimit = 20;
|
||
/// <summary>
|
||
/// Collection of request messages.
|
||
/// </summary>
|
||
static List<HandlerPageTraceInfo> _messages = new List<HandlerPageTraceInfo>(MessageLimit);
|
||
|
||
/// <summary>
|
||
/// Contains request info
|
||
/// </summary>
|
||
public class HandlerPageTraceInfo
|
||
{
|
||
/// <summary>
|
||
/// Events collection in this request.
|
||
/// </summary>
|
||
private List<ChartHandlerEvents> _events = new List<ChartHandlerEvents>();
|
||
/// <summary>
|
||
/// Initializes a new instance of the <see cref="HandlerPageTraceInfo"/> class.
|
||
/// </summary>
|
||
public HandlerPageTraceInfo()
|
||
{
|
||
if (HttpContext.Current != null)
|
||
{
|
||
DateStamp = DateTime.Now;
|
||
if (HttpContext.Current.Request != null)
|
||
{
|
||
Url = HttpContext.Current.Request.Url.ToString();
|
||
Verb = HttpContext.Current.Request.HttpMethod;
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// Gets or sets the date stamp.
|
||
/// </summary>
|
||
/// <value>The date stamp.</value>
|
||
public DateTime DateStamp { get; private set; }
|
||
/// <summary>
|
||
/// Gets or sets the URL.
|
||
/// </summary>
|
||
/// <value>The URL.</value>
|
||
public string Url { get; private set; }
|
||
/// <summary>
|
||
/// Gets or sets the verb.
|
||
/// </summary>
|
||
/// <value>The verb.</value>
|
||
public string Verb { get; private set; }
|
||
/// <summary>
|
||
/// Gets the events.
|
||
/// </summary>
|
||
/// <value>The events.</value>
|
||
public IList<ChartHandlerEvents> Events
|
||
{
|
||
get
|
||
{
|
||
return _events.AsReadOnly();
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// Adds a trace info item.
|
||
/// </summary>
|
||
/// <param name="message">The message.</param>
|
||
/// <param name="errorInfo">The error info.</param>
|
||
internal void AddTraceInfo(string message, string errorInfo)
|
||
{
|
||
lock (_events)
|
||
{
|
||
_events.Add(new ChartHandlerEvents()
|
||
{
|
||
Message = message,
|
||
ErrorInfo = errorInfo
|
||
}
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Contains an event in particural request.
|
||
/// </summary>
|
||
public class ChartHandlerEvents
|
||
{
|
||
/// <summary>
|
||
/// Gets or sets the message.
|
||
/// </summary>
|
||
/// <value>The message.</value>
|
||
public string Message { get; set; }
|
||
/// <summary>
|
||
/// Gets or sets the error info.
|
||
/// </summary>
|
||
/// <value>The error info.</value>
|
||
public string ErrorInfo { get; set; }
|
||
/// <summary>
|
||
/// Gets the text.
|
||
/// </summary>
|
||
/// <value>The text.</value>
|
||
public string Text { get { return Message + ErrorInfo; } }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Writes message in the trace.
|
||
/// </summary>
|
||
/// <param name="message">The message.</param>
|
||
/// <param name="errorInfo">The error info.</param>
|
||
internal static void TraceWrite( string message, Exception errorInfo)
|
||
{
|
||
if (IsTraceEnabled)
|
||
{
|
||
HttpContext.Current.Trace.Write(ChartCategory, message, errorInfo);
|
||
if (CurrentTraceInfo != null)
|
||
{
|
||
CurrentTraceInfo.AddTraceInfo(message, errorInfo != null ? errorInfo.ToString() : String.Empty);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the current trace info.
|
||
/// </summary>
|
||
/// <value>The current trace info.</value>
|
||
private static HandlerPageTraceInfo CurrentTraceInfo
|
||
{
|
||
get
|
||
{
|
||
lock (_lockObject)
|
||
{
|
||
if (HttpContext.Current != null)
|
||
{
|
||
if (HttpContext.Current.Items[Diagnostics.ContextID] == null)
|
||
{
|
||
HandlerPageTraceInfo pageTrace = new HandlerPageTraceInfo();
|
||
_messages.Add(pageTrace);
|
||
if (_messages.Count > MessageLimit)
|
||
{
|
||
_messages.RemoveRange(0, _messages.Count - MessageLimit);
|
||
}
|
||
HttpContext.Current.Items[Diagnostics.ContextID] = pageTrace;
|
||
}
|
||
return (HandlerPageTraceInfo)HttpContext.Current.Items[Diagnostics.ContextID];
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a value indicating whether this instance is trace enabled.
|
||
/// </summary>
|
||
/// <value>
|
||
/// <c>true</c> if this instance is trace enabled; otherwise, <c>false</c>.
|
||
/// </value>
|
||
internal static bool IsTraceEnabled
|
||
{
|
||
get
|
||
{
|
||
return HttpContext.Current != null && HttpContext.Current.Trace.IsEnabled;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets the messages collection.
|
||
/// </summary>
|
||
/// <value>The messages.</value>
|
||
internal static ReadOnlyCollection<HandlerPageTraceInfo> Messages
|
||
{
|
||
get
|
||
{
|
||
List<HandlerPageTraceInfo> result;
|
||
lock (_lockObject)
|
||
{
|
||
result = new List<HandlerPageTraceInfo>(_messages);
|
||
}
|
||
return result.AsReadOnly();
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion //Diagnostics class
|
||
}
|