Recently I had a critical problem in Lombardi to discover the WSDL generated from WCF (Windows Communication Foundation) - A communication framework from .NET platform.
WCF is Microsoft’s unified programming model for building service-oriented
applications. It enables developers to build secure, reliable,
transacted solutions that integrate across platforms and interoperate
with existing investments and allows exposure services in many endpoint types, such, NET.TCP (native from .Net Applications), BasicHTTP (SOAP), REST, and others.
Eg:
<service behaviorConfiguration="DefaultBehavior" name="CustomerService">
<endpoint address="" binding="basicHttpBinding" bindingConfiguration="SecureHttpBinding" contract="Services.Contracts.ICustomer" />
<endpoint address="" binding="netTcpBinding" bindingConfiguration="SecureTcpBinding" contract="Services.Contracts.ICustomer" />
<endpoint address="mex" binding="mexTcpBinding" contract="IMetadataExchange" />
<host>
<baseAddresses>
<add baseAddress="/Customer.svc" />
</baseAddresses>
</host>
</service>
The above configuration will expose the service over HTTP and NET.TCP Protocols and will generate a WSDL for the "basicHttpBinding".
The problem is than the WSDL, automatically generated, contains references to SOAP 1.2, not supported by IBM Lombardi, causing error in import the service specifications.
Because of the automatically WSDL generation by WCF you can't modify or manipulate him.
The IBM's support was unable to solve this problem on your tool, and then we had to created our own solution, consisting basically intercepting the request to the service WSDL, changing him.
How does this? Our services are hosted on IIS (Microsoft Information Services), then we would have to create a HTTP Handler to do the necessary transformation on the WSDL and return him so that the Lombardi so that can interpret him, removing SOAP 1.2 references.
We create a .NET Library responsible for getting the original service's WSDL and transform him. After it must be registered as HTTP Handler in IIS:
public class WsdlTransformationHandler : IHttpHandler
{
/// <summary>
/// Gets a value indicating whether another request can use the WsdlTransformationHandler instance.
/// </summary>
public bool IsReusable
{
get { return true; }
}
/// <summary>
/// Enables processing of HTTP Web requests by the WsdlTransformationHandler.
/// </summary>
/// <param name="context">
/// An System.Web.HttpContext object that provides references to the
/// intrinsic server objects used to service HTTP requests.
/// </param>
public void ProcessRequest(HttpContext context)
{
string url = context.Request.Url.OriginalString;
string wsdlContent = string.Empty;
try
{
url = url.Replace(".wsdlt", ".svc?wsdl");
wsdlContent = GetWsdlFromService(url);
wsdlContent = TransformWsdl(wsdlContent);
Write(context, wsdlContent);
}
catch (Exception ex)
{
Write(context, FormatError(ex, new Dictionary<string, string>()
{
{"URL", url}
}));
}
}
/// <summary>
/// Request the original Wsdl from a service
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
private string GetWsdlFromService(string url)
{
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
HttpWebRequest webRequest = WebRequest.Create(url) as HttpWebRequest;
webRequest.AllowAutoRedirect = true;
webRequest.Method = "GET";
using (WebResponse webResponse = webRequest.GetResponse())
{
using (StreamReader _responseStream = new StreamReader(webResponse.GetResponseStream()))
{
return _responseStream.ReadToEnd();
}
}
}
/// <summary>
/// Transform Wsdl to soap 1.1 definitions without NetTcp references.
/// </summary>
/// <param name="originalWsdl"></param>
/// <returns></returns>
private string TransformWsdl(string originalWsdl)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(originalWsdl);
RemoveInvalidAttributes(xmlDoc);
RemoveInvalidElements(xmlDoc);
return xmlDoc.OuterXml;
}
/// <summary>
/// Remove invalid attributes from Wsdl
/// </summary>
/// <param name="xmlDoc"></param>
private void RemoveInvalidAttributes(XmlDocument xmlDoc)
{
XmlAttribute soap12Attribute = null;
foreach (XmlAttribute attrItem in xmlDoc.DocumentElement.Attributes)
{
if (attrItem.Name.Contains("xmlns:soap12"))
soap12Attribute = attrItem;
}
if (soap12Attribute != null)
xmlDoc.DocumentElement.Attributes.Remove(soap12Attribute);
}
/// <summary>
/// Remove NetTcp elements from Wsdl
/// </summary>
/// <param name="xmlDoc"></param>
private void RemoveInvalidElements(XmlDocument xmlDoc)
{
List<XmlElement> netTcpElements = new List<XmlElement>();
foreach (XmlElement element in xmlDoc.DocumentElement.ChildNodes)
{
if (element.Name.Contains("wsdl:service"))
RemoveInvalidPorts(element);
foreach (XmlAttribute attribute in element.Attributes)
{
if (attribute.Value.ToUpper().Contains("NETTCP"))
{
netTcpElements.Add(element);
break;
}
}
}
foreach (XmlElement netTcpElement in netTcpElements)
xmlDoc.DocumentElement.RemoveChild(netTcpElement);
}
/// <summary>
/// Remove NetTcp port definition from Wsdl
/// </summary>
/// <param name="xmlElement"></param>
private void RemoveInvalidPorts(XmlElement xmlElement)
{
List<XmlElement> netTcpElements = new List<XmlElement>();
foreach (XmlElement portElement in xmlElement.ChildNodes)
{
foreach (XmlAttribute attribute in portElement.Attributes)
{
if (attribute.Value.ToUpper().Contains("NETTCP"))
{
netTcpElements.Add(portElement);
break;
}
}
}
foreach (XmlElement netTcpElement in netTcpElements)
xmlElement.RemoveChild(netTcpElement);
}
/// <summary>
/// Write the transformed Wsdl to Response
/// </summary>
/// <param name="context"></param>
/// <param name="content"></param>
private void Write(HttpContext context, string content)
{
context.Response.Clear();
context.Response.ContentType = "text/plain";
context.Response.ContentEncoding = Encoding.UTF8;
context.Response.ContentType = "text/plain; charset=utf-8";
context.Response.Write(content);
}
/// <summary>
/// Format exception message to display
/// </summary>
/// <param name="ex"></param>
/// <param name="additionalData"></param>
/// <returns></returns>
private string FormatError(Exception ex, Dictionary<string, string> additionalData = null)
{
StringBuilder _sb = new StringBuilder();
_sb.AppendLine("ERROR");
_sb.AppendLine();
_sb.AppendLine("Message: " + ex.Message);
_sb.AppendLine("Source: " + ex.Source);
_sb.AppendLine("TargetSite: " + ex.TargetSite.Name);
_sb.AppendLine("StackTrace: " + ex.StackTrace);
_sb.AppendLine();
_sb.AppendLine("Additional Data");
if (additionalData != null)
{
foreach (string key in additionalData.Keys)
{
_sb.AppendLine(key + ": " + additionalData[key]);
}
}
return _sb.ToString();
}
}
Observe in the code, which in addition to removing the SOAP 1.2 references, also we removed the Net.TCP endpoint to not duplicate the operations in Lombardi.
The above implementation must be compiled on .NET Framework 2.0 to be registered at the GAC and used in IIS.
Configuring IIS:
1 - Register your assembly in GAC (Global Assembly Cache), move the DLL to into the folder (C:\Windows\Assembly) or use GACUTIL tool.
2 - On IIS Console, open the Handler Mappings Settings
3 -
On the upper right, select the "Add Managed Handler" action
4 - Into "Edit Managed Handler" window, make the following settings:
Type "*.wsdlt" into request path box, this is the extensions that your handler will intecept. Choose your assembly on Type dropdown box, it will apear after it put into the GAC.
Click on "Request Restrictions" button and make the above settings.
5 - Restart the IIS.
It's Done!
Now, you must change the call for your service in Lombardi, making pass to the Handler, eg:
Original Request: http://localhost/Services/Customer.svc?wsdl
New Request: http://localhost/Services/Customer.wsdlt
