private void ProcessExtensionsNode(XmlNode routingNode, MonoRailConfiguration config) { foreach (XmlNode node in routingNode.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } if (node.Name != Extension_Node_Name) { String message = String.Format("Unexpected node '{0}' within '{1}' node. " + "Expected {2}", node.Name, Extensions_Node_Name, Extension_Node_Name); throw new ConfigurationException(message); } XmlAttribute typeAtt = node.Attributes["type"]; if (typeAtt == null || typeAtt.Value.Length == 0) { String message = String.Format("An {0} node must have a 'type' attribute " + "to declare the extension full type name", Extension_Node_Name); throw new ConfigurationException(message); } config.Extensions.Add(typeAtt.Value); } }
/// <summary> /// Creates a configuration section handler. /// </summary> /// <param name="parent"></param> /// <param name="configContext">Configuration context object.</param> /// <param name="section"></param> /// <returns>The created section handler object.</returns> public virtual object Create(object parent, object configContext, XmlNode section) { MonoRailConfiguration config = new MonoRailConfiguration(section); Deserialize(section, config); return config; }
/// <summary> /// Creates a configuration section handler. /// </summary> /// <param name="parent"></param> /// <param name="configContext">Configuration context object.</param> /// <param name="section"></param> /// <returns>The created section handler object.</returns> public virtual object Create(object parent, object configContext, XmlNode section) { var config = new MonoRailConfiguration(section); Deserialize(section, config); return(config); }
protected void Validate(MonoRailConfiguration config) { if (config.CustomControllerFactory != null) { ValidateTypeImplements(config.CustomControllerFactory, typeof(IControllerFactory)); } else { if (config.ControllerAssemblies.Count == 0) { throw new ConfigurationException("Inside the node controllers, you have to specify " + "at least one assembly entry"); } } IList extensionTypes = new ArrayList(); foreach (String typeName in config.Extensions) { Type extensionType = MonoRailConfiguration.GetType(typeName); ValidateTypeImplements(extensionType, typeof(IMonoRailExtension)); extensionTypes.Add(extensionType); } config.Extensions = extensionTypes; if (config.CustomFilterFactory != null) { ValidateTypeImplements(config.CustomFilterFactory, typeof(IFilterFactory)); } if (config.CustomViewComponentFactory != null) { ValidateTypeImplements(config.CustomViewComponentFactory, typeof(IViewComponentFactory)); } if (config.CustomEngineTypeName != null) { ValidateTypeImplements(config.CustomEngineTypeName, typeof(IViewEngine)); } if (config.ViewsPhysicalPath == null || config.ViewsPhysicalPath.Length == 0) { throw new ConfigurationException("You must provide a '" + Views_Node_Name + "' node and a " + "absolute or relative path to the views directory with the attribute " + View_Path_Root); } // Reasonable assumption if (config.ControllerAssemblies.Count != 0 && config.ComponentsAssemblies.Count == 0) { foreach (String entry in config.ControllerAssemblies) { config.ComponentsAssemblies.Add(entry); } } }
private void ProcessComponentFactoryNode(XmlNode node, MonoRailConfiguration config) { XmlAttribute type = node.Attributes["type"]; if (type == null) { throw new ConfigurationException("The custom controller factory node must specify a 'type' attribute"); } config.CustomViewComponentFactory = type.Value; }
private static void AssertCommon( MonoRailConfiguration config ) { Assert.AreEqual( "castleproject.org", config.SmtpConfig.Host); Assert.AreEqual( "secret", config.SmtpConfig.Password); Assert.AreEqual( "JoeDoe", config.SmtpConfig.Username); Assert.AreEqual( "Castle.MonoRail.Framework.Views.NVelocity.NVelocityViewEngine", config.ViewEngineConfig.ViewEngines[0].Engine.FullName ); Assert.AreEqual( "MoviesDemo", config.ControllersConfig.Assemblies[0] ); Assert.IsTrue( config.ViewEngineConfig.ViewPathRoot.EndsWith("views") ); }
private void ProcessComponentsNode(XmlNode controllersNode, MonoRailConfiguration config) { foreach (XmlNode node in controllersNode.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } ProcessComponentEntry(node, config); } }
private void ProcessRoutingNode(XmlNode routingNode, MonoRailConfiguration config) { foreach (XmlNode node in routingNode.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } ProcessRuleEntry(node, config); } }
private void ProcessComponentEntry(XmlNode componentNode, MonoRailConfiguration config) { if (!componentNode.HasChildNodes) { throw new ConfigurationException("Inside the node components, you have to specify the assemblies " + "through the value of each child node"); } String assemblyName = componentNode.FirstChild.Value; config.ComponentsAssemblies.Add(assemblyName); }
internal static MonoRailConfiguration GetConfig() { MonoRailConfiguration config = (MonoRailConfiguration) ConfigurationSettings.GetConfig(MonoRailConfiguration.SectionName); if (config == null) { throw new ApplicationException("Unfortunately, you have to provide " + "a small configuration to use MonoRail. Check the samples or the documentation."); } return(config); }
private void ProcessRuleEntry(XmlNode node, MonoRailConfiguration config) { XmlNode patternNode = node.SelectSingleNode("pattern"); XmlNode replaceNode = node.SelectSingleNode("replace"); if (patternNode == null || patternNode.ChildNodes[0] == null) { throw new ConfigurationException("A rule node must have a pattern (child) node denoting the regular expression to be matched"); } if (replaceNode == null || replaceNode.ChildNodes[0] == null) { throw new ConfigurationException("A rule node must have a replace (child) node denoting the string to be replaced"); } String pattern = patternNode.ChildNodes[0].Value; String replace = replaceNode.ChildNodes[0].Value; config.RoutingRules.Add(new RoutingRule(pattern.Trim(), replace.Trim())); }
private void ProcessViewNode(XmlNode node, MonoRailConfiguration config) { XmlAttribute viewPath = node.Attributes[View_Path_Root]; if (viewPath == null) { throw new ConfigurationException("The views node must specify the '" + View_Path_Root + "' attribute"); } String path = viewPath.Value; if (!Path.IsPathRooted(path)) { path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path); } config.ViewsPhysicalPath = path; XmlAttribute xhtmlRendering = node.Attributes["xhtmlRendering"]; if (xhtmlRendering != null) { try { config.ViewsXhtmlRendering = bool.Parse(xhtmlRendering.Value); } catch (FormatException ex) { throw new ConfigurationException("The xhtmlRendering attribute of the views node must be a boolean value.", ex); } } XmlAttribute customEngine = node.Attributes["customEngine"]; if (customEngine != null) { config.CustomEngineTypeName = customEngine.Value; } }
public object Create(object parent, object configContext, XmlNode section) { MonoRailConfiguration config = new MonoRailConfiguration(); config.ConfigSection = section; XmlAttribute useWindsorAtt = section.Attributes["useWindsorIntegration"]; if (useWindsorAtt != null && "true".Equals(useWindsorAtt.Value)) { ConfigureWindsorIntegration(config); } XmlAttribute smtpHostAtt = section.Attributes["smtpHost"]; XmlAttribute smtpUserAtt = section.Attributes["smtpUsername"]; XmlAttribute smtpPwdAtt = section.Attributes["smtpPassword"]; if (smtpHostAtt != null && smtpHostAtt.Value != String.Empty) { config.SmtpConfig.Host = smtpHostAtt.Value; } if (smtpUserAtt != null && smtpUserAtt.Value != String.Empty) { config.SmtpConfig.Username = smtpUserAtt.Value; } if (smtpPwdAtt != null && smtpPwdAtt.Value != String.Empty) { config.SmtpConfig.Password = smtpPwdAtt.Value; } foreach (XmlNode node in section.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } if (String.Compare(Controllers_Node_Name, node.Name, true) == 0) { ProcessControllersNode(node, config); } else if (String.Compare(Components_Node_Name, node.Name, true) == 0) { ProcessComponentsNode(node, config); } else if (String.Compare(Views_Node_Name, node.Name, true) == 0) { ProcessViewNode(node, config); } else if (String.Compare(Custom_Controller_Factory_Node_Name, node.Name, true) == 0) { ProcessControllerFactoryNode(node, config); } else if (String.Compare(Custom_Component_Factory_Node_Name, node.Name, true) == 0) { ProcessComponentFactoryNode(node, config); } else if (String.Compare(Custom_Filter_Factory_Node_Name, node.Name, true) == 0) { ProcessFilterFactoryNode(node, config); } else if (String.Compare(Routing_Node_Name, node.Name, true) == 0) { ProcessRoutingNode(node, config); } else if (String.Compare(Extensions_Node_Name, node.Name, true) == 0) { ProcessExtensionsNode(node, config); } } Validate(config); return(config); }
private void ConfigureWindsorIntegration(MonoRailConfiguration config) { config.CustomControllerFactory = "Castle.MonoRail.WindsorExtension.WindsorControllerFactory, Castle.MonoRail.WindsorExtension"; config.CustomFilterFactory = "Castle.MonoRail.WindsorExtension.WindsorFilterFactory, Castle.MonoRail.WindsorExtension"; config.CustomViewComponentFactory = "Castle.MonoRail.WindsorExtension.WindsorViewComponentFactory, Castle.MonoRail.WindsorExtension"; }
public void ShouldSetupBrail() { var config = new MonoRailConfiguration(); app.Configure(config); Assert.That(config.ViewEngineConfig.ViewPathRoot.EndsWith("\\Views", StringComparison.OrdinalIgnoreCase)); Assert.That(config.ViewEngineConfig.ViewEngines.Any(x => x.Engine == typeof(BooViewEngine))); }
/// <summary> /// Reads the attribute <c>customSession</c> /// from <see cref="MonoRailConfiguration"/> and /// instantiate it based on the type name provided. /// </summary> /// <exception cref="ConfigurationException"> /// If the typename was not provided or the type /// could not be instantiated/found /// </exception> /// <param name="manager">The Extension Manager</param> /// <param name="configuration">The configuration</param> private void Init(ExtensionManager manager, MonoRailConfiguration configuration) { manager.AcquireSessionState += OnAdquireSessionState; manager.ReleaseSessionState += OnReleaseSessionState; XmlAttribute customSessionAtt = configuration.ConfigurationSection.Attributes["customSession"]; if (customSessionAtt == null || customSessionAtt.Value.Length == 0) { String message = "The CustomSessionExtension requires that " + "the type that implements ICustomSessionFactory be specified through the " + "'customSession' attribute on 'monorail' configuration node"; throw new ConfigurationErrorsException(message); } Type customSessType = TypeLoadUtil.GetType(customSessionAtt.Value); if (customSessType == null) { String message = "The Type for the custom session could not be loaded. " + customSessionAtt.Value; throw new ConfigurationErrorsException(message); } try { customSession = (ICustomSessionFactory) Activator.CreateInstance(customSessType); } catch(InvalidCastException) { String message = "The Type for the custom session must " + "implement ICustomSessionFactory. " + customSessionAtt.Value; throw new ConfigurationErrorsException(message); } }
/// <summary> /// Deserializes the config section. /// </summary> /// <param name="section">The section.</param> /// <param name="config">The config.</param> private void Deserialize(XmlNode section, MonoRailConfiguration config) { config.Deserialize(section); }