by community-syndication | May 3, 2010 | BizTalk Community Blogs via Syndication
Microsoft is holding a virtual launch event on May 20th related to many connected systems technologies including AppFabric (on-premise and cloud) and BizTalk Server. If you are interested in hearing more about these technologies and how Microsoft feels the on-premise solutions align with the cloud, you should check out this event. Follow the link for details, calendar link, etc.
Application Infrastructure: Cloud Benefits Delivered
http://www.appinfrastructure.com
Want to bring the benefits of the cloud to your current IT environment? Cloud computing offers a range of benefits, including elastic scale and never-before-seen applications. While you ponder your long-term investment in the cloud, you can harness a number of cloud benefits in your current IT environment now.
Join us on May 20 at 8:30 A.M. Pacific Time to learn how your current IT assets can harness some of the benefits of the cloud on-premises-and can readily connect to new applications and data running in the cloud. As part of the Virtual Launch Event, Gartner vice president and distinguished analyst Yefim Natis will discuss the latest trends and biggest questions facing the Application Infrastructure space. He will also speak about the role Application Infrastructure will play in helping businesses benefit from the cloud. Plus, you’ll hear some exciting product announcements and a keynote from Abhay Parasnis, GM of Application Server Group at Microsoft. Parasnis will discuss the latest Microsoft investments in the Application Infrastructure space aimed at delivering on-demand scalability, highly available applications, a new level of connectivity, and more. Save the date!
by community-syndication | May 3, 2010 | BizTalk Community Blogs via Syndication
Troubleshooting applications in production is always a challenge. With AppFabric monitoring your workflows and services, you get great information about exactly what is happening, including notices about unhandled exceptions. In this episode, Michael McKeown will show you more about how you can use these features to troubleshoot problems with your applications.
Be sure to check out the AppFabric Wiki for more great tips, and to share yours as well.
by community-syndication | May 3, 2010 | BizTalk Community Blogs via Syndication
There are quite a a few cases where it is useful to have a duplex communications. An obvious candidate is allowing a service to notify the user interface application of the progress so the user knows what is happening. Normally, when using plain WCF, you would use a ServiceContract attribute with a CallbackContract that specified the service uses duplex communications. For example something like the following code on the server:
[ServiceContract(CallbackContract = typeof(IService1Callback))]
public interface IService1
{
[OperationContract]
string GetData(int value);
}
[ServiceContract]
public interface IService1Callback
{
[OperationContract]
void Reply(string message);
}
along with a client like this:
class Program
{
static void Main(string[] args)
{
var callback = new Service1Callback();
var proxy = new Service1Client(new InstanceContext(callback));
Console.WriteLine(proxy.GetData(42));
Console.ReadLine();
}
}
class Service1Callback : IService1Callback
{
public void Reply(string message)
{
Console.WriteLine(message);
}
}
But with a workflow service this doesn’t work because, without the ServiceContract attribute, there is no way to specify the CallbackContract. Yet workflows support duplex communications. So if we can’t use a CallbackContract how can we do so?
Workflow Services and Durable Duplex
Instead of the normal WCF duplex services workflow services use a mechanism that is called durable duplex. This is a more disconnected way of doing duplex communications that has a big advantage in that both communications work independently of each other. And that means the usual drawbacks of duplex communications don’t apply here. We can even use a completely different binding on the callback than on the original request. There is however a downside as the client has to create its own ServiceHost and act as a complete WCF service, a little more involved than a normal duplex request. Also settings a workflow, and the client, up for durable duplex takes a bit more configuring. So lets take a look how to do so.
Creating the Workflow Service
First step is to create the workflow service. This starts just like any other WCF Workflow Service Application. The durable duplex mechanism requires a context binding so the first change to the project is to use the wsHttpContextBinding. An easy change using the WCF protocolMapping:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<protocolMapping>
<add scheme="http" binding="wsHttpContextBinding" />
</protocolMapping>
<!-- Remainder deleted -->
</system.serviceModel>
</configuration>
Next step is adding a client console application and making sure we can call the workflow service. Add a console application, add a service reference to the workflow service and add the following code to the Main() function:
static void Main(string[] args)
{
var proxy = new ServiceClient();
Console.WriteLine(proxy.GetData(42));
Console.ReadLine();
}
No big deal so far. Now lets add the duplex part.
First of all we need to add a ServiceHost to the client exposing a callback contract and a callback service definition for the workflow service to call back to. Unlike a normal duplex service, where you define the contract on the service, we need to define this contract on the client using the following definition:
[ServiceContract]
interface IServiceCallback
{
[OperationContract(IsOneWay = true)]
void Update(string message);
}
[ServiceBehavior(InstanceContextMode= InstanceContextMode.Single)]
class ServiceCallback : IServiceCallback
{
public void Update(string message)
{
Console.WriteLine(message);
}
}
Next step is to update the Main() function to host this service:
static void Main(string[] args)
{
var address = "http://localhost:8080/ServiceCallback";
var serviceCallback = new ServiceCallback();
var host = new ServiceHost(serviceCallback, new Uri(address));
host.Open();
var proxy = new ServiceClient();
Console.WriteLine(proxy.GetData(42));
Console.ReadLine();
proxy.Close();
host.Close();
}
Note that this looks just like a service would when self hosting.
Next step is to get the workflow service to call back to the client. For this we need to do a could of things. First of all we need to let the workflow service know where to call back to. This is done by adding a CallbackContextMessageProperty with the callback address to the request header.
This can be done with an OperationContextScope by replacing the proxy.GetDate() call with the following code in the Main() function:
var proxy = new ServiceClient();
using (new OperationContextScope((IContextChannel)proxy.InnerChannel))
{
var context = new CallbackContextMessageProperty(address, new Dictionary<string, string>());
OperationContext.Current.OutgoingMessageProperties.Add(CallbackContextMessageProperty.Name, context);
Console.WriteLine(proxy.GetData(42));
}
Next we need to update the workflow itself.
The first thing we need to add is a CorrelationHandle variable to hold the callback correlation.
Next we need to initialize the callbackHandle using the CorrelationInitializer on the GetData Receive activity.
Next we need a Send activity to send the response to the client setting its CorrelatesWith to the same callbackHandle just initialized.
Finally we set the Send activity properties to match the client callback service as follows:
Note that we leave both the AddressUri and EndpointAddress empty, there is no config either, because this is provide through the request context and the callback correlation handle. We are also setting and set the binding to basicHttpBinding because that was what the client was using.
And finally we need to add a message to pass back like this:
So with all this complete we can run our client and service and have the service call back into the client.
A few things that might trip you up.
Forgetting to set the callback CorrelationHandle results in no messages being sent to the client. In fact an InvalidOperationException occurs with message "Endpoint with Name='<not specified>' and ServiceContract '<not specified>' has a null or empty Uri property. A Uri for this Endpoint must be provided.". This is caused by the Send activity not being able to find its callback address.
Not passing an empty context from the client. The CallbackContextMessageProperty has a few constructor overloads, one just taking a single EndpointAddress and no context parameter. Seems like a good choice as we don’t need to specify any context. Unfortunately this results in an ArgumentNullException with message "Value cannot be null. Parameter name: context". Again when the Send activity tries to find its callback address
How about Silverlight?
And the is of course the biggest problem of them all: what if you can’t create a ServiceHost on the client? In that case you are done for and there is no way to use this durable duplex mechanism. And I guess that rules Silverlight out as a possible client [:(]
Conclusion
All in all this works but it is kind of hard to setup the first time because of all the intricacies with the CallbackContextMessageProperty and the callback correlation handle.
Sample project DuplexDemo.zip
Enjoy
www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu
by community-syndication | May 3, 2010 | BizTalk Community Blogs via Syndication
WSCFblue v1 has been a really successful project and we’ve had some great discussions on the forums, feature requests (most of which we have been able to provide) and so on. For a long time the team has been thinking about the next generation of WSCF tooling, taking what we have now to the next […]
by community-syndication | May 2, 2010 | BizTalk Community Blogs via Syndication
Welcome to the 20th interview in my series of discussions with “connected technology” thought leaders. This month we have the distinct pleasure of harassing Aaron Skonnard who is a Microsoft MVP, blogger, co-founder of leading .NET training organization Pluralsight, MSDN magazine author and target of probably 12 other accolades that I’m not aware of. Q: […]
by community-syndication | May 2, 2010 | BizTalk Community Blogs via Syndication
In a BizTalk environment it is sometimes necessary to create a custom adapter to implement functionality that is not available with the out-of-the-box adapters. This article will handle a small part in the process of implementing your custom adapter, the deployment part. Also, this article only applies to adapters that use strong named assemblies. Using […]
by community-syndication | May 2, 2010 | BizTalk Community Blogs via Syndication
In a previous post I wrote about an AS2 problem that I encountered after renaming the BizTalk Groupname. In this post I digg into another AS2 problem, this time related to context properties. Lately I have been asked to reconfigure an AS2 configuration to send messages with a predefined filename. This is easily done by […]
