Andreas Erben's posts : Windows Communication Foundation

Cloud Proxy Demo / Simple BizTalk Workflow Services End-to-end demo

Andreas Erben — Thu, 02 Oct 2008 09:55:00 GMT

(German version may be written at a later time / Deutsche Version wird gegebenenfalls später geschrieben)

This post combines several concepts from several posts about BizTalk Workflow Services. You should read the intro, about flow control, about send&receive activities and about the little trick to hide some code in conditions. Additionally we will showcase binding of properties in BizTalk Workflow Services.

What shall be achieved?

We want a workflow instance to communicate with a service and be called back by the service. Then the workflow should do something and wait for the client to fetch the result of the work done.

Some challenges:

How to get the WorkflowInstanceId to the service?
How to get information back to the workflow?
How to pass the information from one activity in the workflow to another activity?
How to get the information back to the service?

Challenge 1: How to get the WorkflowInstanceId to the service?

There is currently no out-of-the-box way to access the WorkflowInstanceId and there is no "setter" activity to store a value somewhere. To do this, we will use the technique described in here, where we hide code in conditions to send information via the CloudServiceBusSend activity to the service.

We will use the following condition for that.

System.Convert.ToBoolean(((System.ServiceBus.Workflow.CloudServiceBusSend) this.GetActivityByName("cloudServiceBusSend1") ).GetType().GetProperty("Body").SetValue(this.GetActivityByName("cloudServiceBusSend1"), "<Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'><text></text> </Echo>".Insert(69, this.WorkflowInstanceId.ToString()), null)) || True

Note that this condition results in an Xml-string that is longer than 8192 characters. You will have to strip whitespace from that Xml-string to be able to upload it to BizTalk Workflow Services.

Challenge 2: How to get information back to the workflow?

Fortunately we received the InstanceId, now we need to tell the workflow that we want it to do something for us. Unfortunately CloudServiceBusSend so far does not work with returned values. So: The only way to call the workflow is through the CloudHttpReceive activity and we need the InstanceId to call the proper instance. Using the CloudHttpReceive was demonstrated here.

Challenge 3: How to pass the information from one activity in the workflow to another activity?

As mentioned, we have no activities for getting/setting or manipulating data. We could either employ the previously mentioned trick to hide some code in conditions or we can use property binding. We will do the latter.

We bind the request property of a CloudHttpReceive activity to the URL property of a CloudHttpSend activity. So, the URL of the CloudHttpSend will be "filled" by the incoming WebHttpRequest and when CloudHttpSend gets executed it will request data from the URL that was supplied externally.

Activity=cloudHttpSend1, Path=URL

The complete activity with activity binding would look like this:

<ns0:CloudHttpReceive Request="{ActivityBind cloudHttpSend1,Path=URL}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />

Challenge 4: How to get the information back to the service?

To solve that challenge we can either use a CloudServiceBusSend or we can have the service asking the workflow via a CloudHttpReceive activity. We will use CloudHttpReceive in this case because we want the service to "control" when it asks for the result.

The workflow

Now let us look at the complete workflow first

and as Xoml definition:

<SequentialWorkflowActivity x:Class="WorkflowProject1.Workflow1" x:Name="Workflow1" xmlns:ns0="http://schemas.microsoft.com/2007/11/CloudWorkflowActivityLibrary" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <ns0:CloudWhile x:Name="cloudWhile1">
    <ns0:CloudWhile.Condition>
      <RuleConditionReference ConditionName="While Condition" />
    </ns0:CloudWhile.Condition>
    <ns0:CloudSequence x:Name="cloudSequence1">
      <ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/YOURUSERNAMEHERE/EchoService/" Response="" Body="&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Echo&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo" ConnectionMode="RelayedDuplexSession" />
      <ns0:CloudHttpReceive Request="{ActivityBind cloudHttpSend1,Path=URL}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />
      <ns0:CloudHttpSend x:Name="cloudHttpSend1" StatusCode="0" URL="http://www.microsoft.com" Method="GET" Request="{x:Null}" RequestContentType="{x:Null}" Response="{ActivityBind cloudHttpReceive2,Path=Response}" />
      <ns0:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive2" StatusCode="0" Response="Bye" />
      <ns0:CloudDelay x:Name="cloudDelay1" Timeout="00:00:10" />
    </ns0:CloudSequence>
  </ns0:CloudWhile>
</SequentialWorkflowActivity>

Let's look at the activities from top to bottom.

There is not really anything to say about cloudSequence1.

The cloudWhile1 activity has the condition set as seen in Challenge 1.

The condition is represented by this Xml structure:

<RuleDefinitions xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <RuleDefinitions.Conditions>
    <RuleExpressionCondition Name="While Condition">
      <RuleExpressionCondition.Expression>
        <ns0:CodeBinaryOperatorExpression Operator="BooleanOr" xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
          <ns0:CodeBinaryOperatorExpression.Left>
            <ns0:CodeMethodInvokeExpression>
              <ns0:CodeMethodInvokeExpression.Parameters>
                <ns0:CodeMethodInvokeExpression>
                  <ns0:CodeMethodInvokeExpression.Parameters>
                    <ns0:CodeMethodInvokeExpression>
                      <ns0:CodeMethodInvokeExpression.Parameters>
                        <ns0:CodePrimitiveExpression>
                          <ns0:CodePrimitiveExpression.Value>
                            <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String>
                          </ns0:CodePrimitiveExpression.Value>
                        </ns0:CodePrimitiveExpression>
                      </ns0:CodeMethodInvokeExpression.Parameters>
                      <ns0:CodeMethodInvokeExpression.Method>
                        <ns0:CodeMethodReferenceExpression MethodName="GetActivityByName">
                          <ns0:CodeMethodReferenceExpression.TargetObject>
                            <ns0:CodeThisReferenceExpression />
                          </ns0:CodeMethodReferenceExpression.TargetObject>
                        </ns0:CodeMethodReferenceExpression>
                      </ns0:CodeMethodInvokeExpression.Method>
                    </ns0:CodeMethodInvokeExpression>
                    <ns0:CodeMethodInvokeExpression>
                      <ns0:CodeMethodInvokeExpression.Parameters>
                        <ns0:CodePrimitiveExpression>
                          <ns0:CodePrimitiveExpression.Value>
                            <ns1:Int32 xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">69</ns1:Int32>
                          </ns0:CodePrimitiveExpression.Value>
                        </ns0:CodePrimitiveExpression>
                        <ns0:CodeMethodInvokeExpression>
                          <ns0:CodeMethodInvokeExpression.Method>
                            <ns0:CodeMethodReferenceExpression MethodName="ToString">
                              <ns0:CodeMethodReferenceExpression.TargetObject>
                                <ns0:CodePropertyReferenceExpression PropertyName="WorkflowInstanceId">
                                  <ns0:CodePropertyReferenceExpression.TargetObject>
                                    <ns0:CodeThisReferenceExpression />
                                  </ns0:CodePropertyReferenceExpression.TargetObject>
                                </ns0:CodePropertyReferenceExpression>
                              </ns0:CodeMethodReferenceExpression.TargetObject>
                            </ns0:CodeMethodReferenceExpression>
                          </ns0:CodeMethodInvokeExpression.Method>
                        </ns0:CodeMethodInvokeExpression>
                      </ns0:CodeMethodInvokeExpression.Parameters>
                      <ns0:CodeMethodInvokeExpression.Method>
                        <ns0:CodeMethodReferenceExpression MethodName="Insert">
                          <ns0:CodeMethodReferenceExpression.TargetObject>
                            <ns0:CodePrimitiveExpression>
                              <ns0:CodePrimitiveExpression.Value>
                                <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt;&lt;text&gt;&lt;/text&gt; &lt;/Echo&gt;</ns1:String>
                              </ns0:CodePrimitiveExpression.Value>
                            </ns0:CodePrimitiveExpression>
                          </ns0:CodeMethodReferenceExpression.TargetObject>
                        </ns0:CodeMethodReferenceExpression>
                      </ns0:CodeMethodInvokeExpression.Method>
                    </ns0:CodeMethodInvokeExpression>
                    <ns0:CodePrimitiveExpression />
                  </ns0:CodeMethodInvokeExpression.Parameters>
                  <ns0:CodeMethodInvokeExpression.Method>
                    <ns0:CodeMethodReferenceExpression MethodName="SetValue">
                      <ns0:CodeMethodReferenceExpression.TargetObject>
                        <ns0:CodeMethodInvokeExpression>
                          <ns0:CodeMethodInvokeExpression.Parameters>
                            <ns0:CodePrimitiveExpression>
                              <ns0:CodePrimitiveExpression.Value>
                                <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">Body</ns1:String>
                              </ns0:CodePrimitiveExpression.Value>
                            </ns0:CodePrimitiveExpression>
                          </ns0:CodeMethodInvokeExpression.Parameters>
                          <ns0:CodeMethodInvokeExpression.Method>
                            <ns0:CodeMethodReferenceExpression MethodName="GetProperty">
                              <ns0:CodeMethodReferenceExpression.TargetObject>
                                <ns0:CodeMethodInvokeExpression>
                                  <ns0:CodeMethodInvokeExpression.Method>
                                    <ns0:CodeMethodReferenceExpression MethodName="GetType">
                                      <ns0:CodeMethodReferenceExpression.TargetObject>
                                        <ns0:CodeCastExpression TargetType="System.ServiceBus.Workflow.CloudServiceBusSend, System.ServiceBus.Workflow, Version=0.12.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
                                          <ns0:CodeCastExpression.Expression>
                                            <ns0:CodeMethodInvokeExpression>
                                              <ns0:CodeMethodInvokeExpression.Parameters>
                                                <ns0:CodePrimitiveExpression>
                                                  <ns0:CodePrimitiveExpression.Value>
                                                    <ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String>
                                                  </ns0:CodePrimitiveExpression.Value>
                                                </ns0:CodePrimitiveExpression>
                                              </ns0:CodeMethodInvokeExpression.Parameters>
                                              <ns0:CodeMethodInvokeExpression.Method>
                                                <ns0:CodeMethodReferenceExpression MethodName="GetActivityByName">
                                                  <ns0:CodeMethodReferenceExpression.TargetObject>
                                                    <ns0:CodeThisReferenceExpression />
                                                  </ns0:CodeMethodReferenceExpression.TargetObject>
                                                </ns0:CodeMethodReferenceExpression>
                                              </ns0:CodeMethodInvokeExpression.Method>
                                            </ns0:CodeMethodInvokeExpression>
                                          </ns0:CodeCastExpression.Expression>
                                        </ns0:CodeCastExpression>
                                      </ns0:CodeMethodReferenceExpression.TargetObject>
                                    </ns0:CodeMethodReferenceExpression>
                                  </ns0:CodeMethodInvokeExpression.Method>
                                </ns0:CodeMethodInvokeExpression>
                              </ns0:CodeMethodReferenceExpression.TargetObject>
                            </ns0:CodeMethodReferenceExpression>
                          </ns0:CodeMethodInvokeExpression.Method>
                        </ns0:CodeMethodInvokeExpression>
                      </ns0:CodeMethodReferenceExpression.TargetObject>
                    </ns0:CodeMethodReferenceExpression>
                  </ns0:CodeMethodInvokeExpression.Method>
                </ns0:CodeMethodInvokeExpression>
              </ns0:CodeMethodInvokeExpression.Parameters>
              <ns0:CodeMethodInvokeExpression.Method>
                <ns0:CodeMethodReferenceExpression MethodName="ToBoolean">
                  <ns0:CodeMethodReferenceExpression.TargetObject>
                    <ns0:CodeTypeReferenceExpression Type="System.Convert, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
                  </ns0:CodeMethodReferenceExpression.TargetObject>
                </ns0:CodeMethodReferenceExpression>
              </ns0:CodeMethodInvokeExpression.Method>
            </ns0:CodeMethodInvokeExpression>
          </ns0:CodeBinaryOperatorExpression.Left>
          <ns0:CodeBinaryOperatorExpression.Right>
            <ns0:CodePrimitiveExpression>
              <ns0:CodePrimitiveExpression.Value>
                <ns1:Boolean xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">true</ns1:Boolean>
              </ns0:CodePrimitiveExpression.Value>
            </ns0:CodePrimitiveExpression>
          </ns0:CodeBinaryOperatorExpression.Right>
        </ns0:CodeBinaryOperatorExpression>
      </RuleExpressionCondition.Expression>
    </RuleExpressionCondition>
  </RuleDefinitions.Conditions>
</RuleDefinitions>

For "copy/paste" purposes, here is the whitespace-stripped Xml-representation:

<RuleDefinitions xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow"><RuleDefinitions.Conditions><RuleExpressionCondition Name="While Condition"><RuleExpressionCondition.Expression><ns0:CodeBinaryOperatorExpression Operator="BooleanOr" xmlns:ns0="clr-namespace:System.CodeDom;Assembly=System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"><ns0:CodeBinaryOperatorExpression.Left><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="GetActivityByName"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeThisReferenceExpression /></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:Int32 xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">69</ns1:Int32></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="ToString"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodePropertyReferenceExpression PropertyName="WorkflowInstanceId"><ns0:CodePropertyReferenceExpression.TargetObject><ns0:CodeThisReferenceExpression /></ns0:CodePropertyReferenceExpression.TargetObject></ns0:CodePropertyReferenceExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="Insert"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt;&lt;text&gt;&lt;/text&gt; &lt;/Echo&gt;</ns1:String></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression><ns0:CodePrimitiveExpression /></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="SetValue"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">Body</ns1:String></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="GetProperty"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="GetType"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeCastExpression TargetType="System.ServiceBus.Workflow.CloudServiceBusSend, System.ServiceBus.Workflow, Version=0.12.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"><ns0:CodeCastExpression.Expression><ns0:CodeMethodInvokeExpression><ns0:CodeMethodInvokeExpression.Parameters><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:String xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">cloudServiceBusSend1</ns1:String></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="GetActivityByName"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeThisReferenceExpression /></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeCastExpression.Expression></ns0:CodeCastExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeMethodInvokeExpression.Parameters><ns0:CodeMethodInvokeExpression.Method><ns0:CodeMethodReferenceExpression MethodName="ToBoolean"><ns0:CodeMethodReferenceExpression.TargetObject><ns0:CodeTypeReferenceExpression Type="System.Convert, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /></ns0:CodeMethodReferenceExpression.TargetObject></ns0:CodeMethodReferenceExpression></ns0:CodeMethodInvokeExpression.Method></ns0:CodeMethodInvokeExpression></ns0:CodeBinaryOperatorExpression.Left><ns0:CodeBinaryOperatorExpression.Right><ns0:CodePrimitiveExpression><ns0:CodePrimitiveExpression.Value><ns1:Boolean xmlns:ns1="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">true</ns1:Boolean></ns0:CodePrimitiveExpression.Value></ns0:CodePrimitiveExpression></ns0:CodeBinaryOperatorExpression.Right></ns0:CodeBinaryOperatorExpression></RuleExpressionCondition.Expression></RuleExpressionCondition></RuleDefinitions.Conditions></RuleDefinitions>

cloudServiceBusSend1 is configured like this with the "Body" property actually at execution time being overwritten by the condition of cloudWhile1.

cloudHttpReceive1 will get data in the "Request" property and put it into the "URL" property of cloudHttpSend1.

cloudHttpSend1 will find it's URL property overwritten by the data received at cloudHttpReceive1. Then it will execute the WebHttpRequest and put the body of the result in the "Response" property of cloudHttpReceive2.

cloudHttpReceive2 looks very empty. The "Response" property however will be overwritten by the data bound in cloudHttpSend1.

cloudDelay1 is configured to wait 10 seconds.

Create this workflow by copy/pasting the Xoml and rules and setting the type name to "SimpleEnd2End".

The service

Now you need to set up the service. To do that work on a copy of Program Files\Microsoft BizTalk Services SDK\Samples\Communication\GettingStarted\Echo.

You will need to modify the file "EchoService.cs".

Modify the "using" statements like this:

using System;
using System.ServiceModel;
using System.Threading;
using System.Net;
using System.IO;
using System.Text;

Copy the methods "CallHttpReceiveActivityWithLogin", "GetTokenGrantingToken" and "CallHttpReceiveActivity" from the code snippet at the bottom of send&receive activities to the class "EchoService".

Modify the "Echo"-method like this:

public string Echo(string text)
{
    Console.WriteLine(text + ":InstanceId received");
    Threading.ThreadStart starter = delegate { HttpCall(text); };
    new Threading.Thread(starter).Start();
    return "nothing to return really";        
}

You see that a new thread will be started with a delegate to HttpCall(text). This is because the service shall continue processing after returning from the "Echo"-method

Add a method "HttpCall" like this:

private void HttpCall(string instanceId)
{
    Console.WriteLine(instanceId+":Thread started");
    string username = "YOURUSERNAME";
    string password = "YOURPASSWORD";
    string workflowTypeName = "SimpleEnd2End";
    string activityName1 = "cloudHttpReceive1";
    string activityName2 = "cloudHttpReceive2";
    string dummyString = "does not matter";
    string urlToGet = "http://www.daenet.eu";
    //wait a bit before the first call
    Thread.Sleep(1000);
    Console.WriteLine(instanceId + ":request "+urlToGet);
    string result1 = CallHttpReceiveActivityWithLogin(
                                urlToGet, username, password,
                                workflowTypeName, activityName1,
                                instanceId);
    //wait a bit before the second call to allow loading of URL
    Thread.Sleep(5000);
    Console.WriteLine(instanceId + ":retrieve data for "
                      + urlToGet);
    string result2 = CallHttpReceiveActivityWithLogin(
                                dummyString, username, password,
                                workflowTypeName, activityName2,
                                instanceId);
    Console.WriteLine(instanceId + ":WebHttpResponse length "
                      + result2.Length);
    Console.WriteLine(instanceId + ":Thread exits");
}

After some initialization this method waits for 1 second and then does a WebHttpRequest to the activity cloudHttpReceive1, sending "http://www.daenet.eu" in the body of the request (which will then overwrite "http://www.microsoft.com" in the cloudHttpSend1 activity). At the same time the workflow in the cloud should continue and retrieve the wanted data. Then it waits another 5 seconds and executes another WebHttpRequest, but this time to the activity cloudHttpReceive2, where it will retrieve the result of what the workflow hopefully loaded meanwhile from the passed URL. Some output is printed to the console and the method and thread exits.
Please note that the workflow itself however will loop endlessly and likely block at some point since it may reach a CloudHttpReceive when there is nobody to send anymore.

For your convenience, the complete code of the modified file "EchoService.cs":

//---------------------------------------------------------------------------------
// Microsoft (R) BizTalk Services
// Software Development Kit
// 
// Copyright (c) Microsoft Corporation. All rights reserved.  
// Copyright (c) of modifications: Andreas Erben
// THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, 
// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES 
// OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. 
//---------------------------------------------------------------------------------
 
namespace System.ServiceBus.Samples
{
    using System;
    using System.ServiceModel;
    using System.Threading;
    using System.Net;
    using System.IO;
    using System.Text;
 
 
    [ServiceBehavior(Name = "EchoService",
        Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
    class EchoService : EchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine(text + ":InstanceId received");
            Threading.ThreadStart starter = delegate { HttpCall(text); };
            new Threading.Thread(starter).Start();
            return "nothing to return really";        
        }
 
        private void HttpCall(string instanceId)
        {
            Console.WriteLine(instanceId+":Thread started");
            string username = "YOURUSERNAME";
            string password = "YOURPASSWORD";
            string workflowTypeName = "SimpleEnd2End";
            string activityName1 = "cloudHttpReceive1";
            string activityName2 = "cloudHttpReceive2";
            string dummyString = "does not matter";
            string urlToGet = "http://www.daenet.eu";
            //wait a bit before the first call
            Thread.Sleep(1000);
            Console.WriteLine(instanceId + ":request "+urlToGet);
            string result1 = CallHttpReceiveActivityWithLogin(
                                        urlToGet, username, password,
                                        workflowTypeName, activityName1,
                                        instanceId);
            //wait a bit before the second call to allow loading of URL
            Thread.Sleep(5000);
            Console.WriteLine(instanceId + ":retrieve data for "
                              + urlToGet);
            string result2 = CallHttpReceiveActivityWithLogin(
                                        dummyString, username, password,
                                        workflowTypeName, activityName2,
                                        instanceId);
            Console.WriteLine(instanceId + ":WebHttpResponse length "
                              + result2.Length);
            Console.WriteLine(instanceId + ":Thread exits");
        }
 
        static string CallHttpReceiveActivityWithLogin(
                    string requestBody, string username, string password,
                    string workflowTypeName, string activityName,
                    string instanceId)
        {
            string token = GetTokenGrantingToken(username, password);
            return CallHttpReceiveActivity(
                                    requestBody, username, token,
                                    workflowTypeName, activityName,
                                    instanceId);
        }
 
        static string GetTokenGrantingToken(string userName, string password)
        {
            string tokenUrl = string.Format(
                "https://{0}/issuetoken.aspx?u={1}&p={2}",
                "identity.biztalk.net",
                userName,
                password);
 
            HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
            HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
            using (Stream responseStream = tokenResponse.GetResponseStream())
            {
                byte[] tokenBody = new byte[500];
                int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
                return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
            }
        }
 
        static string CallHttpReceiveActivity(
                            string requestBody, string username, string token,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
            Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                        + username + "/workflows/" + workflowTypeName +
                        "/instances/" + instanceId + "/" + activityName);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
            //this adds the retrieved token as a header
            request.Headers.Add("X-MS-Identity-Token", token);
            request.Method = "POST";
            request.ContentType = "text/plain";
            //send the body
            byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
            request.ContentLength = requestBodyBytes.Length;
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
                requestStream.Flush();
            }
 
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            using (Stream responseStream = response.GetResponseStream())
            {
 
                using (StreamReader reader = new StreamReader(responseStream,
                                                              Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

Running the sample

Start the modifed "Echo"-sample that will start-up its self-hosted ServiceBus endpoint.
Create 1 or more instances of the type SimpleEnd2End.
Start the instances of SimpleEnd2End.
Watch the output in the console of the modified "Echo"-sample until you are happy and press enter.

The output for 1 workflow instance:

d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:InstanceId received
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread started
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:request http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:retrieve data for http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:WebHttpResponse length 28427
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread exits
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:InstanceId received
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread started
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:request http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:retrieve data for http://www.daenet.eu
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:WebHttpResponse length 28427
d81d8ba2-3137-4a6d-aafe-c6c8c5eea1a8:Thread exits

The output for 2 concurrent workflow instances:

a7874223-e9d1-430c-b0f9-d36baf6d1076:InstanceId received
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread started
a7874223-e9d1-430c-b0f9-d36baf6d1076:request http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:InstanceId received
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread started
befa13cf-4b4c-4118-82dc-4a94ef288952:request http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:retrieve data for http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:retrieve data for http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:WebHttpResponse length 28427
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread exits
befa13cf-4b4c-4118-82dc-4a94ef288952:WebHttpResponse length 28427
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread exits
a7874223-e9d1-430c-b0f9-d36baf6d1076:InstanceId received
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread started
a7874223-e9d1-430c-b0f9-d36baf6d1076:request http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:InstanceId received
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread started
befa13cf-4b4c-4118-82dc-4a94ef288952:request http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:retrieve data for http://www.daenet.eu
befa13cf-4b4c-4118-82dc-4a94ef288952:retrieve data for http://www.daenet.eu
a7874223-e9d1-430c-b0f9-d36baf6d1076:WebHttpResponse length 28427
a7874223-e9d1-430c-b0f9-d36baf6d1076:Thread exits
befa13cf-4b4c-4118-82dc-4a94ef288952:WebHttpResponse length 28427
befa13cf-4b4c-4118-82dc-4a94ef288952:Thread exits

This is part of the actual retrieved data to be found in result2 when breaking after the second call to the workflow:

Note that it will, as seen in the previous blog-post be wrapped in the XML representation of a string object containing the retrieved data. To get the actual data, you would need to parse that XML structure (even though it is a simple parse).

This is all for now, I hope it made BizTalk Workflow Services more "accessible".

Finally some advertisment: If you want to talk to us/me about BizTalk Workflow Services or other exciting technologies or approaches then contact us/me. "face 2 face" logistics are most easy in the US or Europe.

Cloudy messages / Send & Receive Activities in BizTalk Workflow Services

Andreas Erben — Thu, 02 Oct 2008 03:14:00 GMT

(German version may be provided at a later stage / Deutsche Version wird gegebenenfalls nachgereicht)

In previous posts, I gave an introduction to BizTalk Workflow Services, I wrote about flow control and rambled about tricks you can do in conditions.

This post will deal with the send and receive activities available now.

BizTalk Workflow Services offer the following send and receive activities:

CloudHttpReceive
CloudHttpSend
CloudServiceBusSend

CloudServiceBusSend

CloudServiceBusSend was already used in the introduction post, so I will start with this.

CloudServiceBusSend with ConnectionMode RelayedMultiCast

Please look at the provided sample typically at Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted and find the activity "cloudServiceBusSend1".

The activity corresponds to the following Xoml-fragment:

<ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/ChatRooms/watchdog/MulticastService/" Response="{x:Null}" Body="&lt;Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;nickName&gt;watchdog&lt;/nickName&gt; &lt;text&gt;The Microsoft site is responding.&lt;/text&gt;&lt;/Chat&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat" ConnectionMode="RelayedMulticast" />

Select cloudServiceBusSend1 and look at the properties:

ConnectionMode

There are two implemented ConnectionModes: "RelayedMultiCast" and "RelayedDuplexSession".
RelayedMultiCast requires a contract that only contains OneWay operations. "RelayedDuplexSession" in contrast will theoretically allow a response, but there seems to be a bug in the present version and the response will get lost. The posted example uses the "RelayedMultiCast" ConnectionMode. It interacts with the sample Program Files\Microsoft BizTalk Services SDK\Samples\Communication\ExploringFeatures\ConnectionModes\Multicast.

URL

sb://connect.biztalk.net/services/ChatRooms/watchdog/MulticastService/

This is the URL of the ServiceBus address you are trying to reach. A WorkflowValidator will not only check it for being not empty but also use the scheme "sb".

Action

http://samples.microsoft.com/ServiceModel/Relay/MulticastContract/Chat

Nothing really surprising. It is best understood though when looking at the contract of the corresponding sample

[ServiceContract(Name = "MulticastContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface MulticastContract
{
    [OperationContract(IsOneWay=true)]
    void Hello(string nickName);
 
    [OperationContract(IsOneWay = true)]
    void Chat(string nickName, string text);
 
    [OperationContract(IsOneWay = true)]
    void Bye(string nickName);
}

So, it is basically Namespace+Name+Operation.

Body

<Chat xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <nickName>watchdog</nickName> <text>The Microsoft site is responding.</text></Chat>

What is actually being sent. A WorkflowValidator will check if it is valid XML.
In this example you see the outer element being named "Chat" like the operation that is going to be called on the interface with the namespace "http://samples.microsoft.com/ServiceModel/Relay/" of the ServiceContract. Then there are two string parameters, each represented by an XML-Tag corresponding to the parameter names of the operation: "nickName" with its value "watchdog" and "text" with its value "The Microsoft site is responding.".

Response

The response is empty, with RelayedMultiCast it will always stay empty even after the call (since it only involves OneWay operations) and unfortunately in the present CTP drop I found it impossible so far to be filled.

CloudServiceBusSend with ConnectionMode RelayedDuplexSession

Let's look at a slightly different configuration for this activity

<ns0:CloudServiceBusSend x:Name="cloudServiceBusSend1" URL="sb://connect.biztalk.net/services/andreaserben/EchoService/" Response="" Body="&lt;Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'&gt; &lt;text&gt;Original&lt;/text&gt;&lt;/Echo&gt;" Action="http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo" ConnectionMode="RelayedDuplexSession" />

with the properties being like

ConnectionMode

As mentioned "RelayedDuplexSession" will theoretically allow a response, but there seems to be a bug in the present version and the response will get lost. This example interacts with the sample Program Files\Microsoft BizTalk Services SDK\Samples\Communication\GettingStarted\Echo.

URL

sb://connect.biztalk.net/services/YOURWORKFLOWSERVICESUSERNAME/EchoService/

This is the URL of the ServiceBus address you are trying to reach in this case contains your username because this is how the "Echo" sample sets up its endpoint.

Action

http://samples.microsoft.com/ServiceModel/Relay/EchoContract/Echo

Again nothing really surprising. It is best understood though when looking at the contract of the corresponding sample

[ServiceContract(Name = "EchoContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface EchoContract
{
    [OperationContract]
    string Echo(string text);
}
 

Again it is Namespace+Name+Operation. (Note that this is not a one-way operation now.)

Body

<Echo xmlns='http://samples.microsoft.com/ServiceModel/Relay/'> <text>Original</text></Echo>

The outer element is named "Echo" like the operation that is going to be called on the interface with the namespace "http://samples.microsoft.com/ServiceModel/Relay/" of the ServiceContract. Then there is the parameter "text" with its value "Original".

Response

The response is empty, here you would expect your value to show up that you get back from the ServiceBus as return values, however, it does not seem to work at the present time.

CloudHttpSend

Again look at the sample at Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\GettingStarted and this time find the activity cloudHttpSend1.

The activity corresponds to the following Xoml-fragment:

<ns0:CloudHttpSend x:Name="cloudHttpSend1" StatusCode="0" URL="http://www.microsoft.com" Method="GET" Request="{x:Null}" RequestContentType="{x:Null}" Response="{x:Null}" />

Select the activity and look at its properties:

URL

http://www.microsoft.com

The address of the resource you want to access. The WorkflowValidator will allow the Uri-Schemes "http", "https" and "ftp". The URL has to be given in absolute format. (The actual access is done through HttpWebRequest).

Method

GET

Allowed values are "GET" and "POST".

RequestContentType

This only is being considered for the "POST"-method. An example would be "text/plain".

Request

This is only being considered for the "POST"-method. The string here will be written to the RequestStream of the HttpWebRequest by interpreting the the String as UTF8-encoded through Encoding.UTF8.GetBytes(REQUESTSTRING).

StatusCode

The StatusCode that the HTTP-Request receives will appear here after the call was being made.

Response

The "Response" property will contain the content of the ResponseStream of the HttpWebRequest interpreted as UTF8-encoded.

There is really not much more to it, I will however try to give an end-to-end example that utilizes this activity in a bit more meaningful manner.

CloudHttpReceive

CloudHttpReceive is tough to impossible to figure out with the given documentation as to date.

Let me first quote the documentation:

CloudHttpReceive: This activity receives an HTTP request at the URI http://workflow.biztalk.net/servicesHttp/<UserName>/workflows/<WorkflowTypeName>/instances/
<InstanceId>/<ActivityName> and returns a response. The HTTP listener uses Identity service access control and the operation name "Send"

Properties

Response: the HTTP content to send in response to the HTTP request

StatusCode: the HTTP status code to return in response to the HTTP request

Request: the content of the received HTTP request. This property is set by the activity when a request is received.

It sounds easier than it is.

This is the smallest possible workflow utilizing this activity:

and its corresponding Xoml-definition:

<SequentialWorkflowActivity x:Class="WorkflowProject1.Workflow1" x:Name="Workflow1" xmlns:ns0="http://schemas.microsoft.com/2007/11/CloudWorkflowActivityLibrary" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
  <ns0:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />
</SequentialWorkflowActivity>

A closer look of the Xoml-fragment of that very simple cloudHttpReceive:

<ns0:CloudHttpReceive Request="{x:Null}" x:Name="cloudHttpReceive1" StatusCode="0" Response="Hello" />

It corresponds to those properties:

Request

This property will contain the string you received in the Request-Stream interpreted as UTF8-encoded.

Response

What you set here will be returned to the caller.

StatusCode

This is the statuscode that you will send to the caller.

Log in to BizTalk Workflow Services and create a type named "MinimalHttpReceive" with that Xoml definition and click "save changes".

Note that you did not need to provide a rules definition.

Create an instance of that type and start it and look at your instance manager:

Note the GUID of the workflow instance: 7bf7a7c4-82f5-4935-9c03-62ba1e7991aa
This will vary for you and you will have to remember your own GUID.

Now start the workflow instance and go to this URL in your browser:

http://workflow.biztalk.net/servicesHttp/YOURUSERNAMEHERE/workflows/MinimalHttpReceive/instances/YOURGUIDHERE/cloudHttpReceive1

If your browser does not display the complete URL, here it is again as a link:
http://workflow.biztalk.net/servicesHttp/YOURUSERNAMEHERE/workflows/
MinimalHttpReceive/instances/YOURGUIDHERE/cloudHttpReceive1

You should see something like this:

Now you need to log in with the username and password (or respective Information Card) that you used to create the workflow type and instance.

Then you should see something like that:

<string xmlns="http://schemas.microsoft.com/2003/10/Serialization/">Hello</string>

Your workflow should have been changed to "Completed" state.

Now what is interesting here is that you do not receive a pure string "Hello" but actually an XML serialization representation of the object string with content "Hello".

Sending to CloudHttpReceive programmatically

Ok, but now how can you do this programmatically? As you might realize, the challenge is the need to "log in". Unfortunately you cannot just use NetworkCredentials to log in but need to make a little detour.

At first you need to retrieve a token for logging in. You can find an example how to do it in this sample: Program Files\Microsoft BizTalk Services SDK\Samples\Workflow\ExploringFeatures\CreateWorkflowAPIs in Program.cs method GetTokenGrantingToken.

I took the liberty of modifying the method slightly and to remove any dependency to the SDK:

static string GetTokenGrantingToken(string userName, string password)
{
    string tokenUrl = string.Format(
        "https://{0}/issuetoken.aspx?u={1}&p={2}",
        "identity.biztalk.net",
        userName,
        password);
 
    HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
    HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
    using (Stream responseStream = tokenResponse.GetResponseStream())
    {
        byte[] tokenBody = new byte[500];
        int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
        return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
    }
}

It is pretty straightforward. Basically it is a simple HTTPS request to this URL:

https://identity.biztalk.net/issuetoken.aspx?u=YOURUSERNAME&p=YOURPASSWORD

Now, the string that you received represents your token and you need to attach that as a header of type "X-MS-Identity-Token" to your WebHttpRequest you want to send to your workflow instance.

request.Headers.Add("X-MS-Identity-Token", token);

This is the code-snipped for a method encapsulating the whole request:

static string CallHttpReceiveActivity(
                    string requestBody, string username, string token,
                    string workflowTypeName, string activityName,
                    string instanceId)
{
 
    Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                + username + "/workflows/" + workflowTypeName +
                "/instances/" + instanceId + "/" + activityName);
    HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
    //this adds the retrieved token as a header
    request.Headers.Add("X-MS-Identity-Token", token);
    request.Method = "POST";
    request.ContentType = "text/plain";
    //send the body
    byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
    request.ContentLength = requestBodyBytes.Length;
    using (Stream requestStream = request.GetRequestStream())
    {
        requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
        requestStream.Flush();
    }
 
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();
    using (Stream responseStream = response.GetResponseStream())
    {
 
        using (StreamReader reader = new StreamReader(responseStream,
                                                      Encoding.UTF8))
        {
            return reader.ReadToEnd();
        }
    }
}

You can combine both like this:

static string CallHttpReceiveActivityWithLogin(
                    string requestBody, string username, string password,
                    string workflowTypeName, string activityName,
                    string instanceId)
{
    string token = GetTokenGrantingToken(username, password);
    return CallHttpReceiveActivity(
                            requestBody, username, token,
                            workflowTypeName, activityName,
                            instanceId);
}

And an example call to the same workflow instance that we accessed above through the browser would be:

string userName = "YOURUSERNAME";
string password = "YOURPASSWORD";
string workflowTypeName = "MinimalHttpReceive";
string activityName = "cloudHttpReceive1";
string instanceId = "7bf7a7c4-82f5-4935-9c03-62ba1e7991aa";//YOUR GUID HERE INSTEAD
string requestBody="Text to send to cloud";
string result = CallHttpReceiveActivityWithLogin(
                        requestBody, userName, password,
                        workflowTypeName, activityName,
                        instanceId);

For the sake of completeness here the complete code together:

using System;
using System.Text;
using System.Net;
using System.IO;
 
namespace SendToHttpReceive
{
    class Program
    {
        static void Main(string[] args)
        {
 
            string userName = "YOURUSERNAME";
            string password = "YOURPASSWORD";
            string workflowTypeName = "MinimalHttpReceive";
            string activityName = "cloudHttpReceive1";
            string instanceId = "7bf7a7c4-82f5-4935-9c03-62ba1e7991aa";//YOUR GUID HERE INSTEAD
            string requestBody="Text to send to cloud";
            string result = CallHttpReceiveActivityWithLogin(
                                    requestBody, userName, password,
                                    workflowTypeName, activityName,
                                    instanceId);
            Console.WriteLine(result);
            Console.ReadLine();
        }
 
 
        static string CallHttpReceiveActivityWithLogin(
                            string requestBody, string username, string password,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
            string token = GetTokenGrantingToken(username, password);
            return CallHttpReceiveActivity(
                                    requestBody, username, token,
                                    workflowTypeName, activityName,
                                    instanceId);
        }
 
        static string GetTokenGrantingToken(string userName, string password)
        {
            string tokenUrl = string.Format(
                "https://{0}/issuetoken.aspx?u={1}&p={2}",
                "identity.biztalk.net",
                userName,
                password);
 
            HttpWebRequest tokenRequest = (HttpWebRequest)WebRequest.Create(tokenUrl);
            HttpWebResponse tokenResponse = (HttpWebResponse)tokenRequest.GetResponse();
 
            using (Stream responseStream = tokenResponse.GetResponseStream())
            {
                byte[] tokenBody = new byte[500];
                int tokenBodyLength = responseStream.Read(tokenBody, 0, 500);
                return Encoding.UTF8.GetString(tokenBody, 0, tokenBodyLength);
            }
        }
 
 
 
        static string CallHttpReceiveActivity(
                            string requestBody, string username, string token,
                            string workflowTypeName, string activityName,
                            string instanceId)
        {
 
            Uri address = new Uri(@"http://workflow.biztalk.net/servicesHttp/"
                        + username + "/workflows/" + workflowTypeName +
                        "/instances/" + instanceId + "/" + activityName);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(address);
            //this adds the retrieved token as a header
            request.Headers.Add("X-MS-Identity-Token", token);
            request.Method = "POST";
            request.ContentType = "text/plain";
            //send the body
            byte[] requestBodyBytes = Encoding.UTF8.GetBytes(requestBody);
            request.ContentLength = requestBodyBytes.Length;
            using (Stream requestStream = request.GetRequestStream())
            {
                requestStream.Write(requestBodyBytes, 0, requestBodyBytes.Length);
                requestStream.Flush();
            }
 
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            using (Stream responseStream = response.GetResponseStream())
            {
 
                using (StreamReader reader = new StreamReader(responseStream,
                                                              Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

Running that against a running workflow instance will (not surprisingly) result in this output:

In a future post I will try to show an "end-to-end"-demo that actually integrates a lot of what was shown previously and achieves bidirectional communication with a service in the cloud and has your workflow doing something that the service requests.

Andreas@Mobility Day 2008, Zagreb, Croatia

Andreas Erben — Sat, 13 Sep 2008 01:10:24 GMT

I had the honor to present at the Mobility Day 2008 in beautiful Zagreb, Croatia on September 9, 2008.

I covered part 2 of a series of two sessions dealing with "best practices" about connecting mobile systems. While the first part, presented by Damir Dobric, dealt with quite advanced connectivity scenarios utilizing WCF and .NET Compact Framework at the core implementation level, my part presented a larger scenario combining a WCF Service Bus and a retry-ing binding together with a cell tower to geo-coordinate service to a multiple-subscriber application.

Find my presentation at this location: http://developers.de/media/p/2857.aspx.

daenet wins German innovation prize 2008 for SOA / daenet gewinnt den Innovationspreis 2008 für die Kategorie SOA

Andreas Erben — Thu, 06 Mar 2008 15:41:43 GMT

(German version below / deutsche Version weiter unten)

Now I can finally talk about it. Our daenet SOA Suite now has officially been awarded with an important prize. "http://www.imittelstand.de/auszeichnungen/innovationspreis2008/kategoriesieger/soa.html" The "Innovationspreis 2008" (innovation prize 2008) specifically considers the needs of the so called "Mittelstand". The "Mittelstand" is the engine and the driver of the economy in Germany. Even though it means roughly "medium sized businesses", many of them are international, globalized companies with 10000 employees and more that in the US most often would be called enterprises. What is special about them is the down-to-earth "can-do" attitude and the need for fast return of investment (ROI) coupled with a high level of innovation.

So we are very proud that our SOA solution is being recognized as the BEST SOA solution for the most important customers that possibly could exist for all the right reasons.

The jury was huge and impressive, both academically apt and still with the mindset of delivering value is the key differentiator in life.

Why did we target the needs of the "Mittelstand"? Because we see that a lot of SOA approaches are far too complex for most companies and therefore too much being talked about and too little is being actually done. Being suitable for "Mittelstand" in my opinion automatically means being suitable for enterprises with the advantage that you can "scale" the approach down even to the departmental level.

In future posts I will likely talk more about what the daenet SOA Suite can do... until then: just ask me if you are interested.

(German version / deutsche Version)

Nun kann ich endlich darüber sprechen. Unsere daenet SOA Suite wurde offiziell mit einem wichtigen Preis ausgezeichnet. "http://www.imittelstand.de/auszeichnungen/innovationspreis2008/kategoriesieger/soa.html" Der "Innovationspreis 2008" berücksichtigt besonders die Bedürfnisse des sogenannten "Mittelstand". Der Mittelstand ist der Motor der deutschen Wirtschaft. Auch wenn es eigentlich "Mittelgroße Firmen" bedeutet, sind viele dieser in Wirklichkeit internationale, globalisierte Firmen mit 10000 und mehr Angestellten, die in den USA oft "enterprises" genannt würden. Besonders am Mittelstand ist die Bodenständigkeit und die "wir machen's möglich"-Einstellung, welche aber mit der Notwendigkeit einhergeht, einen schnellen Investitionsrückfluss (ROI) zu erreichen, der mit einem hohen Innovationsbedarf und hoher Innovationskraft gekoppelt ist.

Also sind wir sehr stolz, dass unsere SOA Lösung als die BESTE SOA Lösung für diese Kundenzielgruppe anerkannt wurde, welche sicherlich aus all den richtigen Gründen heraus gesehen die wichtigste Kundenzielgruppe überhaupt ist.

Die Jury selbst war groß und beeindruckend: Akademisch qualifiziert und gleichzeitig mit dem Bewusstsein, dass "Werte schaffen" der Hauptunterscheidungsgrund im Leben ist.

Warum haben wir speziell die Bedürfnisse des "Mittelstand" adressiert? Weil wir sehen, dass viele SOA Ansätze bei weitem zu komplex für die meisten Firmen sind und deshalb zu viel geredet und zu wenig gehandelt wird. Wenn eine Lösung für den Mittelstand geeignet ist, heisst das meiner Meinung nach, dass sie automatisch auch für Konzerne geeignet ist aber den Vorteil mitbringt, nach "unten" skalierbar zu sein, also selbst auf Abteilungsebene einsetzbar zu sein.

In künftigen Artikeln werde ich wahrscheinlich mehr darüber schreiben, was die daenet SOA Suite alles kann... bis dahin: Bitte fragen Sie mich, wenn Sie Interesse haben!

Huge surprise today around daenet and SOA / Heute große Überraschung rund um daenet und SOA

Andreas Erben — Thu, 06 Mar 2008 12:35:18 GMT

(German version below / deutsche Version weiter unten)

Expect a huge surprise today. I am waiting for the official press info to leak out so nobody is upset with me that I talk about it. What I can tell you is that it is around daenet and SOA. It will be one more reason to talk to us when it comes to this topic :)

(German version / deutsche Version)

Heute kommt noch eine große Überraschung auf uns zu. Ich warte noch darauf, dass eine offizielle Presseinfo raussickert, so dass niemand sauer auf mich sein kann, dass ich darüber rede. Was ich jetzt schon sagen kann ist, dass es um daenet und SOA geht. Es wird ein weiterer Grund sein, mit uns über dieses Themengebiet zu sprechen :)

Workaround for problem with BizTalk RFID and .NET 3.5 beta 2 installed on the same machine

Andreas Erben — Wed, 03 Oct 2007 18:44:39 GMT

If you install .NET framework 3.5 beta 2 on the same machine like Microsoft BizTalk RFID, then your RFID Services will not start anymore.

See: http://support.microsoft.com/kb/942521

The reason for this is that the installation of .NET framework 3.5 beta 2 does not leave the DLLs of .NET framework 3.0 alone, but replaces them, introducing at least one bug.

In this case, the System.Runtime.Serialization.dll is replaced, both in
%windir%\Microsoft.Net\Framework\v3.0\Windows Communication Foundation
and in the GAC.

To fix this, you need to retrieve an old version of the System.Runtime.Serialization.dll from a working installation of .NET framework 3.0 and register it in the GAC.
What you do NOT want is version 3.0.4506.590. What you want is for example version 3.0.4506.30. Note however, that this is completely unsupported and that you do this at your own risk and that their might be side effects and incompatibilities with other parts of the system.

Reminder: To install the correct copy in the GAC use this line:
gacutil /f /i System.Runtime.Serialization.dll

This will force an overwrite of the existing System.Runtime.Serialization.dll

You can find gacutil usually in:
%ProgramFiles%\Microsoft SDKs\Windows\6.0\bin\gacutil.exe
or if you installed the full SDK that comes with Visual Studio 2008 Beta 2, in
%ProgramFiles%\Microsoft SDKs\Windows\6.0\bin\gacutil.exe.

Good luck!

WCF designer revisited: Efforts on the way, not coming as part of any product yet

Andreas Erben — Thu, 07 Jun 2007 00:19:46 GMT

Damir recently posted about a WCF designer, or rather that there is no WCF designer yet and it does not seem to be on the immediate roadmap for Orcas / Visual Studio 2008.

Let me look deeper into the promise of the WCF designer..

Chris Smith said in early 2006 he is working on the WCF designer experience. But what are the actual developments we actually see?

1. VS 2005 extensions for .NET Framework 3.0 (WCF & WPF) & VS 2008 ("Orcas")

The "Visual Studio 2005 extensions for .NET Framework 3.0 (WCF & WPF)" have been referred to as "WCF designer" in the blog post "Introducing the <DataContract>" by Thom Robbins. Those features will be available in Visual Studio 2008 (codename: Orcas). They might not "deserve" the name though when comparing with what people actually might expect when hearing "WCF designer".

2. Patterns & Practices: Service Factory

There is speculation that the "Service Factory" from Patterns&Practices will basically contain or be what people will then call "WCF designer". Currently the recent developments are available at Codeplex, check out the newer builds. Check out the Service Factory Blogs.As of the time of the posting though, this does NOT work with Orcas yet.

Taken from Don Smith's blog post "First Service Factory v3 Community Drop" here are two pictures of what to expect

There are newer builds available already.

3. Community effort: DSLFactory Utilities

Last but not least I want to point your attention to the efforts of the French speaking community http://dslfactory.org/. Check out codeplex here: http://www.codeplex.com/DslFactoryUtilities.

They posted how it can look like:

This is synchronized with code.

Not bad at all!

Not part of any product yet

We see various efforts underway inside Microsoft and inside the community, but there is no product yet that will ship anything WCF designer-like. Please note that "Service Factory" is something "unsupported" as long as it resides in "Patterns&Practices" and does not count as a product.

I hope this overview gets you started on the quest for the WCF designer :)

svcutil.exe/wsdl.exe: issue with message part name "parameters"

Andreas Erben — Fri, 02 Feb 2007 01:16:00 GMT

In a WCF project we recently received a WSDL from our customer that we needed to build a client/proxy to.
So we used svcutil.exe to generate the C#-code we wanted.
To our surprise, the code did not contain the types of the contract we expected, but something like this:

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.ServiceContractAttribute(Namespace="http://MyService.namespace", ConfigurationName="MyService")]

public interface MyService

{

// CODEGEN: Generating message contract since the wrapper namespace (http://MyTypes.namespace) of message myMethodRequest does not match the default value (http://MyService.namespace)

[System.ServiceModel.OperationContractAttribute(Action="myMethod", ReplyAction="*")]

myMethodResponse myMethod(myMethodRequest request);

}

[System.Diagnostics.DebuggerStepThroughAttribute()]

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.MessageContractAttribute(WrapperName="Request", WrapperNamespace="http://MyTypes.namespace", IsWrapped=true)]

public partial class myMethodRequest

{

public myMethodRequest()

{

}

[System.Diagnostics.DebuggerStepThroughAttribute()]

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.MessageContractAttribute(WrapperName="Response", WrapperNamespace="http://MyTypes.namespace", IsWrapped=true)]

public partial class myMethodResponse

{

public myMethodResponse()

{

}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

public interface MyServiceChannel : MyService, System.ServiceModel.IClientChannel

{

}

After a long time of experimenting around and not getting a clue, I tried the good old wsdl.exe, which gave me the following:

Microsoft (R) Web Services Description Language Utility
[Microsoft (R) .NET Framework, Version 2.0.50727.312]
Copyright (C) Microsoft Corporation. All rights reserved.
Error: Unable to import binding 'MyService_SoapHttp_Binding' from namespace 'http://MyService.namespace'.
- Unable to import operation 'myMethod'.
- These members may not be derived.

If you would like more help, please type "wsdl /?".

OK, so there was an issue with abstract types? Indeed, the WSDL contained abstract complexTypes and a complexType extending that abstract type for both, request and response.

I then simplified it by just making one of those types a simple type. And suddenly it worked. However, this was not satisfying.

When playing around with it, I ended up at the message parts which were like this:

At one point I changed one of the name attributes of the message part to something else, say:

and suddenly it worked.

I changed it back and did the same for the request.

So, I thought, it was a problem with the name property being duplicated. However, looking at other examples proved that this was not the case.

A section saying

would work just fine, we found.

It is a weird combination of: abstract types used in both request and response and the names of the message parts of request and response being both "parameters".

Here is the full "problem" wsdl to play with. Have fun.

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="MyService" targetNamespace="http://MyService.namespace" xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:myns="http://MyTypes.namespace" xmlns:sdx="http://ServiceDescription.namespace" xmlns:tns="http://MyService.namespace" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
    <types>
        <schema attributeFormDefault="unqualified" elementFormDefault="unqualified" targetNamespace="http://MyTypes.namespace" version="1.1" xmlns="http://www.w3.org/2001/XMLSchema" xmlns:myns="http://MyTypes.namespace">
            <complexType abstract="true" name="RequestAbstractType">
                <attribute name="RequestID" type="integer" use="required"/>
            </complexType>
            <element name="Request" type="myns:RequestType"/>
            <complexType name="RequestType">
                <complexContent>
                    <extension base="myns:RequestAbstractType">
                        <sequence>
                            <element name="RequestNode" type="string"/>
                        </sequence>
                    </extension>
                </complexContent>
            </complexType>
            <complexType abstract="true" name="ResponseAbstractType">
                <attribute name="ResponseID" type="integer" use="required"/>
            </complexType>
            <element name="Response" type="myns:ResponseType"/>
            <complexType name="ResponseType">
                <complexContent>
                    <extension base="myns:ResponseAbstractType">
                        <sequence>
                            <element name="ResponseNode" type="string"/>
                        </sequence>
                    </extension>
                </complexContent>
            </complexType>
        </schema>
    </types>
    <message name="MyServiceRequest">
        <part element="myns:Request" name="parameters" />
    </message>
    <message name="MyServiceResponse">
        <part element="myns:Response" name="parameters" />
    </message>
    <portType name="MyService">
        <operation name="myMethod">
            <input message="tns:MyServiceRequest"/>
            <output message="tns:MyServiceResponse"/>
        </operation>
    </portType>
     <binding name="MyService_SoapHttp_Binding" type="tns:MyService">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
    <operation name="myMethod">
    <soap:operation soapAction="myMethod"/>
    <input>
        <soap:body use="literal"/>
    </input>
    <output>
        <soap:body use="literal"/>
    </output>
    </operation>
</binding>
<service name="MyServiceProvider">
    <serviceKey xmlns="http://MyServiceProvider.namespace">uddi:myservices.org:MyServiceProvider</serviceKey>
        <port binding="tns:MyService_SoapHttp_Binding" name="MyService_Http_Port">
            <soap:address location="http://myserver:12345/soap/MyServiceProvider"/>
        </port>
        <port binding="tns:MyService_SoapHttp_Binding" name="MyService_Https_Port">
            <soap:address location="https://myserver:12346/soap/MyServiceProvider"/>
        </port>
    </service>
</definitions>

The relevant samples are available for download as a .zip attachment.