InversionOfControl/Castle.Windsor/Configuration/Interpreters/XmlInterpreter.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Windsor.Configuration.Interpreters
  16 {
  17         using System;
  18         using System.Xml;
  19         using System.Configuration;
  20         using Castle.Core.Configuration.Xml;
  21         using Castle.Core.Resource;
  22         using Castle.Core.Configuration;
  23
  24         using Castle.MicroKernel;
  25         using Castle.MicroKernel.SubSystems.Resource;
  26
  27         using Castle.Windsor.Configuration.Interpreters.XmlProcessor;
  28
  29         /// <summary>
  30         /// Reads the configuration from a XmlFile. Sample structure:
  31         /// <code>
  32         /// &lt;configuration&gt;
  33         ///   &lt;facilities&gt;
  34         ///     &lt;facility id="myfacility"&gt;
  35         ///
  36         ///     &lt;/facility&gt;
  37         ///   &lt;/facilities&gt;
  38         ///
  39         ///   &lt;components&gt;
  40         ///     &lt;component id="component1"&gt;
  41         ///
  42         ///     &lt;/component&gt;
  43         ///   &lt;/components&gt;
  44         /// &lt;/configuration&gt;
  45         /// </code>
  46         /// </summary>
  47         public class XmlInterpreter : AbstractInterpreter
  48         {
  49                 private IKernel kernel;
  50
  51                 #region Constructors
  52
  53                 /// <summary>
  54                 /// Initializes a new instance of the <see cref="XmlInterpreter"/> class.
  55                 /// </summary>
  56                 public XmlInterpreter()
  57                 {
  58                 }
  59
  60                 /// <summary>
  61                 /// Initializes a new instance of the <see cref="XmlInterpreter"/> class.
  62                 /// </summary>
  63                 /// <param name="filename">The filename.</param>
  64                 public XmlInterpreter(String filename) : base(filename)
  65                 {
  66                 }
  67
  68                 /// <summary>
  69                 /// Initializes a new instance of the <see cref="XmlInterpreter"/> class.
  70                 /// </summary>
  71                 /// <param name="source">The source.</param>
  72                 public XmlInterpreter(Castle.Core.Resource.IResource source) : base(source)
  73                 {
  74                 }
  75
  76                 #endregion
  77
  78                 /// <summary>
  79                 /// Gets or sets the kernel.
  80                 /// </summary>
  81                 /// <value>The kernel.</value>
  82                 public IKernel Kernel
  83                 {
  84                         get { return kernel ; }
  85                         set { kernel = value; }
  86                 }
  87
  88                 public override void ProcessResource(IResource source, IConfigurationStore store)
  89                 {
  90                         XmlProcessor.XmlProcessor processor = (kernel == null) ?
  91                                 new XmlProcessor.XmlProcessor(EnvironmentName) :
  92                                 new XmlProcessor.XmlProcessor(EnvironmentName,
  93                                         kernel.GetSubSystem(SubSystemConstants.ResourceKey) as IResourceSubSystem);
  94
  95                         try
  96                         {
  97                                 XmlNode element = processor.Process(source);
  98
  99                                 Deserialize(element, store);
 100                         }
 101                         catch(XmlProcessorException)
 102                         {
 103                                 string message = "Unable to process xml resource ";
 104
 105                                 throw new ConfigurationErrorsException(message);
 106                         }
 107                 }
 108
 109                 protected void Deserialize(XmlNode section, IConfigurationStore store)
 110                 {
 111                         foreach(XmlNode node in section)
 112                         {
 113                                 if (XmlConfigurationDeserializer.IsTextNode(node))
 114                                 {
 115                                         string message = String.Format("{0} cannot contain text nodes", node.Name);
 116
 117                                         throw new ConfigurationErrorsException(message);
 118                                 }
 119                                 else if (node.NodeType == XmlNodeType.Element)
 120                                 {
 121                                         DeserializeElement(node, store);
 122                                 }
 123                         }
 124                 }
 125
 126                 private void DeserializeElement(XmlNode node, IConfigurationStore store)
 127                 {
 128                         if (ContainersNodeName.Equals(node.Name))
 129                         {
 130                                 DeserializeContainers(node.ChildNodes, store);
 131                         }
 132                         else if (FacilitiesNodeName.Equals(node.Name))
 133                         {
 134                                 DeserializeFacilities(node.ChildNodes, store);
 135                         }
 136                         else if (ComponentsNodeName.Equals(node.Name))
 137                         {
 138                                 DeserializeComponents(node.ChildNodes, store);
 139                         }
 140                         else if (BootstrapNodeName.Equals(node.Name))
 141                         {
 142                                 DeserializeBootstrapComponents(node.ChildNodes, store);
 143                         }
 144                         else
 145                         {
 146                                 string message = string.Format(
 147                                         "Configuration parser encountered <{0}>, but it was expecting to find " +
 148                                         "<{1}>, <{2}>, <{3}> or <{4}>. There might be either a typo on <{0}> or " +
 149                                         "you might have forgotten to nest it properly.",
 150                                         node.Name, ContainersNodeName, FacilitiesNodeName, ComponentsNodeName, BootstrapNodeName);
 151                                 throw new ConfigurationErrorsException(message);
 152                         }
 153                 }
 154
 155                 private void DeserializeContainers(XmlNodeList nodes, IConfigurationStore store)
 156                 {
 157                         foreach(XmlNode node in nodes)
 158                         {
 159                                 if (node.NodeType == XmlNodeType.Element)
 160                                 {
 161                                         AssertNodeName(node, ContainerNodeName);
 162
 163                                         DeserializeContainer(node, store);
 164                                 }
 165                         }
 166                 }
 167
 168                 private void DeserializeContainer(XmlNode node, IConfigurationStore store)
 169                 {
 170                         String name = GetRequiredAttributeValue(node, "name");
 171
 172                         IConfiguration config = XmlConfigurationDeserializer.GetDeserializedNode(node);
 173                         IConfiguration newConfig = new MutableConfiguration(config.Name, node.InnerXml);
 174
 175                         // Copy all attributes
 176                         string[] allKeys = config.Attributes.AllKeys;
 177
 178                         foreach(string key in allKeys)
 179                         {
 180                                 newConfig.Attributes.Add(key, config.Attributes[key]);
 181                         }
 182
 183                         // Copy all children
 184                         newConfig.Children.AddRange(config.Children);
 185
 186                         AddChildContainerConfig(name, newConfig, store);
 187                 }
 188
 189                 private void DeserializeFacilities(XmlNodeList nodes, IConfigurationStore store)
 190                 {
 191                         foreach(XmlNode node in nodes)
 192                         {
 193                                 if (node.NodeType == XmlNodeType.Element)
 194                                 {
 195                                         AssertNodeName(node, FacilityNodeName);
 196
 197                                         DeserializeFacility(node, store);
 198                                 }
 199                         }
 200                 }
 201
 202                 private void DeserializeFacility(XmlNode node, IConfigurationStore store)
 203                 {
 204                         String id = GetRequiredAttributeValue(node, "id");
 205
 206                         IConfiguration config = XmlConfigurationDeserializer.GetDeserializedNode(node);
 207
 208                         AddFacilityConfig(id, config, store);
 209                 }
 210
 211                 private void DeserializeComponents(XmlNodeList nodes, IConfigurationStore store)
 212                 {
 213                         foreach(XmlNode node in nodes)
 214                         {
 215                                 if (node.NodeType == XmlNodeType.Element)
 216                                 {
 217                                         AssertNodeName(node, ComponentNodeName);
 218
 219                                         DeserializeComponent(node, store);
 220                                 }
 221                         }
 222                 }
 223
 224                 private void DeserializeBootstrapComponents(XmlNodeList nodes, IConfigurationStore store)
 225                 {
 226                         foreach(XmlNode node in nodes)
 227                         {
 228                                 if (node.NodeType == XmlNodeType.Element)
 229                                 {
 230                                         AssertNodeName(node, ComponentNodeName);
 231
 232                                         DeserializeBootstrapComponent(node, store);
 233                                 }
 234                         }
 235                 }
 236
 237                 private void DeserializeComponent(XmlNode node, IConfigurationStore store)
 238                 {
 239                         String id = GetRequiredAttributeValue(node, "id");
 240
 241                         IConfiguration config = XmlConfigurationDeserializer.GetDeserializedNode(node);
 242
 243                         AddComponentConfig(id, config, store);
 244                 }
 245
 246                 private void DeserializeBootstrapComponent(XmlNode node, IConfigurationStore store)
 247                 {
 248                         String id = GetRequiredAttributeValue(node, "id");
 249
 250                         IConfiguration config = XmlConfigurationDeserializer.GetDeserializedNode(node);
 251
 252                         AddBootstrapComponentConfig(id, config, store);
 253                 }
 254
 255                 private String GetRequiredAttributeValue(XmlNode node, String attName)
 256                 {
 257                         String value = GetAttributeValue(node, attName);
 258
 259                         if (value.Length == 0)
 260                         {
 261                                 String message = String.Format("{0} elements expects required non blank attribute {1}",
 262                                                                node.Name, attName);
 263
 264                                 throw new ConfigurationErrorsException(message);
 265                         }
 266
 267                         return value;
 268                 }
 269
 270                 private String GetAttributeValue(XmlNode node, String attName)
 271                 {
 272                         XmlAttribute att = node.Attributes[attName];
 273
 274                         return (att == null) ? String.Empty : att.Value.Trim();
 275                 }
 276
 277                 private void AssertNodeName(XmlNode node, string expectedName)
 278                 {
 279                         if (!expectedName.Equals(node.Name))
 280                         {
 281                                 String message = String.Format("Unexpected node under '{0}': Expected '{1}' but found '{2}'",
 282                                                                expectedName, expectedName, node.Name);
 283
 284                                 throw new ConfigurationErrorsException(message);
 285                         }
 286                 }
 287         }
 288 }