public XPathServiceOperationNavigator ( HttpContext httpContext, Context context, Transform.Context transformContext, XPathNavigator navigator, TransformRequest request, TransformResponse response, XsltTransformationManager transformationManager ) {
m_navigator = navigator;
m_httpContext = httpContext;
m_context = context;
m_transformContext = transformContext;
m_request = request;
m_response = response;
m_xslTransformationManager = transformationManager;
m_transform = transformationManager.Transform;
m_encoding = new UTF8Encoding();
}
public XmlServiceOperationReader(HttpContext httpContext, Context context, Transform.Context transformContext, XmlReader reader, TransformRequest request, TransformResponse response, XsltTransformationManager transformationManager) {
m_reader = reader;
m_httpContext = httpContext;
m_context = context;
m_transformContext = transformContext;
m_request = request;
m_response = response;
m_xslTransformationManager = transformationManager;
m_transform = transformationManager.Transform;
m_encoding = new UTF8Encoding();
}
public IAsyncResult BeginProcessRequest ( HttpContext context, AsyncCallback cb, object extraData ) {
m_stopwatch.Start();
FileInfo fileInfo = new FileInfo(context.Request.MapPath(context.Request.CurrentExecutionFilePath));
this.LogDebug("File Date: {0}; File Length: {1}", fileInfo.LastWriteTimeUtc, fileInfo.Length);
m_CONTENT_IS_MEMCACHED = false;
m_USE_MEMCACHED = false;
m_httpContext = context;
m_returnOutput = true;
m_httpMethod = m_httpContext.Request.HttpMethod;
m_memcachedClient = (Client)context.Application["memcached"];
m_encoding = (UTF8Encoding)context.Application["encoding"];
m_queueClient = (QueueClient)context.Application["queueclient"];
m_hashkey = (string)context.Application["hashkey"];
m_xmlServiceOperationManager = (XPathServiceOperationManager)context.Application["xmlServiceOperationManager"];
m_xslTransformationManager = (XsltTransformationManager)context.Application["xslTransformationManager"];
m_transform = m_xslTransformationManager.Transform;
m_xsltParams = (Hashtable)context.Application["globalXsltParams"];
m_transformContext = new Transform.Context(context, m_hashAlgorithm, (string)context.Application["hashkey"], fileInfo, (Hashtable)m_xsltParams.Clone(), fileInfo.LastWriteTimeUtc, fileInfo.Length);
m_namedXsltHashtable = (Hashtable)context.Application["namedXsltHashtable"];
m_xmlSourceETagDictionary = m_xmlServiceOperationManager.XmlSourceETagDictionary;
m_xmlReaderDictionary = m_xmlServiceOperationManager.XmlReaderDictionary;
m_context = new Context(context, m_hashAlgorithm, m_hashkey, fileInfo, fileInfo.LastWriteTimeUtc, fileInfo.Length);
this.LogDebug("File Date: {0}; File Length: {1}", m_context.RequestXmlFileInfo.LastWriteTimeUtc, m_context.RequestXmlFileInfo.Length);
m_nuxleusAsyncResult = new Nuxleus.Core.NuxleusAsyncResult(cb, extraData);
m_callback = cb;
m_nuxleusAsyncResult.m_context = context;
m_builder = new StringBuilder();
m_CONTENT_IS_MEMCACHED = false;
m_USE_MEMCACHED = (bool)context.Application["usememcached"];
Uri requestUri = new Uri(m_context.RequestUri);
m_requestHashcode = m_context.GetRequestHashcode(true).ToString();
m_lastModifiedKey = String.Format("LastModified:{0}", m_context.RequestUri.GetHashCode());
m_lastModifiedDate = String.Empty;
m_request = new TransformRequest();
m_response = new TransformResponse();
Guid requestGuid = Guid.NewGuid();
m_request.ID = requestGuid;
context.Response.ContentType = "text/xml";
IEnumerator headers = context.Request.Headers.GetEnumerator();
for (int i = 0; headers.MoveNext(); i++) {
string local = context.Request.Headers.AllKeys[i].ToString();
this.LogDebug("KeyName: {0}, KeyValue: {1}", local, context.Request.Headers[local]);
}
bool hasXmlSourceChanged = m_xmlServiceOperationManager.HasXmlSourceChanged(m_context.RequestXmlETag, requestUri);
//if (m_USE_MEMCACHED) {
// string obj = (string)m_memcachedClient.Get(m_context.GetRequestHashcode(true).ToString());
// if (obj != null && !hasXmlSourceChanged) {
// m_response.TransformResult = (string)obj;
// m_CONTENT_IS_MEMCACHED = true;
// if ((bool)context.Application["debug"]) {
// context.Response.ContentType = "text";
// }
// } else {
// //m_writer = new StringWriter(m_builder);
// m_CONTENT_IS_MEMCACHED = false;
// }
//} else {
// m_writer = new StringWriter(m_builder);
//}
m_writer = new StringWriter(m_builder);
try {
switch (m_httpMethod) {
case "GET":
case "HEAD":
case "POST": {
string name = String.Format("Name: {0}", context.Request.QueryString["name"]);
this.LogDebug("QueryString Length: {0}", context.Request.QueryString.Count);
this.LogDebug(name);
this.LogDebug("If-None-Match: {0}, RequestHashCode: {1}", context.Request.Headers["If-None-Match"], m_requestHashcode);
this.LogDebug(context.Request.Path);
if (context.Request.Headers["If-None-Match"] == m_requestHashcode) {
object lastModified;
this.LogDebug("They matched.");
this.LogDebug("Use memcached: {0}, KeyExists: {1}, XmlSource Changed: {2}", m_USE_MEMCACHED, m_memcachedClient.TryGet(m_lastModifiedKey, out lastModified), hasXmlSourceChanged);
this.LogDebug("Last Modified Key Value: {0}", m_lastModifiedKey);
if (m_USE_MEMCACHED && m_memcachedClient.TryGet(m_lastModifiedKey, out lastModified) && !hasXmlSourceChanged)
{
m_lastModifiedDate = (string)m_memcachedClient.Get(m_lastModifiedKey);
this.LogDebug("Last Modified Date: {0}", m_lastModifiedDate);
if (context.Request.Headers["If-Modified-Since"] == m_lastModifiedDate) {
context.Response.StatusCode = 304;
m_returnOutput = false;
goto CompleteCall;
} else {
goto Process;
}
} else if (m_CONTENT_IS_MEMCACHED) {
goto CompleteCall;
} else {
goto Process;
}
} else {
this.LogDebug("Headers do not match. Beginning transformation process...");
m_returnOutput = true;
goto Process;
}
}
case "PUT": {
goto CompleteCall;
}
case "DELETE": {
goto CompleteCall;
}
default: {
goto CompleteCall;
}
}
} catch (Exception ex) {
m_exception = ex;
WriteError();
goto CompleteCall;
}
Process:
try {
this.LogDebug("Processing Transformation");
this.LogDebug("Request XML ETag Value: {0}, Request URI: {1}", m_context.RequestXmlETag, requestUri);
XPathNavigator navigator = m_xmlServiceOperationManager.GetXPathNavigator(m_context.RequestXmlETag, requestUri);
//if (initialReader == null) {
// initialReader = reader;
//} else {
// this.LogDebug("XmlReaders are the same object: {0}", initialReader.Equals(reader));
//}
//this.LogDebug("XML Reader Value: {0}", reader.ReadOuterXml());
//this.LogDebug("XML Reader Hash: {0}", reader.GetHashCode());
XPathServiceOperationNavigator serviceOperationReader = new XPathServiceOperationNavigator(context, m_context, m_transformContext, navigator, m_request, m_response, m_xslTransformationManager);
m_response = serviceOperationReader.Process();
} catch (Exception e) {
this.LogDebug("Error: {0} in transformation.", e.Message);
m_exception = e;
WriteError();
}
goto CompleteCall;
CompleteCall:
this.LogDebug("CompleteCall reached");
if (m_lastModifiedDate == String.Empty) {
m_lastModifiedDate = DateTime.UtcNow.ToString("r");
}
context.Response.AppendHeader("Cache-Control", "max-age=86400");
context.Response.AddHeader("Last-Modified", m_lastModifiedDate);
context.Response.AddHeader("ETag", String.Format("\"{0}\"", m_requestHashcode));
m_nuxleusAsyncResult.CompleteCall();
return m_nuxleusAsyncResult;
}
protected void Application_Start(object sender, EventArgs e)
{
//System.Web.HttpApplication application = (System.Web.HttpApplication)sender;
m_useMemCached = false;
m_DEBUG = false;
m_memcachedClient = null;
m_appSettings = new AppSettings();
m_xameleonConfiguration = AspNetXameleonConfiguration.GetConfig();
string hashkey = (string)m_xameleonConfiguration.ObjectHashKey;
Application["hashkey"] = hashkey;
m_awsConfiguration = AspNetAwsConfiguration.GetConfig();
m_transform = new Transform.Transform();
m_processor = new Processor();
m_serializer = new Serializer();
m_resolver = new XmlUrlResolver();
m_namedXsltHashtable = new Hashtable();
m_globalXsltParams = new Hashtable();
m_transformContextHashtable = new Hashtable();
m_xmlServiceOperationManager = new XPathServiceOperationManager(new Dictionary<int, XPathNavigator>());
m_geoIPLookup = new Dictionary<String, IPLocation>();
m_requestXsltParams = null;
m_encoding = new UTF8Encoding();
m_pledgeCount = new PledgeCount(0, 0);
m_pledgeQueue = new Queue<string>();
string sdbAccessKey = String.Empty;
string sdbSecretKey = String.Empty;
string awsUriEndpoint = "https://sdb.amazonaws.com/";
Environment.SetEnvironmentVariable("AWS_URI_ENDPOINT", awsUriEndpoint);
using (XmlReader configReader = XmlReader.Create(HttpContext.Current.Server.MapPath("~/App_Config/aws.config")))
{
while (configReader.Read())
{
if (configReader.IsStartElement())
{
switch (configReader.Name)
{
case "sdb-access-key":
{
sdbAccessKey = configReader.ReadString();
Environment.SetEnvironmentVariable("AWS_PUBLIC_KEY", sdbAccessKey);
Console.WriteLine("SDB_ACCESS_KEY: {0}", sdbAccessKey);
break;
}
case "sdb-secret-key":
{
sdbSecretKey = configReader.ReadString();
Environment.SetEnvironmentVariable("AWS_PRIVATE_KEY", sdbSecretKey);
Console.WriteLine("SDB_PRIVATE_KEY: {0}", sdbSecretKey);
break;
}
default:
break;
}
}
}
}
if (m_xameleonConfiguration.DebugMode == "yes")
m_DEBUG = true;
if (m_xameleonConfiguration.UseMemcached == "yes")
{
m_useMemCached = true;
m_memcachedClient = new Client(new MemcachedClient(), AspNetMemcachedConfiguration.GetConfig());
}
string baseUri = (string)m_xameleonConfiguration.PreCompiledXslt.BaseUri;
if (baseUri != String.Empty)
baseUri = (string)m_xameleonConfiguration.PreCompiledXslt.BaseUri;
else
baseUri = "~";
m_xsltTransformationManager = new XsltTransformationManager(m_processor, m_transform, m_resolver, m_serializer);
m_xsltTransformationManager.HashAlgorithm = m_hashAlgorithm;
m_resolver.Credentials = CredentialCache.DefaultCredentials;
m_namedXsltHashtable = m_xsltTransformationManager.NamedXsltHashtable;
foreach (PreCompiledXslt xslt in m_xameleonConfiguration.PreCompiledXslt)
{
string localBaseUri = (string)m_xameleonConfiguration.PreCompiledXslt.BaseUri;
if (localBaseUri == String.Empty)
localBaseUri = baseUri;
Uri xsltUri = new Uri(HttpContext.Current.Server.MapPath(localBaseUri + xslt.Uri));
m_xsltTransformationManager.Compiler.BaseUri = xsltUri;
m_xsltTransformationManager.AddTransformer(xslt.Name, xsltUri, m_resolver, xslt.InitialMode, xslt.InitialTemplate);
m_namedXsltHashtable.Add(xslt.Name, xsltUri);
if (xslt.UseAsBaseXslt == "yes")
{
m_baseXsltContext = new BaseXsltContext(xsltUri, XsltTransformationManager.GenerateNamedETagKey(xslt.Name, xsltUri), xslt.Name);
}
}
m_xsltTransformationManager.SetBaseXsltContext(m_baseXsltContext);
foreach (XsltParam xsltParam in m_xameleonConfiguration.GlobalXsltParam)
{
m_globalXsltParams[xsltParam.Name] = (string)xsltParam.Select;
}
if (m_memcachedClient != null)
Application["as_memcached"] = m_memcachedClient;
Application["as_usememcached"] = m_useMemCached;
Application["as_xslTransformationManager"] = m_xsltTransformationManager;
Application["as_xmlServiceOperationManager"] = m_xmlServiceOperationManager;
Application["as_namedXsltHashtable"] = m_namedXsltHashtable;
Application["as_globalXsltParams"] = m_globalXsltParams;
Application["as_geoIPLookup"] = m_geoIPLookup;
Application["as_debug"] = m_DEBUG;
Application["as_hashkey"] = hashkey;
Application["as_encoding"] = m_encoding;
Application["as_pledgeCount"] = m_pledgeCount;
Application["as_pledgeQueue"] = m_pledgeQueue;
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
FileInfo fileInfo = new FileInfo(context.Request.MapPath(context.Request.CurrentExecutionFilePath));
m_CONTENT_IS_MEMCACHED = false;
m_USE_MEMCACHED = false;
m_context = context;
m_httpMethod = m_context.Request.HttpMethod;
m_memcachedClient = (Client)context.Application["memcached"];
m_queueClient = (QueueClient)context.Application["queueclient"];
m_xslTransformationManager = (XsltTransformationManager)context.Application["xslTransformationManager"];
m_transform = m_xslTransformationManager.Transform;
m_xsltParams = (Hashtable)context.Application["globalXsltParams"];
m_namedXsltHashtable = (Hashtable)context.Application["namedXsltHashtable"];
m_transformContext = new Transform.Context(context, m_hashAlgorithm, (string)context.Application["hashkey"], fileInfo, (Hashtable)m_xsltParams.Clone(), fileInfo.LastWriteTimeUtc, fileInfo.Length);
m_transformAsyncResult = new NuxleusAsyncResult(cb, extraData);
m_callback = cb;
m_transformAsyncResult.m_context = context;
m_builder = new StringBuilder();
m_CONTENT_IS_MEMCACHED = false;
m_USE_MEMCACHED = (bool)context.Application["usememcached"];
bool hasXmlSourceChanged = m_xslTransformationManager.HasXmlSourceChanged(m_transformContext.RequestXmlETag);
bool hasBaseXsltSourceChanged = m_xslTransformationManager.HasBaseXsltSourceChanged();
if (m_USE_MEMCACHED)
{
string obj = (string)m_memcachedClient.Get(m_transformContext.GetRequestHashcode(true));
if (obj != null && !(hasXmlSourceChanged || hasBaseXsltSourceChanged) && !(m_context.Request.CurrentExecutionFilePath.StartsWith("/service/session") && !(m_context.Request.CurrentExecutionFilePath.StartsWith("/service/geo"))))
{
m_builder.Append(obj);
m_CONTENT_IS_MEMCACHED = true;
if ((bool)context.Application["debug"])
context.Response.ContentType = "text";
else
context.Response.ContentType = "text/xml";
}
else
{
m_writer = new StringWriter(m_builder);
m_CONTENT_IS_MEMCACHED = false;
}
}
else
{
m_writer = new StringWriter(m_builder);
}
//if ((bool)context.Application["debug"])
//{
// context.Response.Write("<debug>");
// context.Response.Write("<file-info>");
// context.Response.Write("Has Xml Changed: " + hasXmlSourceChanged + ":" + m_transformContext.RequestXmlETag + "<br/>");
// context.Response.Write("Has Xslt Changed: " + hasBaseXsltSourceChanged + "<br/>");
// context.Response.Write("Xml ETag: " + m_transformContext.GetRequestHashcode(true) + "<br/>");
// context.Response.Write("XdmNode Count: " + m_xslTransformationManager.GetXdmNodeHashtableCount() + "<br/>");
// context.Response.Write("</file-info>");
// context.Application["debugOutput"] = (string)("<DebugOutput>" + WriteDebugOutput(m_transformContext, m_xslTransformationManager, new StringBuilder(), m_CONTENT_IS_MEMCACHED).ToString() + "</DebugOutput>");
// context.Response.Write("</debug>");
//}
try
{
switch (m_httpMethod)
{
case "GET":
case "HEAD":
{
if (m_CONTENT_IS_MEMCACHED)
{
m_transformAsyncResult.CompleteCall();
return m_transformAsyncResult;
}
else
{
try
{
string file = m_context.Request.FilePath;
string baseXslt;
if (file.EndsWith("index.page"))
{
baseXslt = "precompile-atomictalk";
}
else if (file.EndsWith("service.op"))
baseXslt = "base";
else
baseXslt = m_xslTransformationManager.BaseXsltName;
//m_transform.BeginTransformProcess(m_transformContext, context, m_xslTransformationManager, m_writer, baseXslt, m_transformAsyncResult);
return m_transformAsyncResult;
}
catch (Exception e)
{
m_exception = e;
WriteError();
m_transformAsyncResult.CompleteCall();
return m_transformAsyncResult;
}
}
}
case "PUT":
{
return m_transformAsyncResult;
}
case "POST":
{
return m_transformAsyncResult;
}
case "DELETE":
{
return m_transformAsyncResult;
}
default:
{
return m_transformAsyncResult;
}
}
}
catch (Exception ex)
{
m_exception = ex;
WriteError();
m_transformAsyncResult.CompleteCall();
return m_transformAsyncResult;
}
}