public void TestConvertXmlDocument()
{
StringBuilder xml = new StringBuilder();
xml.Append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
xml.Append("<!--document comment-->");
xml.Append("<root>");
xml.Append("<child1 a1=\"val1\" a2=\"val2\">");
xml.Append("<!--first comment-->");
xml.Append("child1 value");
xml.Append("<!--second comment-->");
xml.Append("</child1>");
xml.Append("<child2>");
xml.Append("<![CDATA[cdata value ]]>");
xml.Append("child2 value");
xml.Append("</child2>");
xml.Append("</root>");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xml.ToString());
Assert.IsNotNull(xmlDoc);
IXmlDocument convXmlDoc = XmlHelper.ConvertDocument(xmlDoc);
Assert.IsNotNull(convXmlDoc);
Assert.AreEqual(convXmlDoc.Encoding, "utf-8");
Assert.IsNull(convXmlDoc.DtdName);
Assert.IsNull(convXmlDoc.DtdUri);
Assert.AreEqual(convXmlDoc.DocumentComment, "document comment");
Assert.AreEqual(convXmlDoc.Name, "root");
Assert.AreEqual(convXmlDoc.ElementList.Count, 2);
IXmlElement child1 = convXmlDoc.GetElement("child1");
Assert.IsNotNull(child1);
Assert.AreEqual(child1.Attributes.Count, 2);
Assert.IsTrue(child1.Attributes.Contains("a1"));
Assert.AreEqual(child1.GetAttribute("a1").GetString(), "val1");
Assert.IsTrue(child1.Attributes.Contains("a2"));
Assert.AreEqual(child1.GetAttribute("a2").GetString(), "val2");
Assert.AreEqual(child1.GetString(), "child1 value");
Assert.AreEqual(child1.Comment, "first comment\nsecond comment");
IXmlElement child2 = convXmlDoc.GetElement("child2");
Assert.IsNotNull(child2);
Assert.AreEqual(child2.Attributes.Count, 0);
Assert.AreEqual(child2.GetString(), "cdata value child2 value");
Assert.IsTrue(child2.Comment.Length == 0);
}
/// <summary>
/// Parse the given <b>IXmlElement</b> as a local <b>IPEndPoint</b>.
/// </summary>
/// <remarks>
/// If the specified <b>IXmlElement</b> contains an empty address,
/// <c>null</c> is returned.
/// </remarks>
/// <param name="xml">
/// The <b>IXmlElement</b> to parse.
/// </param>
/// <returns>
/// A new <b>IPEndPoint</b> representing the contents of the given
/// <b>XmlNode</b>.
/// </returns>
protected static IPEndPoint ParseLocalSocketAddress(IXmlElement xml)
{
IXmlElement xmlAddr = xml.GetElement("address");
IXmlElement xmlPort = xml.GetElement("port");
String sAddressFamiliy =
xml.GetSafeElement("address-family").GetString(
"InterNetwork");
if (xmlAddr == null && xmlPort == null)
{
return(null);
}
string addr = xmlAddr == null ? "localhost" : xmlAddr.GetString();
int port = xmlPort == null ? 0 : xmlPort.GetInt();
NetworkUtils.PreferredAddressFamily =
(AddressFamily)
Enum.Parse(typeof(AddressFamily), sAddressFamiliy);
IPAddress ipAddress;
try
{
ipAddress = addr.Equals("localhost")
? NetworkUtils.GetLocalHostAddress()
: NetworkUtils.GetHostAddress(addr);
}
catch (Exception e)
{
throw new Exception("The \"" + xml.Name + "\" configuration "
+
"element contains an invalid \"address\" element",
e);
}
try
{
return(new IPEndPoint(ipAddress, port));
}
catch (Exception e)
{
throw new Exception("The \"" + xml.Name + "\" configuration "
+
"element contains an invalid \"port\" element",
e);
}
}
/// <summary>
/// Configure the controllable service.
/// </summary>
/// <remarks>
/// <p/>
/// This method can only be called before the controllable service
/// is started.
/// </remarks>
/// <param name="xml">
/// An <see cref="IXmlElement"/> carrying configuration information
/// specific to the IControllable object.
/// </param>
/// <exception cref="InvalidOperationException">
/// Thrown if the service is already running.
/// </exception>
/// <exception cref="ArgumentException">
/// Thrown if the configuration information is invalid.
/// </exception>
public override void Configure(IXmlElement xml)
{
lock (this)
{
base.Configure(xml);
if (xml == null)
{
return;
}
// <tcp-initiator>
IXmlElement xmlCat = xml.GetSafeElement("tcp-initiator");
// <stream-provider/>
IXmlElement xmlSub = xmlCat.GetSafeElement("stream-provider");
StreamProvider = StreamProviderFactory.CreateProvider(xmlSub);
// <local-address>
xmlSub = xmlCat.GetSafeElement("local-address");
// <address>
// <port>
LocalAddress = ParseLocalSocketAddress(xmlSub);
// <reusable>
IsLocalAddressReusable = xmlSub.GetSafeElement("reusable").
GetBoolean(IsLocalAddressReusable);
// <remote-addresses>
bool isNameService = false;
xmlSub = xmlCat.GetElement("name-service-addresses");
if (xmlSub == null)
{
xmlSub = xmlCat.GetSafeElement("remote-addresses");
}
else
{
isNameService = true;
}
IAddressProviderFactory factory;
IXmlElement xmlProvider = xmlSub.GetElement("address-provider");
bool missing = xmlProvider == null;
bool empty = !missing && xmlProvider.IsEmpty;
if (empty || missing)
{
ConfigurableAddressProviderFactory factoryImpl =
new ConfigurableAddressProviderFactory();
factoryImpl.Config = missing ? xmlSub : xmlProvider;
factory = factoryImpl;
}
else
{
String name = xmlProvider.GetString();
factory = (IAddressProviderFactory)
OperationalContext.AddressProviderMap[name];
if (factory == null)
{
throw new ArgumentException("Address provider "
+ name + " not found.");
}
}
RemoteAddressProvider = factory.CreateAddressProvider();
if (RemoteAddressProvider is ConfigurableAddressProvider && ConnectTimeout > 0)
{
((ConfigurableAddressProvider)RemoteAddressProvider).RequestTimeout = ConnectTimeout;
}
IsNameService = isNameService;
if (isNameService)
{
Subport = (int)WellKnownSubPorts.NameService;
}
else
{
Subport = -1;
}
// <reuse-address>
IsLocalAddressReusable = xmlCat.GetSafeElement("reuse-address").
GetBoolean(IsLocalAddressReusable);
// <keep-alive-enabled/>
IsKeepAliveEnabled = xmlCat.GetSafeElement("keep-alive-enabled")
.
GetBoolean(IsKeepAliveEnabled);
// <tcp-delay-enabled>
IsTcpDelayEnabled = xmlCat.GetSafeElement("tcp-delay-enabled").
GetBoolean(IsTcpDelayEnabled);
// <receive-buffer-size>
ReceiveBufferSize = ParseMemorySize(
xmlCat, "receive-buffer-size", ReceiveBufferSize);
// <send-buffer-size>
SendBufferSize = ParseMemorySize(
xmlCat, "send-buffer-size", SendBufferSize);
// <linger-timeout>
LingerTimeout = ParseTime(
xmlCat, "linger-timeout", LingerTimeout);
}
}
