public ProcessInboundRulesResult ProcessRequestUrl(Uri requestUri, List<InboundRule> inboundRules)
{
if (inboundRules == null)
{
throw new ArgumentNullException("inboundRules");
}
var originalUri = requestUri;
Log.Debug(this, "Processing url: {0}", originalUri);
var ruleResult = new InboundRuleResult
{
RewrittenUri = originalUri
};
var processedResults = new List<InboundRuleResult>();
foreach (var inboundRule in inboundRules)
{
ruleResult = ProcessInboundRule(ruleResult.RewrittenUri, inboundRule);
processedResults.Add(ruleResult);
if (!ruleResult.RuleMatched)
continue;
if (ruleResult.RuleMatched && ruleResult.StopProcessing)
{
break;
}
}
// TODO: log more information about what actually hapenned - this currently only reflects rewrites/redirects
Log.Debug(this, "Processed originalUrl: {0} redirectedUrl: {1}", originalUri, ruleResult.RewrittenUri);
var finalResult = new ProcessInboundRulesResult(originalUri, processedResults);
return finalResult;
}
public void SaveRewriteReport(InboundRuleResult ruleResult, Database database)
{
var reportingFolder = database.GetItem(new ID(Constants.ReportingFolder_ItemId));
var uniqueId = new ID(Guid.NewGuid()).ToShortID().ToString();
var rule = database.GetItem(new ID(ruleResult.ItemId));
var values = new NameValueCollection
{
{"Rule", rule.Paths.Path},
{"Original Url", ruleResult.OriginalUri.ToString()},
{"Rewritten Url", ruleResult.RewrittenUri.ToString()},
{"Database Name", database.Name}
};
var url = string.Format("{0}/-/item/v1/{1}?name={2}&template={3}&sc_database=master", Configuration.ItemWebApiHost, reportingFolder.Paths.Path, uniqueId, RewriteReportItem.TemplateId).ToLower();
using (var client = new WebClient())
{
client.Headers.Add("X-Scitemwebapi-Username", Configuration.ItemWebApiUser);
client.Headers.Add("X-Scitemwebapi-Password", Configuration.ItemWebApiPassword);
client.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
client.UploadValues(url, "POST", values);
}
}
private void ProcessRewriteAction(InboundRule inboundRule, Uri uri, Match inboundRuleMatch, Match lastConditionMatch, InboundRuleResult ruleResult)
{
var redirectAction = inboundRule.Action as Rewrite;
var rewriteUrl = redirectAction.RewriteUrl;
var rewriteItemId = redirectAction.RewriteItemId;
var rewriteItemAnchor = redirectAction.RewriteItemAnchor;
if (string.IsNullOrEmpty(rewriteUrl) && rewriteItemId == null)
{
ruleResult.RuleMatched = false;
return;
}
if (rewriteItemId.HasValue)
{
rewriteUrl = GetRewriteUrlFromItemId(rewriteItemId.Value, rewriteItemAnchor);
}
// process token replacements
var replacements = new RewriteHelper.Replacements
{
RequestHeaders = RequestHeaders,
RequestServerVariables = RequestServerVariables
};
rewriteUrl = RewriteHelper.ReplaceTokens(replacements, rewriteUrl);
if (redirectAction.AppendQueryString)
{
rewriteUrl += uri.Query;
}
rewriteUrl = RewriteHelper.ReplaceRuleBackReferences(inboundRuleMatch, rewriteUrl);
rewriteUrl = RewriteHelper.ReplaceConditionBackReferences(lastConditionMatch, rewriteUrl);
ruleResult.RewrittenUri = new Uri(rewriteUrl);
ruleResult.StopProcessing = redirectAction.StopProcessingOfSubsequentRules;
}
private InboundRuleResult ProcessRegularExpressionInboundRule(Uri originalUri, InboundRule inboundRule)
{
var ruleResult = new InboundRuleResult
{
OriginalUri = originalUri,
RewrittenUri = originalUri
};
Match inboundRuleMatch,
lastConditionMatch = null;
// test rule match
var isInboundRuleMatch = TestRuleMatches(inboundRule, originalUri, out inboundRuleMatch);
ConditionMatchResult conditionMatchResult = null;
// test conditions matches
if (isInboundRuleMatch && inboundRule.Conditions != null && inboundRule.Conditions.Any())
{
var replacements = new RewriteHelper.Replacements
{
RequestHeaders = RequestHeaders,
RequestServerVariables = RequestServerVariables
};
conditionMatchResult = RewriteHelper.TestConditionMatches(inboundRule, replacements, out lastConditionMatch);
isInboundRuleMatch = conditionMatchResult.Matched;
}
// test site name restrictions
if (isInboundRuleMatch && !string.IsNullOrEmpty(inboundRule.SiteNameRestriction))
{
isInboundRuleMatch = TestSiteNameRestriction(inboundRule);
}
if (isInboundRuleMatch && inboundRule.Action != null)
{
ruleResult.RuleMatched = true;
if (inboundRule.ResponseHeaders.Any())
{
ruleResult.ResponseHeaders = inboundRule.ResponseHeaders;
}
Log.Debug(this, "INBOUND RULE MATCH - requestUri: {0} inboundRule: {1}", originalUri, inboundRule.Name);
// TODO: Need to implement Rewrite, None
if (inboundRule.Action is Redirect)
{
ProcessRedirectAction(inboundRule, originalUri, inboundRuleMatch, lastConditionMatch, ruleResult);
}
else if (inboundRule.Action is Rewrite)
{
ProcessRewriteAction(inboundRule, originalUri, inboundRuleMatch, lastConditionMatch, ruleResult);
}
else if (inboundRule.Action is ItemQueryRedirect)
{
ProcessItemQueryRedirectAction(inboundRule, originalUri, inboundRuleMatch, lastConditionMatch, ruleResult);
}
else if (inboundRule.Action is AbortRequest || inboundRule.Action is CustomResponse)
{
ProcessActionProcessing(ruleResult);
}
else
{
throw new NotImplementedException("Redirect Action, Custome Response and Abort Reqeust Action are the only supported type of redirects");
}
ruleResult.ResultAction = inboundRule.Action;
ruleResult.ConditionMatchResult = conditionMatchResult;
}
else if (inboundRule.Action == null)
{
Log.Warn(this, "Inbound Rule has no Action set - inboundRule: {0} inboundRule ItemId: {1}", inboundRule.Name, inboundRule.ItemId);
// we are going to skip this because we don't know what to do with it during processing
ruleResult.RuleMatched = false;
}
return ruleResult;
}
private void ProcessItemQueryRedirectAction(InboundRule inboundRule, Uri uri, Match inboundRuleMatch, Match lastConditionMatch, InboundRuleResult ruleResult)
{
var redirectAction = inboundRule.Action as ItemQueryRedirect;
var itemQuery = redirectAction.ItemQuery;
if (string.IsNullOrEmpty(itemQuery))
{
ruleResult.RuleMatched = false;
return;
}
// process token replacements in the item query
itemQuery = RewriteHelper.ReplaceRuleBackReferences(inboundRuleMatch, itemQuery);
itemQuery = RewriteHelper.ReplaceConditionBackReferences(lastConditionMatch, itemQuery);
var rewriteItemId = ExecuteItemQuery(itemQuery);
if (!rewriteItemId.HasValue)
{
ruleResult.RuleMatched = false;
return;
}
string rewriteUrl = GetRewriteUrlFromItemId(rewriteItemId.Value, null);
// process token replacements
var replacements = new RewriteHelper.Replacements
{
RequestHeaders = RequestHeaders,
RequestServerVariables = RequestServerVariables
};
rewriteUrl = RewriteHelper.ReplaceTokens(replacements, rewriteUrl);
rewriteUrl = RewriteHelper.ReplaceRuleBackReferences(inboundRuleMatch, rewriteUrl);
rewriteUrl = RewriteHelper.ReplaceConditionBackReferences(lastConditionMatch, rewriteUrl);
ruleResult.RewrittenUri = new Uri(rewriteUrl);
ruleResult.StopProcessing = redirectAction.StopProcessingOfSubsequentRules;
}
private InboundRuleResult ProcessInboundRule(Uri originalUri, InboundRule inboundRule)
{
Log.Debug(this, "Processing inbound rule - requestUri: {0} inboundRule: {1}", originalUri, inboundRule.Name);
var ruleResult = new InboundRuleResult
{
OriginalUri = originalUri,
RewrittenUri = originalUri
};
switch (inboundRule.Using)
{
case Using.ExactMatch:
case Using.RegularExpressions:
case Using.Wildcards:
ruleResult = ProcessRegularExpressionInboundRule(ruleResult.OriginalUri, inboundRule);
break;
//case Using.Wildcards:
// //TODO: Implement Wildcards
// throw new NotImplementedException("Using Wildcards has not been implemented");
// break;
}
Log.Debug(this, "Processing inbound rule - requestUri: {0} inboundRule: {1} rewrittenUrl: {2}", ruleResult.OriginalUri, inboundRule.Name, ruleResult.RewrittenUri);
ruleResult.ItemId = inboundRule.ItemId;
return ruleResult;
}
private void ProcessActionProcessing(InboundRuleResult ruleResult)
{
ruleResult.StopProcessing = true;
}
