private static void ReadErrorHandler(XmlNode node, RewriterConfiguration config) { XmlNode codeNode = node.Attributes[Constants.AttrCode]; if (codeNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrCode), node); } XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler = null; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified)); } } else { handler = new DefaultErrorHandler(urlNode.Value); } config.ErrorHandlers.Add(Convert.ToInt32(codeNode.Value), handler); }
private static void ReadActions(XmlNode node, IList<IRewriteAction> actions, RewriterConfiguration config) { XmlNode childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { IList<IRewriteActionParser> parsers = config.ActionParserFactory.GetParsers(childNode.LocalName); if (parsers != null) { bool parsed = false; foreach (IRewriteActionParser parser in parsers) { IRewriteAction action = parser.Parse(childNode, config); if (action != null) { parsed = true; actions.Add(action); } } if (!parsed) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNotAllowed, node.FirstChild.Name), node); } } } childNode = childNode.NextSibling; } }
private static void ReadMapping(XmlNode node, RewriterConfiguration config) { // Name attribute. XmlNode nameNode = node.Attributes[Constants.AttrName]; // Mapper type not specified. Load in the hash map. StringDictionary map = new StringDictionary(); foreach (XmlNode mapNode in node.ChildNodes) { if (mapNode.NodeType == XmlNodeType.Element) { if (mapNode.LocalName == Constants.ElementMap) { string fromValue = mapNode.GetRequiredAttribute(Constants.AttrFrom, true); string toValue = mapNode.GetRequiredAttribute(Constants.AttrTo, true); map.Add(fromValue, toValue); } else { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, mapNode.LocalName), node); } } } config.TransformFactory.AddTransform(new StaticMappingTransform(nameNode.Value, map)); }
/// <summary> /// Load RewriterConfiguration Instance to XmlNode /// </summary> /// <param name="node">XmlNode</param> /// <returns></returns> public static RewriterConfiguration LoadFromNode(XmlNode node) { RewriterConfiguration configuration = RewriterConfigurationReader.Read(node); //HttpRuntime.Cache.Add(_cacheName, configuration, null, DateTime.Now.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Normal, null); return(configuration); }
private static void ReadRule(XmlNode node, RewriterConfiguration config) { bool parsed = false; IList <IRewriteActionParser> parsers = config.ActionParserFactory.GetParsers(node.LocalName); if (parsers != null) { foreach (IRewriteActionParser parser in parsers) { if (!parser.AllowsNestedActions && node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, parser.Name), node); } if (!parser.AllowsAttributes && node.Attributes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoAttributes, parser.Name), node); } IRewriteAction rule = parser.Parse(node, config); if (rule != null) { config.Rules.Add(rule); parsed = true; break; } } } if (!parsed) { // No parsers recognised to handle this node. throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, node.LocalName), node); } }
private static void ReadRegisterParser(XmlNode node, RewriterConfiguration config) { XmlNode typeNode = node.Attributes[Constants.AttrParser]; if (typeNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrParser), node); } if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } object parser = TypeHelper.Activate(typeNode.Value, null); IRewriteActionParser actionParser = parser as IRewriteActionParser; if (actionParser != null) { config.ActionParserFactory.AddParser(actionParser); } IRewriteConditionParser conditionParser = parser as IRewriteConditionParser; if (conditionParser != null) { config.ConditionParserPipeline.AddParser(conditionParser); } }
/// <summary> /// Loads the configuration from the .config file, with caching. /// </summary> /// <returns>The configuration.</returns> public static RewriterConfiguration Load() { XmlNode section = ConfigurationManager.GetSection(Constants.RewriterNode) as XmlNode; RewriterConfiguration config = null; XmlNode filenameNode = section.Attributes.GetNamedItem(Constants.AttrFile); if (filenameNode != null) { string filename = HttpContext.Current.Server.MapPath(filenameNode.Value); config = LoadFromFile(filename); if (config != null) { CacheDependency fileDependency = new CacheDependency(filename); HttpRuntime.Cache.Add(_cacheName, config, fileDependency, DateTime.UtcNow.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Default, null); } } if (config == null) { config = LoadFromNode(section); HttpRuntime.Cache.Add(_cacheName, config, null, DateTime.UtcNow.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Default, null); } return(config); }
private static void ReadRegisterLogger(XmlNode node, RewriterConfiguration config) { // Type attribute. XmlNode typeNode = node.Attributes[Constants.AttrLogger]; if (typeNode == null) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrLogger), node); } if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } // Logger type specified. Create an instance and add it // as the mapper handler for this map. var logger = TypeHelper.Activate(typeNode.Value, null) as IRewriteLogger; if (logger != null) { config.Logger = logger; } }
private void ReadAttributeActions(XmlNode node, bool allowFinal, IList actions, RewriterConfiguration config) { int i = 0; while (i < node.Attributes.Count) { XmlNode attrNode = node.Attributes[i++]; IList parsers = config.ActionParserFactory.GetParsers(String.Format(Constants.AttributeAction, node.LocalName, attrNode.LocalName)); if (parsers != null) { foreach (IRewriteActionParser parser in parsers) { IRewriteAction action = parser.Parse(node, config); if (action != null) { if (action.Processing == RewriteProcessing.ContinueProcessing || allowFinal) { actions.Add(action); break; } } } } } }
private static void ReadRegisterTransform(XmlNode node, RewriterConfiguration config) { // Type attribute. XmlNode typeNode = node.Attributes[Constants.AttrTransform]; if (typeNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrTransform), node); } if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } // Transform type specified. Create an instance and add it // as the mapper handler for this map. IRewriteTransform handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteTransform; if (handler != null) { config.TransformFactory.AddTransform(handler); } else { // TODO: Error due to type. } }
public IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { XmlNode statusCodeNode = node.Attributes.GetNamedItem("status"); if (statusCodeNode == null) { return null; } return new MVCStatusAction((HttpStatusCode)Convert.ToInt32(statusCodeNode.Value)); }
private static void ReadDefaultDocuments(XmlNode node, RewriterConfiguration config) { foreach (XmlNode childNode in node.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element && childNode.LocalName == Constants.ElementDocument) { config.DefaultDocuments.Add(childNode.InnerText); } } }
private static void ReadDefaultDocuments(XmlNode node, RewriterConfiguration config) { foreach (XmlNode childNode in node.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element && childNode.LocalName == Constants.ElementDocument) { config.DefaultDocuments.Add(childNode.InnerText); } } }
/// <summary> /// Reads configuration information from the given XML Node. /// </summary> /// <param name="section">The XML node to read configuration from.</param> /// <returns>The configuration information.</returns> public static RewriterConfiguration Read(XmlNode section) { if (section == null) { throw new ArgumentNullException("section"); } RewriterConfiguration config = RewriterConfiguration.Create(); if (config == null) { throw new ArgumentNullException("config"); } foreach (XmlNode node in section.ChildNodes) { if (node.NodeType == XmlNodeType.Element) { if (node.LocalName == Constants.ElementErrorHandler) { ReadErrorHandler(node, config); } else if (node.LocalName == Constants.ElementDefaultDocuments) { ReadDefaultDocuments(node, config); } else if (node.LocalName == Constants.ElementRegister) { if (node.Attributes[Constants.AttrParser] != null) { ReadRegisterParser(node, config); } else if (node.Attributes[Constants.AttrTransform] != null) { ReadRegisterTransform(node, config); } else if (node.Attributes[Constants.AttrLogger] != null) { ReadRegisterLogger(node, config); } } else if (node.LocalName == Constants.ElementMapping) { ReadMapping(node, config); } else { ReadRule(node, config); } } } return(config); }
/// <summary> /// Parses conditions from the node. /// </summary> /// <param name="node">The node.</param> /// <param name="conditions">Conditions list to add new conditions to.</param> /// <param name="negative">Whether the conditions should be negated.</param> /// <param name="config">Rewriter configuration</param> protected void ParseConditions(XmlNode node, IList<IRewriteCondition> conditions, bool negative, RewriterConfiguration config) { if (config == null) { return; } if (node == null) { throw new ArgumentNullException("node"); } if (conditions == null) { throw new ArgumentNullException("conditions"); } // Parse attribute-based conditions. foreach (IRewriteConditionParser parser in config.ConditionParserPipeline) { IRewriteCondition condition = parser.Parse(node); if (condition != null) { if (negative) { condition = new NegativeCondition(condition); } conditions.Add(condition); } } // Now, process the nested <and> conditions. XmlNode childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { if (childNode.LocalName == Constants.ElementAnd) { ParseConditions(childNode, conditions, negative, config); XmlNode childNode2 = childNode.NextSibling; node.RemoveChild(childNode); childNode = childNode2; continue; } } childNode = childNode.NextSibling; } }
/// <summary> /// Constructor. /// </summary> /// <param name="contextFacade">The context facade to use.</param> /// <param name="configuration">The configuration to use.</param> public RewriterEngine(IContextFacade contextFacade, RewriterConfiguration configuration) { if (contextFacade == null) { throw new ArgumentNullException("contextFacade"); } if (configuration == null) { throw new ArgumentNullException("configuration"); } ContextFacade = contextFacade; _configuration = configuration; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string headerName = XmlNodeExtensions.GetRequiredAttribute(node, Constants.AttrHeader); string headerValue = XmlNodeExtensions.GetRequiredAttribute(node, Constants.AttrValue, true); return new AddHeaderAction(headerName, headerValue); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string cookieName = node.GetRequiredAttribute(Constants.AttrCookie); string cookieValue = node.GetRequiredAttribute(Constants.AttrValue, true); return new SetCookieAction(cookieName, cookieValue); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string propertyName = XmlNodeExtensions.GetRequiredAttribute(node, Constants.AttrProperty); string appSettingKey = XmlNodeExtensions.GetRequiredAttribute(node, Constants.AttrKey); return new SetAppSettingPropertyAction(propertyName, appSettingKey); }
/// <summary> /// Reads configuration information from the given XML Node. /// </summary> /// <param name="config">The rewriter configuration object to populate.</param> /// <param name="section">The XML node to read configuration from.</param> /// <returns>The configuration information.</returns> public static void Read(RewriterConfiguration config, XmlNode section) { if (section == null) { throw new ArgumentNullException("section"); } foreach (XmlNode node in section.ChildNodes) { if (node.NodeType == XmlNodeType.Element) { if (node.LocalName == Constants.ElementErrorHandler) { ReadErrorHandler(node, config); } else if (node.LocalName == Constants.ElementDefaultDocuments) { ReadDefaultDocuments(node, config); } else if (node.LocalName == Constants.ElementRegister) { if (node.Attributes[Constants.AttrParser] != null) { ReadRegisterParser(node, config); } else if (node.Attributes[Constants.AttrTransform] != null) { ReadRegisterTransform(node, config); } else if (node.Attributes[Constants.AttrLogger] != null) { ReadRegisterLogger(node, config); } } else if (node.LocalName == Constants.ElementMapping) { ReadMapping(node, config); } else { ReadRule(node, config); } } } }
private static void ReadRegisterLogger(XmlNode node, RewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = XmlNodeExtensions.GetRequiredAttribute(node, Constants.AttrLogger); // Logger type specified. Create an instance and add it // as the mapper handler for this map. IRewriteLogger logger = TypeHelper.Activate(type, null) as IRewriteLogger; if (logger != null) { config.Logger = logger; } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } XmlNode statusCodeNode = node.Attributes.GetNamedItem(Constants.AttrStatus); if (statusCodeNode == null) { return null; } return new SetStatusAction((HttpStatusCode)Convert.ToInt32(statusCodeNode.Value)); }
private static void ReadRegisterTransform(XmlNode node, RewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrTransform); // Transform type specified. // Create an instance and add it as the mapper handler for this map. IRewriteTransform transform = TypeHelper.Activate(type, null) as IRewriteTransform; if (transform == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, type, typeof(IRewriteTransform)), node); } config.TransformFactory.AddTransform(transform); }
private static void ReadRegisterTransform(XmlNode node, RewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrTransform); // Transform type specified. // Create an instance and add it as the mapper handler for this map. var transform = TypeHelper.Activate(type, null) as IRewriteTransform; if (transform == null) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.InvalidTypeSpecified, type, typeof (IRewriteTransform)), node); } config.TransformFactory.AddTransform(transform); }
/// <summary> /// Parses the action. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } var rule = new ConditionalAction(); // Process the conditions on the element. bool negative = (node.LocalName == Constants.ElementUnless); ParseConditions(node, rule.Conditions, negative, config); // Next, process the actions on the element. ReadActions(node, rule.Actions, config); return rule; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string to = node.GetRequiredAttribute(Constants.AttrTo, true); XmlNode processingNode = node.Attributes[Constants.AttrProcessing]; var processing = RewriteProcessing.ContinueProcessing; if (processingNode != null) { if (processingNode.Value == Constants.AttrValueRestart) { processing = RewriteProcessing.RestartProcessing; } else if (processingNode.Value == Constants.AttrValueStop) { processing = RewriteProcessing.StopProcessing; } else if (processingNode.Value != Constants.AttrValueContinue) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ValueOfProcessingAttribute, processingNode.Value, Constants.AttrValueContinue, Constants.AttrValueRestart, Constants.AttrValueStop), node); } } var action = new RewriteAction(to, processing); ParseConditions(node, action.Conditions, false, config); return action; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } string to = node.GetRequiredAttribute(Constants.AttrTo, true); bool permanent = true; XmlNode permanentNode = node.Attributes.GetNamedItem(Constants.AttrPermanent); if (permanentNode != null) { if (!bool.TryParse(permanentNode.Value, out permanent)) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidBooleanAttribute, Constants.AttrPermanent), node); } } RedirectAction action = new RedirectAction(to, permanent); ParseConditions(node, action.Conditions, false, config); return action; }
/// <summary> /// Load RewriterConfiguration Instance /// </summary> /// <returns></returns> public static RewriterConfiguration Load() { XmlNode section = System.Configuration.ConfigurationManager.GetSection(Constants.RewriterNode) as XmlNode; RewriterConfiguration configuration = null; XmlNode namedItem = section.Attributes.GetNamedItem(Constants.AttrFile); if (namedItem != null) { string filename = HttpContext.Current.Server.MapPath(namedItem.Value); configuration = LoadFromFile(filename); if (configuration != null) { CacheDependency dependencies = new CacheDependency(filename); HttpRuntime.Cache.Add(_cacheName, configuration, dependencies, DateTime.Now.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Normal, null); } } if (configuration == null) { configuration = LoadFromNode(section); HttpRuntime.Cache.Add(_cacheName, configuration, null, DateTime.Now.AddHours(1.0), TimeSpan.Zero, CacheItemPriority.Normal, null); } return(configuration); }
private static void ReadErrorHandler(XmlNode node, RewriterConfiguration config) { string code = node.GetRequiredAttribute(Constants.AttrCode); XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler = null; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, typeNode.Value, typeof(IRewriteErrorHandler)), node); } } else { handler = new DefaultErrorHandler(urlNode.Value); } int statusCode; if (!Int32.TryParse(code, out statusCode)) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidHttpStatusCode, code), node); } config.ErrorHandlers.Add(statusCode, handler); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { return new MethodNotAllowedAction(); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { return new ForbiddenAction(); }
/// <summary> /// Parses the action. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, null if no action parsed.</returns> public abstract IRewriteAction Parse(XmlNode node, RewriterConfiguration config);
private static void ReadErrorHandler(XmlNode node, RewriterConfiguration config) { XmlNode codeNode = node.Attributes[Constants.AttrCode]; if (codeNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrCode), node); } XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler = null; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified)); } } else { handler = new DefaultErrorHandler(urlNode.Value); } config.ErrorHandlers.Add(Convert.ToInt32(codeNode.Value), handler); }
private static void ReadRegisterTransform(XmlNode node, RewriterConfiguration config) { // Type attribute. XmlNode typeNode = node.Attributes[Constants.AttrTransform]; if (typeNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrTransform), node); } if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } // Transform type specified. Create an instance and add it // as the mapper handler for this map. IRewriteTransform handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteTransform; if (handler != null) { config.TransformFactory.AddTransform(handler); } else { // TODO: Error due to type. } }
private static void ReadRegisterParser(XmlNode node, RewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrParser); object parser = TypeHelper.Activate(type, null); var actionParser = parser as IRewriteActionParser; if (actionParser != null) { config.ActionParserFactory.AddParser(actionParser); } var conditionParser = parser as IRewriteConditionParser; if (conditionParser != null) { config.ConditionParserPipeline.AddParser(conditionParser); } }
private static void ReadErrorHandler(XmlNode node, RewriterConfiguration config) { string code = node.GetRequiredAttribute(Constants.AttrCode); XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler = null; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.InvalidTypeSpecified, typeNode.Value, typeof (IRewriteErrorHandler)), node); } } else { handler = new DefaultErrorHandler(urlNode.Value); } int statusCode; if (!Int32.TryParse(code, out statusCode)) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.InvalidHttpStatusCode, code), node); } config.ErrorHandlers.Add(statusCode, handler); }
private static void ReadMapping(XmlNode node, RewriterConfiguration config) { // Name attribute. XmlNode nameNode = node.Attributes[Constants.AttrName]; // Mapper type not specified. Load in the hash map. var map = new StringDictionary(); foreach (XmlNode mapNode in node.ChildNodes) { if (mapNode.NodeType == XmlNodeType.Element) { if (mapNode.LocalName == Constants.ElementMap) { string fromValue = mapNode.GetRequiredAttribute(Constants.AttrFrom, true); string toValue = mapNode.GetRequiredAttribute(Constants.AttrTo, true); map.Add(fromValue, toValue); } else { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNotAllowed, mapNode.LocalName), node); } } } config.TransformFactory.AddTransform(new StaticMappingTransform(nameNode.Value, map)); }
private static void ReadRule(XmlNode node, RewriterConfiguration config) { bool parsed = false; IList<IRewriteActionParser> parsers = config.ActionParserFactory.GetParsers(node.LocalName); if (parsers != null) { foreach (IRewriteActionParser parser in parsers) { if (!parser.AllowsNestedActions && node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoElements, parser.Name), node); } if (!parser.AllowsAttributes && node.Attributes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoAttributes, parser.Name), node); } IRewriteAction rule = parser.Parse(node, config); if (rule != null) { config.Rules.Add(rule); parsed = true; break; } } } if (!parsed) { // No parsers recognised to handle this node. throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNotAllowed, node.LocalName), node); } }
private static void ReadRegisterLogger(XmlNode node, RewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException( MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrLogger); // Logger type specified. Create an instance and add it // as the mapper handler for this map. var logger = TypeHelper.Activate(type, null) as IRewriteLogger; if (logger != null) { config.Logger = logger; } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, RewriterConfiguration config) { return new NotImplementedAction(); }