Untyped Messages and WCF Services in a real scenario

Context:

This project was my first big Biztalk experience. It started more than two years ago (is still in Biztalk 2006 R2) and most of the work was made based on pre-conceived ideas of what was good, what was easy, what was trustable.
The project kept on growing and at a certain point the desire to trash it all and restart was too strong. This is an example of how to slowly modify a monster-like orchestration. The images and names aren’t always the same because they are not from a case-study, they were all taken from a real project. It consisted of several orchestrations and this post was made when each one of them was in a different stage of transformation so that all situations are represented.

---

In this project we had to deal with a bunch of different XML files, different types, different schedules, and, worst of all, different actions on the destination server.



We could make this by using maps on the send port, but the tracking of the messages was critical so we needed to keep track of the message on every step of the journey. So, an orchestration was the choice.

To reunite everything, the receive port that collects them (from FTP, SAP idocs, etc.) is the entry of the orchestration. The Message schema in the orchestration is System.Xml.XmlDocument so all schemas are accepted with no distinction.
A Decide component help us creating the basic structure for it, with a lot of conditions of type

OriginalMessage(BTS.MessageType) == http://Company/Schemas/BusinessPartnerActivityTypes#ActivityTypes

and a two-way destination port prepared for send/receive schemas of type System.Xml.XmlDocument, we could make it by repeating a lot of components.

For each flow we make

1. Transform Xml (Received message) to original schema

FCBusinessPartnerActivityTypes = OriginalMessage;

2. Map original schema to service schema


3. Transform ServiceSchema to Xml (port schema)

XmlMessage = SMUVASActivityType;

4. Send to Service

5. Receive Response

6. And after some flows made the general picture would be something like

How to make it in a lighter way?

The first step is to remove the transformation.

1. Declare a string variable for the map, called mapName

1.1. Use an expression editor to select the map based on the message type

1.2. Use the Fully Qualified Name of the map

mapName="";
if(OriginalMessage(BTS.MessageType) == "http://Company/Schemas/OrderTypes#OrderTypes"){ mapName="Company.Biztalk.SmuasCommercialModule.Messaging.map_FCOrderTypes_to_SMUVASOrderTypes";
}
if(OriginalMessage(BTS.MessageType) == "http://Company/Schemas/OrderStatus#OrderStatus"){
mapName="Company.Biztalk.SmuasCommercialModule.Messaging.map_FCOrderStatus_to_SMUVASOrderStatus";
}
…

2. Then in a message assignment use the transform method.

mapSystemType = System.Type.GetType(mapName);
transform(XmlMessage) = mapSystemType(OriginalMessage);

3. The orchestration will be much simpler.

The next optimization is to remove the multiple actions.

At the if that defines the map, you can also define the action. Something like

if(OriginalMessage(BTS.MessageType) == "http://Company/Schemas/Banks#Banks"){
mapName="Company.Biztalk.SmuasFinancialModule.Messaging.map_FCBanks_to_SMUVASBanks"; action="http://SmuAs/Services/BackendServices/CommonBackendSyncService/ICommonBackendSyncService/SetBankList";
}

And when the request message is created, give it the correspondent action.

mapSystemType = System.Type.GetType(mapName);
transform(RequestMessage) = mapSystemType(OriginalMessage);
RequestMessage(WCF.Action)= action;

The look of the orchestration is much lighter and pleasant to work with.

Using Business Rules Engine (I)

Making business rules without messages

The most common way of using business rules is by evaluating a XML message with XPath and return an XML message with more info. The problem is that most of the examples are orchestration dependents: by demanding a compiled DLL with the schemas to be used, they limit the possibilities.
In a project with many orchestrations an easy solution is to make a solution with the schemas, compile, define the rules based on that DLL, and then apply them in the remaining solutions. If it is a small project where schema and orchestration could be on the same DLL, a first compilation is needed for BRE to access the schema. Only then the orchestration can add the rule.

But, what if the message is not important in any direction? What if you just want to use the same rule in all orchestrations without referring each and every DLL?
Scenario: ten distinct schemas. One flow in and one flow out for each. The same tracking rules apply on each direction, depending only on the schema. Here I found a great way of corrupting the principles of the rules.
I recommend this blog because it was the first were I could find any comprehensible info about BRE.

Basic: Policies have versions, on each version one or more rules. By activating different versions different rules can be in use. A rule is divided in condition and actions. A straight-forward "If-Then".



Usually each orchestration has its own rule and each rule is for an orchestration, a direct match.
The trick is to make a single rule, the if always true, and the orchestration will receive information that can be used or not.

The advantage of business rules engine is the low processing time and the changeable ease (copy version, edit, publish and deploy). There are no big processing advantages in using rules this way, but the changing method is still easy and no deployments required.

Making the if always true

Like always, just use the condition 1==1 or something that obvious.
On the actions list, we’ll use an ArrayList to return a list of words.

Go to facts explorer window

Select .NET classes

Right-click and browse .NET Assemblies

Select the mscorlib library

Press OK



The library will become available.



Find ArrayList and the Add() method, and drag it to actions pane as many time as you’ll need.
Fill in with the key strings and publish the version.



Add to the orchestration variables list one of type ArrayList.
Go to Orchestration View and right click Variables folder for New Variable
At new variable define name (in this example rulesArray) and type (<.NET Class…>, mscorlib, ArrayList)
Create another variable, of type Boolean called generateAck.
Add Call Rules component and use that variable as destination for the output.



And then at a Expression editor, search for the value and do as you please. In this example, only for the flows listed we’ll generate Ack. The fixed value is the message type that the orchestration mandatorily knows.



For instance we are searching for Purchase Orders, abbreviated PO. Since the rulesArray includes that value, ANY orchestration that has Purchase Orders will set generateAcks as true and therefore record Acks, if the proper code is made.

WCF service publishing wizard settings

Did you ever had to republish a web service over and over again? Is it fun to go through the wizard and add the methods one by one?

We were having that problem. The idea was to make a connection between SAP and Sharepoint through web services created by Biztalk. An RFC in SAP receives the request and returns the values to Sharepoint that will use them to create a page. To comunication was quick and stable, but I was losing my mind and time creating the services one by one. Let's see the process step by step with focus on Biztalk:

1. the new RFC is created in SAP (not my problem)
2. Biztalk imports reference with the SAP Adapter (easy)
3. build and deploy dll (too easy)

4. recreate service through Biztalk WCF Publishing Wizard
4.1 select Transport Type
4.2 enable Metadata endpoint
4.3 select Biztalk application
4.4 select "publish schemas"
4.5 rename Web Service
4.6 rename Web Method
4.7 define schema type for request and for response, enlarging both the columns to read the schema type
4.8 repeat 4.6 and 4.7 for every single RFC, old or new...
4.9 define namespace
4.10 define the same service location with overwrite
4.11 allowing anonymous access
4.12 press Create

5 update reference on client
6 do some new methods
7 test

The best way to reduce time on Biztalk is never to press the Finish button. Going back the settings are all there and you can deploy it again.

But there is a better way... I googled for this situation. On this blessed link I found the answers for all my problems. Well, at least for this one.
So, the deployment stores the configuration inside wwwroot. And more! It is understandable and can be edited!

I simply made a batch file to call the wizard with the parameter

cd C:\Program Files\Microsoft BizTalk Server 2006\
BtsWcfServicePublishingWizard -WcfServiceDescription=C:\Inetpub\wwwroot\BizTalkWcfService\App_Data\Temp\WcfServiceDescription.xml

and now my work is just with steps 4.3, 4.4, 4.6, 4.7, 4.9, 4.12. The annoying configuration of all old methods, and more than half the checkbox clicks are made for me.

Question: Shouldn't the wizard allow the loading of a xml file?

BizTalk Maintenance

Excellent article on Biztalk maintenance:

The BizTalk Ops Team - Maintaining a Healthy, Responsive and Available BizTalk Environment

Biztalk Performance tunning blog on MSDN

There is a useful blog about Biztalk performance tunning on MSDN:
Biztalk Performance