Attaching an ESB 2.0 Itinerary To WCF Message Header
Yesterday I was building a unit test to test an Http Adapter provider ( http://esbextlibrary.codeplex.com ) that we needed for communication with a Http based endpoint; and before you go down the road of why use HTTP Adapter vs the WCF Adapter and all its endless possibilities, the HTTP Legacy adapter didn’t have issues with badly formed messages like the WCF Adapter did.
When building the unit test, I wanted to use the ESB WCF Generic on ramps, and the WCF Adapter to send a message into the ESB. For those that don’t know this, there is a sample test client that comes with the ESB Samples. This test client contains code to embed an Itinerary and send this itinerary using a SOAP header. The sample also contains code to send to an ASMX web service, and a WCF service. In my opinion the samples are fairly cumbersome and awkward in regards to sending an itinerary into the ESB. Also, keep in mind that this test client was built for ESB 1.0, and ASMX focused doesn’t really take WCF and it’s power into account.
Thus the reasoning for this post…. I wanted to show that there are other ways accomplish this same goal, however using WCF, and the WCF InboundHeaders promoted property.
Let’s say I have an itinerary that looks as simple as this:
This itinerary uses a custom Http Adapter provider through the Resolve_Http_Endpoint resolver configuration to send in the message using the BizTalk HTTP Adapter.
To embed this itinerary into a WCF message, I’ll need to export this itinerary as XML and get the Itinerary content as such:
<Itinerary xmlns:xsi=\”http://www.w3.org/2001/XMLSchema-instance\” xmlns:xsd=\”http://www.w3.org/2001/XMLSchema\” uuid=\”\” beginTime=\”\” completeTime=\”\” state=\”Pending\” isRequestResponse=\”false\” servicecount=\”1\” name=\”HttpLegacyItinerary\” version=\”1.0\” xmlns=\”http://schemas.microsoft.biztalk.practices.esb.com/itinerary\”><BizTalkSegment interchangeId=\”\” epmRRCorrelationToken=\”\” receiveInstanceId=\”\” messageId=\”\” xmlns=\”\” /><ServiceInstance name=\”DTSTwoWaySyncResponse\” type=\”Messaging\” state=\”Pending\” position=\”0\” isRequestResponse=\”true\” xmlns=\”\” /><Services xmlns=\”\”><Service uuid=\”dde8337957054bb79fbdb8be148d5c02\” beginTime=\”\” completeTime=\”\” name=\”DTSTwoWaySyncResponse\” type=\”Messaging\” state=\”Pending\” isRequestResponse=\”true\” position=\”0\” serviceInstanceId=\”\” /></Services><ResolverGroups xmlns=\”\”><Resolvers serviceId=\”DTSTwoWaySyncResponse0\”><![CDATA[STATIC:\\transportType=HTTP;transportLocation=http_legacy://localhost/MyApp/default.aspx;action=;endpointConfig=RequestTimeout=30&ResponseStatusCode=200;jaxRpcResponse=false;messageExchangePattern=;targetNamespace=;transformType=;]]></Resolvers></ResolverGroups></Itinerary>
Now that I have the itinerary content, I can use one of the Generic WCF Onramps, or create my own, which is actually what I did. To create your own WCF Generic on ramp:
Create a BizTalk Receive Location inside the ESB BizTalk Application using the BizTalk Admin Console.
Configure the Receive Location to use a WCF-Custom adapter. I choose to use the netTCP Binding with all the default settings. The Uri for this adapter was set to: net.tcp://localhost:8888/ReceiveMsg/service.svc
Configure the Receive Location to use the ItineraryReceivePassthrough pipeline with all the defaults.
Create a Dynamic Send port that matches the filter expressions you created inside the Itinerary. Mine were set to
After I configured all the BizTalk receive and send ports, I needed the client code in my unit test project to invoke and send the test message to the WCF Generic on ramp, along with the attached itinerary as a Soap header (WCF Message Header).
To Configure a client with the message header I created a unit test with a method marked up with the [TestMethod] attribute and added the following code:
NetTcpBinding b = new NetTcpBinding ();
EndpointAddress epa = new EndpointAddress ( “net.tcp://localhost:8888/ReceiveMsg/service.svc” );
IBizTalkReceiveLocation proxy = ChannelFactory < IBizTalkReceiveLocation >.CreateChannel(b, epa);
Message msg = Message .CreateMessage( MessageVersion .Default, “SendToBizTalk” ,
new StringReader (
“<?xml version=\”1.0\” ?><TestMessage>Post To Http Adapter</TestMessage>” )));
Write_ItineraryTo_WCF_InboundHeaders( ref msg);
The Method of interest here is the “ Write_ItineraryTo_WCF_InboundHeaders(ref msg);” line of code.
This method is outlined here:
private void Write_ItineraryTo_WCF_InboundHeaders( ref Message wcfMessage)
// code taken from msdn: http://technet.microsoft.com/en-us/library/bb246105%28BTS.20%29.aspx
//const string PropertiesToPromoteKey = “http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/Promote”;
const string PropertiesToWriteKey = “http://schemas.microsoft.com/BizTalk/2006/01/Adapters/WCF-properties/WriteToContext” ;
//XmlQualifiedName propItinerary = new XmlQualifiedName(“Itinerary”, “http://schemas.microsoft.biztalk.practices.esb.com/itinerary”);
XmlQualifiedName writeItinerary = new XmlQualifiedName ( “Itinerary” , “http://schemas.microsoft.biztalk.practices.esb.com/itinerary” );
//Create a List of KeyValuePairs that indicate properties to be promoted to BizTalk message context.
//A Property Schema must be deployed and string values have a limit of 256 characters
//List<KeyValuePair<XmlQualifiedName, object>> promoteProps = new List<KeyValuePair<XmlQualifiedName, object>>();
//promoteProps.Add(new KeyValuePair<XmlQualifiedName, object>(propItinerary , HttpLegacyItinerary ));
//wcfMessage.Properties[PropertiesToPromoteKey] = promoteProps;
//Create a List of KeyValuePairs that indicate properties to be written to BizTalk message context
KeyValuePair < XmlQualifiedName , object > pair = new KeyValuePair < XmlQualifiedName , object >(writeItinerary,
List < KeyValuePair < XmlQualifiedName , object >> writeProps = new List < KeyValuePair < XmlQualifiedName , object >>();
XmlSerializer ser = new XmlSerializer ( typeof ( Itinerary ), “http://schemas.microsoft.biztalk.practices.esb.com/itinerary” );
//XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
Itinerary itin =
( Itinerary )ser.Deserialize( XmlDictionaryReader .Create( new StringReader (HttpLegacyItinerary)));
MessageHeader header = MessageHeader .CreateHeader( “Esb” , “” , itin, new myItinerary (itin, “i” , “http://schemas.microsoft.biztalk.practices.esb.com/itinerary” ));
// code for testing the Itinerary pipeline component…
//string str2 = header.ToString(); // .Replace(“\r\n”, “”);
//string pattern = “<[a-zA-Z0-9]:Itinerary.*?</[a-zA-Z0-9]:Itinerary>”;
//string str = Regex.Match(str2, pattern).Value;
//wcfMessage.Properties[PropertiesToWriteKey] = writeProps;
This method takes the itinerary content as a string, and deserializes it into an actual Itinerary class from the ESB Itinerary OM v1.0 assembly. This class then used to create a WCF Message header using the MessageHeader.Create static method call.
There’s one major note here to pay attention to…
The ESB Itinerary pipeline Component that is used with the ItineraryReceivePassthrough pipeline retrieves the Itinerary from a SOAP 1.x message header which is written (not distinguished/nor promoted) into the BizTalk Message context by either the SOAP adapter, or the WCF Adapter. When using the SOAP legacy adapter in BizTalk, SOAP headers are automatically written to the message context, again I must stress, that they are written, not promoted, nor distinguished. This means that the values are not available to orchestrations, nor routing capabilities by default. To get these values promoted, then you have to deploy a property schema with the correct SOAP target namespace. For WCF adapters, however, to get the headers promoted or written you must follow this msdn article:
The component uses a regular expression in order to find the itinerary inside the Soap Headers content. The Regular expression is: string pattern = “<[a-zA-Z0-9]:Itinerary.*?</[a-zA-Z0-9]:Itinerary>”;
What this regular expression tells us is that we must take care to add a prefix qualifier with exactly 1 character to the Itinerary Message Header, otherwise, your itinerary will not be found. Also make sure that you don’t use the “ a” prefix qualifier, as this is already take by WCF and SOAP specifics. Thus any other value will do fine.
Well in order to do this I had to use the overridden MessageHeader.Create() static method, which supports the use of a custom XmlObjectSerializer. This will allow me to control the serialization of the ESB Itinerary so that I may achieve this functionality. This is outlined in the following code:
private Itinerary itin = null ;
private XmlSerializerNamespaces ns = null ;
private XmlSerializer ser = null ;
public myItinerary( Itinerary itin, string prefix, string nameSpace)
this .itin = itin;
ns = new XmlSerializerNamespaces ();
ser = new XmlSerializer ( typeof ( Itinerary ), “http://schemas.microsoft.biztalk.practices.esb.com/itinerary” );
public override bool IsStartObject( XmlDictionaryReader reader)
return true ;
public override object ReadObject( XmlDictionaryReader reader, bool verifyObjectName)
public override void WriteEndObject( XmlDictionaryWriter writer)
public override void WriteObjectContent( XmlDictionaryWriter writer, object graph)
ser.Serialize(writer , this .itin, this .ns);
public override void WriteStartObject( XmlDictionaryWriter writer, object graph)
This custom XmlObjectSerializer class just uses the XmlSerializer behind the scenes, and a XmlSerializerNamespaces instance to add the prefix and namespace setting when serializing the Itinerary ESB OM v1.0 class back into the message stream with a single character prefix qualifier.
After all this was done, I was able to send the test message into the WCF Channel, with the attached WCF Message Header containing the ESB 2.0 strict Itinerary.