So all People out there, I’m up to Windows 8 and I love it. I’ve heard a lot of bad experiences but I find it cool to not have the start button, and my daughter can use the computer even easier now. Anyways, I use this computer for work, so I had to install all […]
Blog Post by: Tord Glad Nordahl
2012 was an excellent professional and personal year for me, thankfully with lots of work but also extremely funny. I had the chance to meet and become good friend with a few outstanding BizTalk community members and MVP’s, some I had the opportunity to meet during MVP Summit, like Nino Crudele, others I met during […]
Blog Post by: Sandro Pereira
In next couple of weeks I like to do a series of blog posts on the new adapters provided in the upcoming release of BizTalk Server 2013. In this post I like to demonstrate the WCF-BasicHttpRelay adapter.
The WCF-BasicHttpRelay adapter can be used with BizTalk to send and receive messages from the Service Bus relay endpoints using the BasicHttpRelayBinding. This is a binding that BizTalk can use to configure endpoints which can communicate with ASMX-based Web services and other services that conform to the WS-I Basic Profile 1.1. The BasicHttpRelayBinding is derived from the standard BasicHttpBinding. However, the key difference between the two is that the BasicHttpRelayBinding can create publicly reachable and, if required, publicly discoverable HTTP listener endpoint listening on the Windows Azure Service Bus, while the BasicHttpBinding listens through the standard HTTP.sys listener on the local Windows computer.
The following scenario will describe a way to send messages to a Service Bus relay endpoint configured through WCF-BasicHttpRelay adapter in BizTalk Server 2013. A message from a client application will be send through the relay in the Windows Azure Service Bus to BizTalk Server. Below you will find a diagram that shows the flow of a message from a client (a feedback application) that will send a message to endpoint registered in Windows Azure Service Bus, which will be relayed through to BizTalk.
BizTalk Server has an endpoint registered in the Windows Azure Service Bus through a receive location that is configured with the WCF-BasicHttpRelay adapter. A receive location in BizTalk Server 2013 can be configured with the WCF-BasicHttpRelay Adapter using the “http” or “https” URI scheme. The URI will be used to register the endpoint on the Windows Azure Service Bus. The URI can be specified in the general tab of the WCF-BasicHttpRelay Transport properties.
WCF-BasicHttpRelay Transport properties General Tab.
With the Binding tab you can configure the time-out and encoding-related properties. Depending on your requirements you can specify different values than the default. For this scenario the default values are used.
WCF-BasicHttpRelay Transport properties Binding Tab.
The created channel is SSL-protected if the endpoint URI scheme is “https” and configured through the security tab of WCF-BasicHttpRelay Transport properties.
WCF-BasicHttpRelay Transport properties Security Tab.
When setting the Security mode to Transport or TransportWithMessageCredential the scheme will be “https”. Setting it to none the scheme will be “http”. By checking the “Enable service discovery” checkbox you can specify whether the behavior of the service is published in the Service Registry. By checking this checkbox the Display name text box and Discovery mode combo box will be enabled. In the text box you can specify the name with which the service is published to the Service Registry. The Discovery mode can be private or public. Public means publishing in the Service Registry, while private means this will not happen.
Finally with the Access control service you can specify the credentials to be used for authorization with the Service Bus in Access control service case you have specified that the Relay Client authentication type is RelayAccessToken. If that is the case then you will have to specify through Access control service (Edit button) the Issuer name and key.
The Access control Service Dialog Box.
The final tab called Messages enables you to specify the data selection for the SOAP Body element.
WCF-BasicHttpRelay Transport properties Messages Tab.
In this scenario all settings are left default.
Enabling the receive location will result in registration of receive location as an endpoint on Windows Azure Service Bus. This will be visible in Windows Azure Portal under the Service Bus your namespace and then relays.
With the relay present in the Service Bus you can send messages to it. Communication with the endpoint in this scenario will be one-way. Therefore message exchange will be fire-and forget. In case the Relay client authentication type is set to none when configuring the adapter your endpoint is accessible for everyone that has knowledge of the endpoint address. With a simple HTTP post I can send an XML message to the endpoint.
The message ends up in BizTalk being published to the MessageBox through Receive Port having a receive location configured with WCF-BasicHttpRelay adapter. A send port will have subscription of the message, which was received through the receive port and will send the message to a file location on the BizTalk machine.
In case the Relay client authentication type is set to RelayAccessToken when configuring the adapter your endpoint is only accessible for those that have the key and have knowledge of the endpoint address.
This scenario shows how with relative ease you can configure a receive port to register an endpoint in Windows Azure Service Bus. This enables you to receive messages into BizTalk to for instance start a process or collect data. In case you register an endpoint in the Windows Azure Service Bus like this then there is an easy way to test it. You can download the Service Bus Explorer by Paolo Salvatori. This great tool enables you to connect to the service bus, browse within you namespace your queues, topics and relays (see my post on Visual Studio Service Bus Explorer versus Standalone Service Bus Explorer). It provides capabilities to test communication with the Windows Azure Service Bus. If I go to the endpoint I created and select the URI I can send a test message to it.
The message will be send to BizTalk through relay in the Windows Azure Service Bus and finally end up in a folder on the BizTalk machine.
To test your endpoint configured through WCF-BasicHttpRelay can easily be tested using the Service Bus Explorer. This will save you time in writing a test client. This was the first of the series on the new adapters that will be available with the upcoming releases of BizTalk Server 2013.
The scenario above was created on a BizTalk Server 2013 Beta Virtual Machine I created on-premise with Windows Server 2008 R2, Visual Studio 2012 and SQL Server 2012. You can download the client I created for sending messages to relay through code gallery. In the series I will discuss the WCF-NetTCPRelay in the next post followed by posts on the SB-Messaging, WCF-WebHTTP and SFTP Adapter.
Cheers, Steef-Jan
If you don’t want to use a lot of money on service virtualization tools you can create a simple autogenerated WCF facade service that does a little bit of the things the big service virtualization tools does.
This gives you the option to hide service between one common service. The services behind this service could be a service from your backend system, a service from your CRM system and it might even be some external services.
You could do it manually, but then you would have to update it each time one of the backend services changes and with the human factor as an error source. Visual Studio gives you the option to use text templates which can be used to generate code.
Start by creating a WCF Service Application in Visual Studio and add a text template to this project, which will give you a *.tt file. This is the file that you will edit to create the autogenerated code. You might want to read a bit about it at MSDN before reading on. Here is the link.
Working with tt files is like going back in time. Back to the time with ASP and where you don’t have intellisense. I stongly recommend to use Visual Studio 2012 that at least gives you a good debug option.
The first part of the tt file is the part where you specify which .Net namespace you want to use. The tt files knows nothing about the references that you have in your project, which I found out the hard way. My initial thoughts were to use reflection to get information about the services that I was going to work with, but I got into problems when I wanted to work with service references. So I ended up using the EnvDTE namespace, where you work with the FileCodeModel in Visual Studio. So this gives me this first part of the tt file:
<#@ template debug=”true” hostspecific=”true” #>
<#@ output extension=”cs” #>
<#@ assembly name=”EnvDTE” #>
<#@ assembly name=”System.Xml” #>
<#@ import namespace=”EnvDTE” #>
<#@ import namespace=”System.Diagnostics” #>
<#@ import namespace=”System.Xml” #>
<#@ import namespace=”System.Collections.Generic” #>
I wanted to control which services got autogenerated in an XML file, so I at a *.mapping file to the solution where I created a structure with the name of the service I wanted.
Based on this I could load the FileCodeModel and find the CodeFunctions that needed to be exposed.
<#
EnvDTE.DTE dte = GetEnvDTE();
string myFile = this.Host.ResolvePath(“AutoGeneratedFacade.Mapping”);
XmlDocument xdoc = new XmlDocument();
xdoc.Load(myFile);
foreach (XmlNode node in xdoc.SelectNodes(@”//class/name”))
{
string sourceFileName = node.InnerText;
sourceFileName = @”Service References\” + sourceFileName + @”\Reference.cs”;
ProjectItem enumProjectItem = dte.Solution.FindProjectItem(sourceFileName);
FileCodeModel codeModel = enumProjectItem.FileCodeModel;
CodeNamespace codeNamespace = FindNamespace(codeModel.CodeElements);
CodeInterface codeInterface = FindInterface(codeModel.CodeElements);
List<CodeFunction> codeFunctions = FindMethods(codeInterface.Children);
#>
In the above code there are a couple of utility functions:
<#+
private CodeNamespace FindNamespace(CodeElements elements)
{
foreach (CodeElement element in elements)
{
CodeNamespace ns = element as CodeNamespace;
if (ns != null)
return ns;
}
return null;
}
private CodeInterface FindInterface(CodeElements elements)
{
foreach (CodeElement element in elements)
{
CodeInterface codeInterface = element as CodeInterface;
if (codeInterface != null)
return codeInterface;
codeInterface = FindInterface(element.Children);
if (codeInterface != null)
return codeInterface;
}
return null;
}
private List<CodeFunction> FindMethods(CodeElements elements)
{
List<CodeFunction> methods = new List<CodeFunction>();
foreach (CodeElement element in elements)
{
CodeFunction method = element as CodeFunction;
if (method != null)
methods.Add(method);
}
return methods;
}
private EnvDTE.DTE GetEnvDTE()
{
IServiceProvider hostServiceProvider = (IServiceProvider)Host;
if (hostServiceProvider == null)
throw new Exception(“Host property returned unexpected value (null)”);
EnvDTE.DTE dte = (EnvDTE.DTE)hostServiceProvider.GetService(typeof(EnvDTE.DTE));
if (dte == null)
throw new Exception(“Unable to retrieve EnvDTE.DTE”);
return dte;
}
#>
With the CodeFunctions in hand I am now able to create the new interface and class implementation for the autogenerated WCF facade service:
<#+
private void WriteInterface(CodeFunction method)
{
foreach(CodeElement element in method.Attributes)
{
string at = “”;
CodeAttribute att = element as CodeAttribute;
if (att != null)
{
at = at + “[“;
at = at + att.Name;
at = at + “(“;
at = at + att.Value;
at = at + “)]”;
WriteLine(at);
}
}
Write(method.Type.AsString);
Write(” “);
Write(method.Name);
Write(“(“);
string sparameter = “”;
foreach(CodeElement element in method.Parameters)
{
int count = 0;
CodeParameter parameter = element as CodeParameter;
if (parameter != null)
{
sparameter =sparameter + parameter.Type.AsString + ” “;
sparameter = sparameter + parameter.Name;
if(count < method.Parameters.Count)
sparameter = sparameter + “, “;
count++;
}
}
sparameter = sparameter.Substring(0,sparameter.Length -2);
Write(sparameter);
Write(“);”);
}
#>
And with the interface I am able to create the class the implements the interface:
<#+
private void WriteServiceClass(CodeFunction method, string servicename)
{
Write(“public “);
Write(method.Type.AsString);
Write(” “);
Write(method.Name);
Write(“(“);
string sparameter = “”;
string sparameternames = “”;
foreach(CodeElement element in method.Parameters)
{
int count = 0;
CodeParameter parameter = element as CodeParameter;
if (parameter != null)
{
sparameter =sparameter + parameter.Type.AsString + ” “;
sparameter = sparameter + parameter.Name;
sparameternames = sparameternames + parameter.Name;
if(count < method.Parameters.Count)
{
sparameter = sparameter + “, “;
sparameternames = sparameternames + “, “;
}
count++;
}
}
sparameter = sparameter.Substring(0,sparameter.Length -2);
Write(sparameter);
Write(“)”);
WriteLine(String.Empty);
WriteLine(“{“);
PushIndent(” “);
Write(“FacadeService.”);
Write(servicename);
Write(“.”);
Write(servicename);
Write(“Client service = new FacadeService.”);
Write(servicename);
Write(“.”);
Write(servicename);
Write(“Client();”);
WriteLine(String.Empty);
Write(“return service.”);
Write(method.Name);
sparameternames = sparameternames.Substring(0,sparameternames.Length -2);
Write(“(“);
Write(sparameternames);
Write(“);”);
WriteLine(String.Empty);
ClearIndent();
PushIndent(” “);
WriteLine(“}”)
}
#>
The final piece is to change the SVC file to point to the autogenerated class with changes to the Service and Codebehind attributes.
I used this article as inspiration and borrowed some lines of code from it.
With this I just have to update the service proxy and save the tt file to update my facade service and I don’t have to write copy paste code.
Random posts:
Help me, help you. You know how 😉 (click, click, click…)
The success of the product comes to light when people get excited and starts talking about it. Especially when someone like Sandro Pereira who is considered as one of the most influential person in the BizTalk community. We are really humbled and delighted to see Sandro spent lot of time figuring out the capabilities of […]
The post 7 parts series "BizTalk360 a monitoring and support tool" by Sandro Pereira appeared first on BizTalk360 Blog.
Blog Post by: Saravana Kumar
Happy New Year! Thanks for checking out my 45th interview with a thought leader in the “connected technologies” space. This month, we’re talking to Tom Canter who is theDirector of Developmentfor consultancy CCI Tec, a Microsoft “Virtual Technology Specialist (V-TS)” for BizTalk Server, and a smart, grizzled middleware guy. He’s seen it all, and I […]
Blog Post by: Richard Seroter
First of all happy new year!
In this post I would like to summarize how my year 2012 went. For one it has been a very busy year like last year 2011. To summarize all my activity bullet wise:
During 2012 I became good friends with quite a few people. Some of them I visited their homes, wedding and companies. It is great to have Kent Weare, Randal van Splunteren, Richard Seroter, Tord G. Nordahl, Sandro Pereira, Saravana Kumar, Nino Crudele, Johan Hedberg, Mikael Hakanson, Stephen W. Thomas, and Mick Badran as a friend and fellow BizTalk now Microsoft Integration MVP to collaborate with (some of them are in the picture below).
Mikael, Me, Richard, Kent, Johan, Sravana, Stephen, Tord and Mick having a drink at Earls, Bellevue.
February this year I organized a BizTalk innovation event with Saravana as one of the speakers. This turned out to be a success, which was followed up by Nino organizing one in Milan with myself, Saravana, Nino, Tord and Sandro as speakers. Again this turned out to be a successful event. In September Tord (since 1st of January 2013 also a Microsoft Integration MVP) organized a two day BizTalk Innovation event at Bouvet with the same speakers. This turned out to be a huge success.
This year in two weeks from now there will be an event with all of us speaking at the London BizTalk Summit 2013 organized by Saravana, Microsoft UK and BizTalk product group. This will be a great event for us and another possibility to speak as a group, which unofficially is named the “BizTalkCrew” (you’ll sometimes will see the hashtag BizTalkCrew in some of our tweets).
On the personal side I got interested in running and start doing so since April 2012. I have run over 200 miles so far and completed two runs (10 miles in Amsterdam, the Dam-to-Dam run and 9,5 miles in Nijmegen, Seven Hills run).
Running the Seven Hills run (Zevenheuvelen loop, Nijmegen) at 10 kilometers mark.
Besides running I dedicated most of my time with my family and friends, travelling and of course the BizTalk community. Thanks everyone for reading my blog and I will continue to share my knowledge through speaking and writing in 2013.
Cheers,
Steef-Jan
Thanks Microsoft for another wonderful start of New Year. I’m delighted to share that I have been awarded Microsoft Most Valuable Professional (MVP) 2013. For me this is the third time to receive this award and as usual on such occasions, I would like to thank my MVP Lead Cristina Herrero, BizTalk Product Team, Mandi […]
Blog Post by: Sandro Pereira
Microsoft Most Valuable Professional (MVP) program is an annual program awarded by Microsoft for most influential community members in the world. Getting an MVP status in their chosen technology area is a dream for many of the technical professionals. The MVP award is not just restricted to developers, there is no easy way to achieve […]
The post Congratulations to new and renewed Microsoft Integration MVPs (Jan 2013) appeared first on BizTalk360 Blog.
Blog Post by: Saravana Kumar
January 1st is one of 4 dates during the year when Microsoft announce their new and renewed Most Valuable Professionals (MVPs). As someone that was awarded on January 1st, it means the year starts off with a regular scan of my emails to see if my community contributions have been sufficient to be re-awarded.
Sitting proudly in my Inbox was the much anticipated email confirming that I have once again reached the bar to be an ALM MVP for another year.
In addition to my community contributions, I’ve been very busy with our TFS training curriculum. We start 2013 with 6 TFS 2012 courses, the most comprehensive curriculum for TFS 2012 in the world today. Over the next 3 months we’re also releasing two new courses to bring the total up to 8 courses.
Stay tuned for news on the following two courses.