MVP: I’ve been re-awarded with a twist!

by community-syndication | Oct 3, 2012 | BizTalk Community Blogs via Syndication

In the wee early hours of the morning I recently got an email saying I had been awarded
a MVP for another year.

This time I got awarded as an Azure MVP coming from BizTalk
MVP. My love has been BizTalk for the last 12 years (and even Site Server
before that for those that remember back that farno they didn’t have punch cards ).

As always I don’t feel this is personally my award, but more of an award to you, the
community with your hunger and thirst for knowledge to make a difference in your day
to day.

And of course thank you to Microsoft for your belief in the MVP program and individuals
such as myself.

The formal bits out of the way.I’m back for 2012/13!!! Should be a great yeargreat
tourand huge developments. Stay tuned.

My focus will be How to Integration and how-to integrate to/from Windows Azure.

Blog Post by: Mick Badran

Mobilizing Your Line of Business Systems : Introducing The Enterprise Mobile Backend As A Service

by community-syndication | Oct 3, 2012 | BizTalk Community Blogs via Syndication

After a brief hiatus, I am super happy to announce our next Tellago Technology Update. This time we will be focusing on one of my favorite topics: enterprise mobility. Here is a quick summary: Title: Mobilizing Your Line of Business Systems : Introducing…(read more)
Blog Post by: gsusx

BizTalk Community Series: Introducing Stuart Brierley

by community-syndication | Oct 3, 2012 | BizTalk Community Blogs via Syndication

Last couple of weeks I have been preparing and giving talks on BizTalk Server in combination with Windows Azure Service Bus. The integration capabilities Microsoft provides on-premise and in the cloud are amazing and unique. There is no other vendor that has an integration infrastructure up in the cloud like the Service Bus. There are on-premise integration/messaging engines like BizTalk, however the number of adapters it offers has not been matched by any other. These are exciting times as Microsoft keeps innovating both BizTalk Server and Windows Azure Service Bus.

Today I am going to introduce you to another community member that has been contributing to the BizTalk community for quite some time through his blog. His name is Stuart Brierley and he works for Vasanta Group, the UK’s largest supplier of office products, as a Systems Integration Specialist.

and on community

As the father of three young boys (age 1, 8 and 10) spare time is not something that Stuart has a lot of 🙂  He enjoys reading, listening to music, watching TV and Films, football (soccer), cycling…… too many things to fit into an average week! Most of all he enjoys spending time with his family, whether it be taking the older boys to their athletics/swimming/football (soccer)/gymnastics training, going for long tiring bicycle rides together with them and his wonderful wife or just relaxing and playing around the house.

Currently Stuart enjoys getting back into cycling with his thankfully enthusiastic family and he has always enjoyed playing football (soccer), but recently have found that he kept picking up injuries! He is a dedicated Manchester United fan:

“I am a life long supporter of Manchester United, a trait which I am pleased to say I have passed on to the rest of my family :)”

A cool soccer team as they have one of finest striker couple in the world: Wayne Rooney and Robin van Persie.

A final word from Stuart towards the BizTalk community:

Thanks Stuart for your time and contributions!

BizTalk 2010 R2 CTP: Azure Service Bus Integration-Part 4 Sending Messages to Service Bus Topics

by community-syndication | Oct 2, 2012 | BizTalk Community Blogs via Syndication

Back again with Part 4 in this series.  This time around we are going use BizTalk to send a message to an Azure Service Bus Topic using the new SB-Messaging Adapter.

What is the difference between a Service Bus Queue and Topic?

Conceptually they are very similar in the sense that they both provide a durable message store within Azure where Publishers can publish messages and Consumers can consume messages.  Queues store messages in a First In First Out (FIFO) manner and provide a competing consumer experience.  What this means is that if we have two queue clients that are polling the same queue then only one client will receive a copy of any given message.

Topics provide some additional features that really support a Publish/Subscribe (Pub/Sub) architecture.  Topics allow for multiple clients to subscribe to the same Topic through subscriptions.  Subscriptions also support SQL92 expressions and allow a consumer to filter messages out based upon BrokeredMessage Properties.

Scenario

In Part 3 I  discussed how our Work Order Management system can notify our Major Account System when an Estimated Time of Restore is available.  This allows Major Account Representatives the ability to reach out to customers to share the good/bad news about when their power will be restored.

We are going to build upon this scenario but instead of sending all messages to a Queue we are going to send it to a Azure Service Bus Topic instead.  Due to the , fictional, growth of our company there are now two distinct groups responsible for Major accounts.  One for the city of Edmonton and another for the city of Calgary. (Both of these cities exist within Alberta, Canada)  Each queue Subscription client will now subscribe to events for their city.  BizTalk will however just send messages to one Topic and let the Service Bus work out which message needs to be delivered to each client.

Modifying Client Application(s)

Calgary Application

• Once again we are going to leverage the work that we have done in previous posts(In this case Part 3).  The first thing we will do is rename our previous C# Console project from BrokeredMessageFromBizTalk to BrokeredMessageFromBizTalkCalgary.

• Next we will modify the namespace for the Program.cs file so that it reflects the name of the project (BrokeredMessageFromBizTalkCalgary).  Note we will leave the namespace of our EstimatedTimeToRestore.cs as is.
• Below is the entire code listing for our Calgary Client.  Within this code we will use our connectivity parameters to establish a connection.  Once we have a connection we will see if the Calgary subscription currently exists.  If it does not, we will create it.  We will also create it and add a SQLFilter.  This particular filter is interested in messages where the Address Brokered Message Property equals “Calgary”.

using System.IO;
using System.Runtime.Serialization;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Messaging;
using BrokeredMessageFromBizTalk;

namespace BrokeredMessageFromBizTalkCalgary
{
    class Receiver
    {
        const string TopicName = “<your_topic>”;
        static string ServiceNamespace = “<your_namespace>”;
        static string IssuerName = “<your_owner>”;
        static string IssuerKey = “<your_key>”;
        static string connectionString = String.Format(“Endpoint=sb://{0}.servicebus.windows.net/;SharedSecretIssuer={1};SharedSecretValue={2}”,
             ServiceNamespace, IssuerName, IssuerKey); 

        static void Main(string[] args)
        {
           
            TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(
                Receiver.IssuerName, Receiver.IssuerKey);
            Uri uri = ServiceBusEnvironment.CreateServiceUri(“sb”, Receiver.ServiceNamespace, string.Empty);
            MessagingFactory messagingFactory = MessagingFactory.Create(uri, tokenProvider);

            // Create a “Calgary” SQLFilter
           SqlFilter calgaryFilter = new SqlFilter(“Address = ‘Calgary'”);

            //Check to see if Calgary Subscription exists, if it does not then create it
            NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(Receiver.connectionString);
            if (!namespaceManager.SubscriptionExists(Receiver.TopicName, “Calgary”))
            {

                //Create Calgary Subscription with our calgaryFilter
                namespaceManager.CreateSubscription(Receiver.TopicName, “Calgary”, calgaryFilter);

            }
            //Create Subscription Client using Peek/Lock Mode
            SubscriptionClient sc = messagingFactory.CreateSubscriptionClient(Receiver.TopicName , “Calgary”, ReceiveMode.PeekLock);
            BrokeredMessage bm;
            while ((bm = sc.Receive(new TimeSpan(hours: 0, minutes: 0, seconds: 20))) != null)
            {
                var data = bm.GetBody<EstimatedTimeToRestore>(new DataContractSerializer(typeof(EstimatedTimeToRestore)));
                Console.WriteLine(String.Format(“An estimated time of restore {0} has been received for {1}”, data.RestoreTime, data.CustomerName));
                Console.WriteLine(“Brokered Message Property Address has a value of {0}”, bm.Properties[“Address”]);
                //Remove message from Topic
                bm.Complete();
            }

        }
    }
}

Edmonton Application

• Within our existing Visual Studio solution we are going to add another C# Console Application called BrokeredMessageFromBizTalkEdmonton.

• Within this application we will create a reference to our “Calgary” project.  We need to do this so that we have access to the EstimatedTimeToRestore class. This is accomplished by including the following statement:
  • using BrokeredMessageFromBizTalk;
• Otherwise we can simply copy and past the “Calgary” Program.cs code and adapt it for our Edmonton scenario.The main areas that we need to focus on are creating a unique Edmonton Subscription and ensuring that our Edmonton filter matches Edmonton messages and not Calgary messages.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.Serialization;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Messaging;
using BrokeredMessageFromBizTalk;

namespace BrokeredMessageFromBizTalkEdmonton
{
    class Receiver
    {
        const string TopicName = “<your_topic>”;
        static string ServiceNamespace = “<your_namespace>”;
        static string IssuerName = “<your_owner>”;
        static string IssuerKey = “<your_key>”;
        static string connectionString = String.Format(“Endpoint=sb://{0}.servicebus.windows.net/;SharedSecretIssuer={1};SharedSecretValue={2}”,
             ServiceNamespace, IssuerName, IssuerKey);

        static void Main(string[] args)
        {

            TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(
                Receiver.IssuerName, Receiver.IssuerKey);
            Uri uri = ServiceBusEnvironment.CreateServiceUri(“sb”, Receiver.ServiceNamespace, string.Empty);
            MessagingFactory messagingFactory = MessagingFactory.Create(uri, tokenProvider);

            // Create a “Edmonton” filtered subscription
            SqlFilter edmontonFilter = new SqlFilter(“Address = ‘Edmonton'”);

            //Create NamespaceManager object and see if Edmonton Subscription exists for our Topic
            NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(Receiver.connectionString);
            if (!namespaceManager.SubscriptionExists(Receiver.TopicName, “Edmonton”))
            {
                //If the Subscription does not exist, create it
                namespaceManager.CreateSubscription(Receiver.TopicName, “Edmonton”, edmontonFilter);

            }

            //Create Subscription client and use Peek/Lock mechanism for delivery
            SubscriptionClient sc = messagingFactory.CreateSubscriptionClient(Receiver.TopicName, “Edmonton”, ReceiveMode.PeekLock);
            BrokeredMessage bm;
            while ((bm = sc.Receive(new TimeSpan(hours: 0, minutes: 0, seconds: 20))) != null)
            {
                var data = bm.GetBody<EstimatedTimeToRestore>(new DataContractSerializer(typeof(EstimatedTimeToRestore)));
                Console.WriteLine(String.Format(“An estimated time of restore {0} has been received for {1}”, data.RestoreTime, data.CustomerName));
                Console.WriteLine(“Brokered Message Property Address has a value of {0}”, bm.Properties[“Address”]);
                //remove message from Topic
                bm.Complete();
            }

        }
    }
}

Creating Topic

Much like we did in the previous blog post where we created a Service Bus Queue, we can also create a Service Bus Topic from the http://windowsazure.com portal

• To create a new Topic simply click on the New Topic button.

• Provide a Topic Name.  For the purpose of this post I am using PowerRestoreTopic.  We can then leave the default settings as is.

Note: We can also create Topics via code by using the NamespaceManager class much like we did for Subscriptions.  I decided to use the portal just to demonstrate that we have a few options when creating Service Bus artifacts.

Modifying BizTalk Solution

Once again we are going to keep the BizTalk Solution changes to a minimum and will continue to use a Messaging Only scenario.

• The first change that we are going to make is to our BrokeredMessagePropertySchema by adding our Address field.  Note if you recall from our C# projects that we created SQLFilters based upon the Address property being equal to either Calgary or Edmonton(depending upon the application).  By adding this property to our PropertySchema we can now promote this value in our XSD.
• Next we will modify the ETRfile.xsd and promote the Address field.  We will then map this field to the property we just created in our PropertySchema.

• We can now deploy our BizTalk Application and bounce any related Host Instances.
• While inside the BizTalk Administration Console, we need to modify our SB-Messaging Send Port called SendEstimatedTimeToRestoreToAzure.  Previously we were using this Send Port to send messages to a Service Bus Queue.  We will now be sending messages to a Topic which uses the same convention within the URI.  Instead of including our Queue Name in the URI we need to specify the Topic Name.  In our scenario I am going to specify PowerRestoreTopic.

• Our Authentication tab remains unchanged. We will continue to use the same Issuer Name and Issuer Key as in our previous example.

• Finally, we need to click on the Properties tab so that we can enable our custom Brokered Message Properties. To enable these properties we need to provide the namespace for our Property Schema that we previously modified.  As you may recall, we added a property called Address that we will use to route messages within our Azure Topic Subscription.

Testing our Solution

• We are going to leverage the Receive Location that we created in Part 3 of this blog series.  Our solution is expecting messages that conform to the ETRfile.xsd schema.  Below, I have included two sample files.  One contains an Address that belongs in Edmonton and the other one has an Address that belongs in Calgary.  We will drop both of these files within the same receive location and they will be sent to the same PowerRestoreTopic.

• Once the messages have been sent we will launch our two client applications (Calgary and Edmonton).  The expectation is that the Calgary application will retrieve the Calgary Message and the Edmonton application will retrieve the Edmonton Message.
• As expected, our Edmonton client retrieved the Edmonton message and the Calgary client retrieved the Calgary message.

Conclusion

In this post we used existing BizTalk skills to send typed messages to an Azure Service Bus Topic.  We promoted a property within BizTalk that was converted to a Brokered Message Property that can be used within Subscription Filters in order to route messages between different consumers.

Once again the experience is very seamless. I really do like the .Net API for Service Bus.  I think it is intuitive and is very logical.  As simple as it is to use this API it is hard to imagine anything being much simpler. But it has been done. The BizTalk team has made interfacing with the Service Bus even easier than using the API.  From a BizTalk perspective the Service Bus is just another endpoint and requires some additional configuration.  I do find that this aligns with some of the early goals of BizTalk.

BizTalk-Map Incoming Message to a string Field

by community-syndication | Oct 2, 2012 | BizTalk Community Blogs via Syndication

In a recent project I worked, one of the requirements was to copy the entire incoming message to a String Field.

Consider the incoming message

This would have to be mapped to

so the output message should look like

In the BizTalk Mapper you cannot just map a node to the output field.

Well you can but the output is always going to be an empty field as shown below.

To achieve this you will have to make use of Scripting Functoids as follows

The first Functoid defines a C# function that takes a NodeIterator as the input and returns the OuterXml.

The second Functoid uses XSLT to map the incoming message to the string field called IncomingMsg in the output message. To achieve this it calls the NodeToString function that is defined in the previous Functoid. We pass it /TestNode which is the root node of the incoming message.

Since the first Functoid is just being used as a place holder to hold the C# function you will receive the following warning when you test the map in Visual Studio. But it can be ignored.

Blog Post by: Shinva

Bouvet BizTalk Innovation Event – A great experience!

by community-syndication | Oct 2, 2012 | BizTalk Community Blogs via Syndication

Last week I held a presentation at the Bouvet BizTalk Innovation Event (26 – 27 September). This was one of the biggest BizTalk events organized in the Nordic countries this year. Four BizTalk MVP’s together with two distinguished community members presented two full days on BizTalk Server, Service Bus, BizTalk Administration and BizTalk360 (Monitoring). I shared the stage during this days with fellow BizTalk MVP’s Sandro Pereira, Saravana Kumar, and Nino Crudele together with Tord G. Nordahl and Lex Hegt.

Bouvet organized this event for the first time in Norway. Previously BizTalk innovation events were organized in Utrecht (The Netherlands) and Milan (Italy). The venue was the Bouvet office in Stavanger.

Bouvet is a Scandinavian consultancy company, which delivers development and advisory services relating to information technology, interactive communication and enterprise management. Their strengths are broad expertise, long experience and the ability to solve problems creatively. Bouvet has more than 750 employees in 14 offices in Norway and Sweden.

Tord works for Bouvet and was together with his managers our host of the day. They did an outstanding job of organizing this event. The first day was packed with presentations and second day was around labs, live discussions of various topics.

The first day we as speakers talked about:

1) BizTalk adapter pack: Best practice and a presentation of the versatile integration capabilities of the adapter pack! This included various scenario’s with Azure Service Bus (Queues, Topics, Subscriptions and Bridges), SB-Messaging with BizTalk Server 2010 R2 CTP. A Talk by myself.

2) Azure and connected systems (formerly known as AppFabric connected systems) – EAI Integration done correctly, to the cloud and beyond! A talk done by Sandro showing the bridges for EAI and EDI.

3) Jump into the usage of thresholds and throttling to squeeze the BizTalk environment to the MAX. A talk by Tord our host.

4) Also introducing the new standard in BizTalk monitoring: BizTalk 360. This talk was by Saravana Kumar and Lex Hegt. Saravana walkthrough the product and showed some of the capabilities. Lex talked about some real life scenario’s with BizTalk360.

5) Large BizTalk environments, hundreds of servers and multiple adapters: how was it done and how did it scale? A talk by Nino our Italian BizTalk MVP.

This day was wrapped up by Tord and later on we had an awesome diner with the attendees and the Bouvet staff.

Second day each speaker had his own room and hourly time slots, where the attendees could come in ask questions, get some hand-on experience and raise discussions. During these sessions I was able to hand out my BizTalk Server 2010 Cookbook (multiple copies ordered by Bouvet) and sign it.

The two days at Bouvet BizTalk Innovation Event were a great experience. I like to thank Tord and Bouvet for organizing this.

Our next venue as speakers will probably be London next year.

Cheers,

Steef-Jan

a schedule with parameters cannot have an activatable receive

by community-syndication | Oct 2, 2012 | BizTalk Community Blogs via Syndication

You obtain this error if you try to have an active receive location and Orchestration parameters. When you have an activated reception shape, you cannot have orchestration parameters. So make your choice    
Blog Post by: Jeremy Ronk

Bouvet BizTalk Innovation Event Review

by community-syndication | Oct 1, 2012 | BizTalk Community Blogs via Syndication

So the event ended, and I wanted to give you all an update of what you missed out, or what you may have seen! A total of 50 people attended the event that lasted over 2 day. The First day was all about presentation we had a total of 6 speakers. First off was MVP
Blog Post by: Tord Glad Nordahl

Build and Deploy Manager using BTDF

by community-syndication | Oct 1, 2012 | BizTalk Community Blogs via Syndication

Fancy a build and deploy manager for BizTalk which uses BTDF in the background? We use BTDF for building the BizTalk projects and most people now would have used TFS to do continuous integration which can utilize BTDF do build and deploy the projects. However this is perfectly fine for automating the continuous integration process. […]
Blog Post by: shankarsbiztalk

Use SP.SOD.executeFunc(a,b,c) to load the SharePoint JavaScript libraries when needed

by community-syndication | Oct 1, 2012 | BizTalk Community Blogs via Syndication

A couple weeks ago, I was building a stock quote for a master page that required two images stored in /Style Library/Custom/; the images represented the typical stock quote arrows. In order to provide the JavaScript code with the correct location of the site collection’s root I was using the following directly in my code […]
Blog Post by: Patrick Kelly